~soren/vmbuilder/vmbuilder.refactoring

import VMBuilder.util      as util

import VMBuilder.log       as log

import VMBuilder.disk      as disk

from   VMBuilder.disk      import Disk, Filesystem

from   VMBuilder.exception import VMBuilderException, VMBuilderUserError

    result_files: A list of the files that make up the entire vm.

                  The ownership of these files will be fixed up.

 

    

        self.hypervisor = None #: hypervisor object, representing the hypervisor the vm is destined for

        self.result_files = []

        self.plugins  = []

        #: mount point where the disk images will be mounted

        self.rootmnt = None

        self.fsmounted = False

 

        self.optparser = _MyOptParser(epilog="ubuntu-vm-builder is Copyright (C) 2007-2009 Canonical Ltd. and written by Soren Hansen <soren@canonical.com>.", usage='%prog hypervisor distro [options]')

            if not(os.path.isfile(conf)):

        else:

            conf = ''

 

        self.confparser.read(['/etc/vmbuilder.cfg', os.path.expanduser('~/.vmbuilder.cfg'), conf])

 

        self._register_base_settings()

    def get_version_info(self):

        import vcsversion

        info = vcsversion.version_info

        info['major'] = 0

        info['minor'] = 11

        info['micro'] = 3

        return info

       

    def _register_base_settings(self):

        self.register_setting('-d', '--dest', dest='destdir', help='Specify the destination directory. [default: <hypervisor>-<distro>].')

        self.register_setting('-c', '--config',  type='string', help='Specify a additional configuration file')

        self.register_setting('--debug', action='callback', callback=log.set_verbosity, help='Show debug information')

        self.register_setting('-v', '--verbose', action='callback', callback=log.set_verbosity, help='Show progress information')

        self.register_setting('-q', '--quiet', action='callback', callback=log.set_verbosity, help='Silent operation')

        self.register_setting('-t', '--tmp', default=os.environ.get('TMPDIR', '/tmp'), help='Use TMP as temporary working space for image generation. Defaults to $TMPDIR if it is defined or /tmp otherwise. [default: %default]')

        self.register_setting('--templates', metavar='DIR', help='Prepend DIR to template search path.')

        self.register_setting('-o', '--overwrite', action='store_true', default=False, help='Force overwrite of destination directory if it already exist. [default: %default]')

        self.register_setting('--in-place', action='store_true', default=False, help='Install directly into the filesystem images. This is needed if your $TMPDIR is nodev and/or nosuid, but will result in slightly larger file system images.')

        self.register_setting('--tmpfs', metavar="OPTS", help='Use a tmpfs as the working directory, specifying its size or "-" to use tmpfs default (suid,dev,size=1G).')

        self.register_setting('-m', '--mem', type='int', default=128, help='Assign MEM megabytes of memory to the guest vm. [default: %default]')

        self.register_setting('--cpus', type='int', default=1, help='Number of virtual CPU\'s. [default: %default]')

 

        group = self.setting_group('Network related options')

        domainname = '.'.join(socket.gethostbyname_ex(socket.gethostname())[0].split('.')[1:]) or "defaultdomain"

        group.add_option('--domain', metavar='DOMAIN', default=domainname, help='Set DOMAIN as the domain name of the guest [default: The domain of the machine running this script: %default].')

        group.add_option('--ip', metavar='ADDRESS', default='dhcp', help='IP address in dotted form [default: %default].')

        group.add_option('--mac', metavar='VALUE', help='MAC address of the guest [default: one will be automatically generated on first run].')

        group.add_option('--mask', metavar='VALUE', help='IP mask in dotted form [default: based on ip setting]. Ignored if --ip is not specified.')

        group.add_option('--net', metavar='ADDRESS', help='IP net address in dotted form [default: based on ip setting]. Ignored if --ip is not specified.')

        group.add_option('--bcast', metavar='VALUE', help='IP broadcast in dotted form [default: based on ip setting]. Ignored if --ip is not specified.')

        group.add_option('--gw', metavar='ADDRESS', help='Gateway (router) address in dotted form [default: based on ip setting (first valid address in the network)]. Ignored if --ip is not specified.')

        group.add_option('--dns', metavar='ADDRESS', help='DNS address in dotted form [default: based on ip setting (first valid address in the network)] Ignored if --ip is not specified.')

        self.register_setting_group(group)

 

        disk = Disk(self, *args, **kwargs)

        fs = Filesystem(self, *args, **kwargs)

        getattr(self.hypervisor, func)()

    def deploy(self):

        """

        "Deploy" the VM, by asking the plugins in turn to deploy it.

 

        If no non-hypervior and non-distro plugin accepts to deploy

        the image, thfe hypervisor's default deployment is used.

 

        Returns when the first True is returned.

        """

        for plugin in self.plugins:

             if getattr(plugin, 'deploy')():

                 return True

        getattr(self.hypervisor, 'deploy')()

 

    def set_hypervisor(self, arg):

        if arg in VMBuilder.hypervisors.keys():

            self.hypervisor = VMBuilder.hypervisors[arg](self)

            self.set_defaults()

        else:

            raise VMBuilderUserError("Invalid hypervisor. Valid hypervisors: %s" % " ".join(VMBuilder.hypervisors.keys()))

 

        try:

            confvalue = self.confparser.get(self.hypervisor.arg, key)

        except ConfigParser.NoSectionError, e:

            pass

        except ConfigParser.NoOptionError, e:

            pass

        try:

            confvalue = self.confparser.get('%s/%s' % (self.hypervisor.arg, self.distro.arg), key)

        except ConfigParser.NoSectionError, e:

            pass

        except ConfigParser.NoOptionError, e:

            pass

        is called to give all the plugins and the distro and hypervisor plugin a chance to set

        if self.distro and self.hypervisor:

            self.optparser.set_defaults(destdir='%s-%s' % (self.distro.arg, self.hypervisor.arg))

            self.distro.set_defaults()

            self.hypervisor.set_defaults()

 

 

    def ip_defaults(self):

        """

        is called to validate the ip configuration given and set defaults

        """

 

        logging.debug("ip: %s" % self.ip)

        

        if self.mac:

            valid_mac_address = re.compile("([0-9a-f]{2}:){5}([0-9a-f]{2})", re.IGNORECASE)

            if not valid_mac_address.search(self.mac):

                raise VMBuilderUserError("Malformed MAC address entered: %s" % self.mac)

            else:

                logging.debug("Valid mac given: %s" % self.mac)

 

        if self.ip != 'dhcp':

            if self.domain == '':

                raise VMBuilderUserError('Domain is undefined and host has no domain set.')

 

            try:

                numip = struct.unpack('I', socket.inet_aton(self.ip))[0] 

            except socket.error:

                raise VMBuilderUserError('%s is not a valid ip address' % self.ip)

             

            if not self.mask:

                ipclass = numip & 0xFF

                if (ipclass > 0) and (ipclass <= 127):

                    mask = 0xFF

                elif (ipclass > 128) and (ipclass < 192):

                    mask = OxFFFF

                elif (ipclass < 224):

                    mask = 0xFFFFFF

                else:

                    raise VMBuilderUserError('The class of the ip address specified (%s) does not seem right' % self.ip)

            else:

                mask = struct.unpack('I', socket.inet_aton(self.mask))[0]

 

            numnet = numip & mask

 

            if not self.net:

                self.net = socket.inet_ntoa( struct.pack('I', numnet ) )

            if not self.bcast:

                self.bcast = socket.inet_ntoa( struct.pack('I', numnet + (mask ^ 0xFFFFFFFF)))

            if not self.gw:

                self.gw = socket.inet_ntoa( struct.pack('I', numnet + 0x01000000 ) )

            if not self.dns:

                self.dns = self.gw

 

            self.mask = socket.inet_ntoa( struct.pack('I', mask ) )

 

            logging.debug("net: %s" % self.net)

            logging.debug("netmask: %s" % self.mask)

            logging.debug("broadcast: %s" % self.bcast)

            logging.debug("gateway: %s" % self.gw)

            logging.debug("dns: %s" % self.dns)

 

    def create_directory_structure(self):

        """Creates the directory structure where we'll be doing all the work

 

        When create_directory_structure returns, the following attributes will be set:

 

         - L{VM.destdir}: The final destination for the disk images

         - L{VM.workdir}: The temporary directory where we'll do all the work

         - L{VM.rootmnt}: The root mount point where all the target filesystems will be mounted

         - L{VM.tmproot}: The directory where we build up the guest filesystem

 

        ..and the corresponding directories are created.

 

        Additionally, L{VM.destdir} is created, which is where the files (disk images, filesystem

        images, run scripts, etc.) will eventually be placed.

        """

 

        self.workdir = self.create_workdir()

        self.add_clean_cmd('rm', '-rf', self.workdir)

 

        logging.debug('Temporary directory: %s', self.workdir)

 

        self.rootmnt = '%s/target' % self.workdir

        logging.debug('Creating the root mount directory: %s', self.rootmnt)

        os.mkdir(self.rootmnt)

 

        self.tmproot = '%s/root' % self.workdir

        logging.debug('Creating temporary root: %s', self.tmproot)

        os.mkdir(self.tmproot)

 

        # destdir is where the user's files will land when they're done

        if os.path.exists(self.destdir):

            if self.overwrite:

                logging.info('%s exists, and --overwrite specified. Removing..' % (self.destdir, ))

                shutil.rmtree(self.destdir)

            else:

                raise VMBuilderUserError('%s already exists' % (self.destdir,))

 

        logging.debug('Creating destination directory: %s', self.destdir)

        os.mkdir(self.destdir)

        self.add_clean_cmd('rmdir', self.destdir, ignore_fail=True)

 

        self.result_files.append(self.destdir)

 

    def create_workdir(self):

        """Creates the working directory for this vm and returns its path"""

        return tempfile.mkdtemp('', 'vmbuilder', self.tmp)

        if self.in_place:

            self.installdir = self.rootmnt

        else:

            self.installdir = self.tmproot

 

        self.distro.install(self.installdir)

    def preflight_check(self):

        for opt in sum([self.confparser.options(section) for section in self.confparser.sections()], []) + [k for (k,v) in self.confparser.defaults().iteritems()]:

            if '-' in opt:

                raise VMBuilderUserError('You specified a "%s" config option in a config file, but that is not valid. Perhaps you meant "%s"?' % (opt, opt.replace('-', '_')))

 

        self.ip_defaults()

        self.call_hooks('preflight_check')

 

        # Check repository availability

        if self.mirror:

            testurl = self.mirror

        else:

            testurl = 'http://archive.ubuntu.com/'

 

        try:

            logging.debug('Testing access to %s' % testurl)

            testnet = urllib.urlopen(testurl)

        except IOError:

            raise VMBuilderUserError('Could not connect to %s. Please check your connectivity and try again.' % testurl)

 

        testnet.close()

 

        fullpath = '%s%s' % (self.installdir, path)

        finished = False

            self.preflight_check()

            self.create_directory_structure()

 

            disk.create_partitions(self)

            disk.create_filesystems(self)

            self.mount_partitions()

 

            self.install()

 

            self.umount_partitions()

 

            self.hypervisor.finalize()

 

            self.deploy()

 

            util.fix_ownership(self.result_files)

 

            finished = True

            if not finished: