Merge lp:~soren/vmbuilder/0.12.refactoring into lp:vmbuilder

[Soren Hansen]

=== modified file 'VMBuilder/__init__.py'
--- VMBuilder/__init__.py	2010-01-22 13:27:16 +0000
+++ VMBuilder/__init__.py	2010-02-18 16:03:14 +0000
@@ -31,7 +31,8 @@
 # Internal bookkeeping
 distros = {}
 hypervisors = {}
-_plugins = []
+_distro_plugins = []
+_hypervisor_plugins = []
 frontends = {}
 frontend = None
 
@@ -41,18 +42,35 @@
     """Register a hypervisor plugin with VMBuilder"""
     hypervisors[cls.arg] = cls
 
+def get_hypervisor(name):
+    if name in hypervisors:
+        return hypervisors[name]
+    else:
+        raise VMBuilderUserError('No such hypervisor. Available hypervisors: %s' % (' '.join(hypervisors.keys())))
+
 def register_distro(cls):
     """Register a distro plugin with VMBuilder"""
     distros[cls.arg] = cls
 
+def get_distro(name):
+    if name in distros:
+        return distros[name]
+    else:
+        raise VMBuilderUserError('No such distro. Available distros: %s' % (' '.join(distros.keys())))
+
 def register_frontend(cls):
     """Register a frontend plugin with VMBuilder"""
     frontends[cls.arg] = cls
 
-def register_plugin(cls):
-    """Register a plugin with VMBuilder"""
-    _plugins.append(cls)
-    _plugins.sort(key=lambda x: x.priority)
+def register_distro_plugin(cls):
+    """Register a plugin with VMBuilder"""
+    _distro_plugins.append(cls)
+    _distro_plugins.sort(key=lambda x: x.priority)
+
+def register_hypervisor_plugin(cls):
+    """Register a plugin with VMBuilder"""
+    _hypervisor_plugins.append(cls)
+    _hypervisor_plugins.sort(key=lambda x: x.priority)
 
 def set_frontend(arg):
     global frontend
@@ -65,5 +83,13 @@
     """This is sort of weird, but a handy shortcut, if you want to use one of the frontends"""
     return(frontend.run())
 
+def get_version_info():
+    import vcsversion
+    info = vcsversion.version_info
+    info['major'] = 0
+    info['minor'] = 11
+    info['micro'] = 3
+    return info
+ 
 logging.debug('Loading plugins')
 VMBuilder.plugins.load_plugins()

=== modified file 'VMBuilder/disk.py'
--- VMBuilder/disk.py	2009-10-23 07:17:47 +0000
+++ VMBuilder/disk.py	2010-02-18 16:03:14 +0000
@@ -18,7 +18,9 @@
 #
 #    Virtual disk management
 
+import fcntl
 import logging
+import os
 import os.path
 import re
 import stat
@@ -27,6 +29,7 @@
 import VMBuilder
 from   VMBuilder.util      import run_cmd 
 from   VMBuilder.exception import VMBuilderUserError, VMBuilderException
+from   struct              import unpack
 
 TYPE_EXT2 = 0
 TYPE_EXT3 = 1
@@ -34,62 +37,63 @@
 TYPE_SWAP = 3
 
 class Disk(object):
-    def __init__(self, vm, size='5G', preallocated=False, filename=None):
+    def __init__(self, vm, filename, size=None):
         """
         @type  size: string or number
         @param size: The size of the disk image (passed to L{parse_size})
 
-        @type  preallocated: boolean
-        @param preallocated: if True, the disk image already exists and will not be created (useful for raw devices)
-
         @type  filename: string
-        @param filename: force a certain filename or to give the name of the preallocated disk image
+        @param filename: filename of the disk image. If size is given, this
+                         file will be overwritten with an image of the given size
         """
 
-        # We need this for "introspection"
         self.vm = vm
-
-        # Perhaps this should be the frontend's responsibility?
-        self.size = parse_size(size)
-
-        self.preallocated = preallocated
-
-        # If filename isn't given, make one up
-        if filename:
-            self.filename = filename
+        self.filename = filename
+        self.preallocated = False
+
+        if not os.path.exists(self.filename):
+            if not size:
+                raise VMBuilderUserError('%s does not exist, but no size was given.' % (self.filename))
+            self.size = parse_size(size)
         else:
-            if self.preallocated:
-                raise VMBuilderUserError('Preallocated was set, but no filename given')
-            self.filename = 'disk%d.img' % len(self.vm.disks)
+            if size:
+                raise VMBuilderUserError('%s exists, but size was given.' % (self.filename))
+            self.preallocated = True
+            self.size = detect_size(self.filename)
 
         self.partitions = []
 
-    def devletters(self):
+    def devletters(self, vm):
         """
+        @type  vm: VM object
+        @param vm: The VM object to which the disk belongs L{parse_size})
+
         @rtype: string
         @return: the series of letters that ought to correspond to the device inside
                  the VM. E.g. the first disk of a VM would return 'a', while the 702nd would return 'zz'
         """
 
-        return index_to_devname(self.vm.disks.index(self))
-
-    def create(self, directory):
-        """
-        Creates the disk image (unless preallocated), partitions it, creates the partition mapping devices and mkfs's the partitions
-
-        @type  directory: string
-        @param directory: If set, the disk image is created in this directory
-        """
-
-        if not self.preallocated:
-            if directory:
-                self.filename = '%s/%s' % (directory, self.filename)
-            logging.info('Creating disk image: %s' % self.filename)
+        return index_to_devname(vm.disks.index(self))
+
+    def create(self):
+        """
+        Creates the disk image (unless preallocated)
+
+        It is safe to call this method even if the disk image already exists,
+        in which case, it's a no-op.
+        
+        Once this method returns, self.filename points to whatever holds the virtual disk
+        (be it a file, partition, logical volume, etc.).
+        """
+
+        if not os.path.exists(self.filename):
+            logging.info('Creating disk image: "%s" of size: %dMB' % (self.filename, self.size))
             run_cmd(qemu_img_path(), 'create', '-f', 'raw', self.filename, '%dM' % self.size)
-            os.chmod(self.filename, stat.S_IRUSR | stat.S_IWUSR)
 
-        # From here, we assume that self.filename refers to whatever holds the disk image,
-        # be it a file, a partition, logical volume, actual disk..
+    def partition(self):
+        """
+        Partitions the disk image. Call this once you've added all partitions.
+        """
 
         logging.info('Adding partition table to disk image: %s' % self.filename)
         run_cmd('parted', '--script', self.filename, 'mklabel', 'msdos')
@@ -98,6 +102,10 @@
         for part in self.partitions:
             part.create(self)
 
+    def map_partitions(self):
+        """
+        Create loop devices corresponding to the partitions
+        """
         logging.info('Creating loop devices corresponding to the created partitions')
         self.vm.add_clean_cb(lambda : self.unmap(ignore_fail=True))
         kpartx_output = run_cmd('kpartx', '-av', self.filename)
@@ -113,11 +121,12 @@
         for line in parts:
             mapdevs.append(line.split(' ')[2])
         for (part, mapdev) in zip(self.partitions, mapdevs):
-            part.mapdev = '/dev/mapper/%s' % mapdev
+            part.set_filename('/dev/mapper/%s' % mapdev)
 
         # At this point, all partitions are created and their mapping device has been
-        # created and set as .mapdev
+        # created and set as .filename
 
+    def mkfs(self):
         # Adds a filesystem to the partition
         logging.info("Creating file systems")
         for part in self.partitions:
@@ -158,16 +167,15 @@
         @type  mntpnt: string
         @param mntpnt: Intended mountpoint inside the guest of the new partition
         """
+        length = parse_size(length)
         end = begin+length-1
-        logging.debug("add_part - begin %d, length %d, end %d" % (begin, length, end))
+        logging.debug("add_part - begin %d, length %d, end %d, type %s, mntpnt %s" % (begin, length, end, type, mntpnt))
         for part in self.partitions:
             if (begin >= part.begin and begin <= part.end) or \
                 (end >= part.begin and end <= part.end):
-                raise Exception('Partitions are overlapping')
-            if begin > end:
-                raise Exception('Partition\'s last block is before its first')
-            if begin < 0 or end > self.size:
-                raise Exception('Partition is out of bounds. start=%d, end=%d, disksize=%d' % (begin,end,self.size))
+                raise VMBuilderUserError('Partitions are overlapping')
+        if begin < 0 or end > self.size:
+            raise VMBuilderUserError('Partition is out of bounds. start=%d, end=%d, disksize=%d' % (begin,end,self.size))
         part = self.Partition(disk=self, begin=begin, end=end, type=str_to_type(type), mntpnt=mntpnt)
         self.partitions.append(part)
 
@@ -211,6 +219,12 @@
             self.type = type
             self.mntpnt = mntpnt
             self.mapdev = None
+            self.fs = Filesystem(vm=self.disk.vm, preallocated=True, type=self.type, mntpnt=self.mntpnt)
+
+        def set_filename(self, filename):
+            print 'set_filename called'
+            self.filename = filename
+            self.fs.filename = filename
 
         def parted_fstype(self):
             """
@@ -226,9 +240,6 @@
 
         def mkfs(self):
             """Adds Filesystem object"""
-            if not self.mapdev:
-                raise Exception('We can\'t mkfs before we have a mapper device')
-            self.fs = Filesystem(self.disk.vm, preallocated=True, filename=self.mapdev, type=self.type, mntpnt=self.mntpnt)
             self.fs.mkfs()
 
         def get_grub_id(self):
@@ -245,11 +256,10 @@
             return self.disk.partitions.index(self)
 
 class Filesystem(object):
-    def __init__(self, vm, size=0, preallocated=False, type=None, mntpnt=None, filename=None, devletter='a', device='', dummy=False):
+    def __init__(self, vm=None, size=0, preallocated=False, type=None, mntpnt=None, filename=None, devletter='a', device='', dummy=False):
         self.vm = vm
         self.filename = filename
         self.size = parse_size(size)
-        self.preallocated = preallocated
         self.devletter = devletter
         self.device = device
         self.dummy = dummy
@@ -266,7 +276,7 @@
 
     def create(self):
         logging.info('Creating filesystem: %s, size: %d, dummy: %s' % (self.mntpnt, self.size, repr(self.dummy)))
-        if not self.preallocated:
+        if not os.path.exists(self.filename):
             logging.info('Not preallocated, so we create it.')
             if not self.filename:
                 if self.mntpnt:
@@ -288,6 +298,8 @@
         self.mkfs()
 
     def mkfs(self):
+        if not self.filename:
+            raise VMBuilderException('We can\'t mkfs if filename is not set. Did you forget to call .create()?')
         if not self.dummy:
             cmd = self.mkfs_fstype() + [self.filename]
             run_cmd(*cmd)
@@ -297,12 +309,12 @@
                 self.uuid = run_cmd('blkid', '-sUUID', '-ovalue', self.filename).rstrip()
 
     def mkfs_fstype(self):
-        if self.vm.suite in ['dapper', 'edgy', 'feisty', 'gutsy']:
-            logging.debug('%s: 128 bit inode' % self.vm.suite)
-            return { TYPE_EXT2: ['mkfs.ext2', '-F'], TYPE_EXT3: ['mkfs.ext3', '-I 128', '-F'], TYPE_XFS: ['mkfs.xfs'], TYPE_SWAP: ['mkswap'] }[self.type]
-        else:
-            logging.debug('%s: 256 bit inode' % self.vm.suite)
-            return { TYPE_EXT2: ['mkfs.ext2', '-F'], TYPE_EXT3: ['mkfs.ext3', '-F'], TYPE_XFS: ['mkfs.xfs'], TYPE_SWAP: ['mkswap'] }[self.type]
+        map = { TYPE_EXT2: ['mkfs.ext2', '-F'], TYPE_EXT3: ['mkfs.ext3', '-F'], TYPE_XFS: ['mkfs.xfs'], TYPE_SWAP: ['mkswap'] }
+
+        if not self.vm.distro.has_256_bit_inode_ext3_support():
+            map[TYPE_EXT3] = ['mkfs.ext3', '-I 128', '-F']
+
+        return map[self.type]
 
     def fstab_fstype(self):
         return { TYPE_EXT2: 'ext2', TYPE_EXT3: 'ext3', TYPE_XFS: 'xfs', TYPE_SWAP: 'swap' }[self.type]
@@ -310,10 +322,10 @@
     def fstab_options(self):
         return 'defaults'
 
-    def mount(self):
+    def mount(self, rootmnt):
         if (self.type != TYPE_SWAP) and not self.dummy:
             logging.debug('Mounting %s', self.mntpnt) 
-            self.mntpath = '%s%s' % (self.vm.rootmnt, self.mntpnt)
+            self.mntpath = '%s%s' % (rootmnt, self.mntpnt)
             if not os.path.exists(self.mntpath):
                 os.makedirs(self.mntpath)
             run_cmd('mount', '-o', 'loop', self.filename, self.mntpath)
@@ -426,6 +438,20 @@
         return suffix
     return index_to_devname(index / 26 -1, string.ascii_lowercase[index % 26]) + suffix
 
+def detect_size(filename):
+    st = os.stat(filename)
+    if stat.S_ISREG(st.st_mode):
+        return st.st_size / 1024*1024
+    elif stat.S_ISBLK(st.st_mode): 
+        # I really wish someone would make these available in Python
+        BLKGETSIZE64 = 2148012658
+        fp = open(filename, 'r')
+        fd = fp.fileno()
+        s = fcntl.ioctl(fd, BLKGETSIZE64, ' '*8)
+        return unpack('L', s)[0] / 1024*1024
+
+    raise VMBuilderException('No idea how to find the size of %s' % filename)
+
 def qemu_img_path():
     exes = ['kvm-img', 'qemu-img']
     for dir in os.environ['PATH'].split(os.path.pathsep):

=== modified file 'VMBuilder/distro.py'
--- VMBuilder/distro.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/distro.py	2010-02-18 16:03:14 +0000
@@ -17,10 +17,60 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 #    Distro super class
-from   VMBuilder.util    import run_cmd
+from   VMBuilder.util    import run_cmd, call_hooks
 import VMBuilder.plugins
-
-class Distro(VMBuilder.plugins.Plugin):
+import logging
+
+class Context(VMBuilder.plugins.Plugin):
+    def __init__(self):
+        self._config = {}
+        super(Context, self).__init__(self)
+        self.plugins = [plugin_class(self) for plugin_class in self.plugin_classes]
+        self.plugins.sort(key=lambda x:x.priority)
+        self._cleanup_cbs = []
+
+    # Cleanup 
+    def cleanup(self):
+        logging.info("Cleaning up")
+        while len(self._cleanup_cbs) > 0:
+            self._cleanup_cbs.pop(0)()
+
+    def add_clean_cb(self, cb):
+        self._cleanup_cbs.insert(0, cb)
+
+    def add_clean_cmd(self, *argv, **kwargs):
+        cb = lambda : run_cmd(*argv, **kwargs)
+        self.add_clean_cb(cb)
+        return cb
+
+    def cancel_cleanup(self, cb):
+        try:
+            self._cleanup_cbs.remove(cb)
+        except ValueError, e:
+            # Wasn't in there. No worries.
+            pass
+
+    def call_hooks(self, *args, **kwargs):
+        try:
+            call_hooks(self, *args, **kwargs)
+        except Exception, e:
+            #self.cleanup()
+            raise
+
+class Distro(Context):
+    def __init__(self):
+        self.plugin_classes = VMBuilder._distro_plugins
+        super(Distro, self).__init__()
+
+    def set_chroot_dir(self, chroot_dir):
+        self.chroot_dir = chroot_dir 
+
+    def build_chroot(self):
+        self.call_hooks('preflight_check')
+        self.call_hooks('set_defaults')
+        self.call_hooks('bootstrap')
+        self.call_hooks('configure_os')
+        
     def has_xen_support(self):
         """Install the distro into destdir"""
         raise NotImplemented('Distro subclasses need to implement the has_xen_support method')

=== modified file 'VMBuilder/exception.py'
--- VMBuilder/exception.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/exception.py	2010-02-18 16:03:14 +0000
@@ -22,6 +22,6 @@
     """Something failed inside VMBuilder"""
     pass
 
-class VMBuilderUserError(Exception):
+class VMBuilderUserError(VMBuilderException):
     """The user did something silly."""
     pass

=== modified file 'VMBuilder/frontend.py'
--- VMBuilder/frontend.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/frontend.py	2010-02-18 16:03:14 +0000
@@ -18,33 +18,36 @@
 #
 #    Frontend interface and classes
 
-import VMBuilder
-import optparse
+import VMBuilder.plugins
 
-class Frontend(object):
+class Frontend(VMBuilder.plugins.Plugin):
     def __init__(self):
-        self.settings = []
-
-    def setting_group(self, help=None):
-        return self.SettingsGroup(help)
-    
-    def add_setting_group(self, group):
-        self.settings.append(group)
-
-    def add_setting(self, **kwargs):
-        self.settings.append(Setting(**kwargs))
-
-    setting_types =  ['store', 'store']
-    class Setting(object):
-        def __init__(self, **kwargs):
-            self.shortarg = kwargs.get('shortarg', None)
-            self.longarg = kwargs.get('shortarg', None)
-            self.default = kwargs.get('default', None)
-            self.help = kwargs.get('help', None)
-            type = kwargs.get('type', 'store')
-            if type not in setting_types:
-                raise VMBuilderException("Invalid option type: %s" % type)
-
-    class SettingsGroup(Setting):
-        pass
+        self._setting_groups = []
+        self._config = {}
+        self.context = self
+
+#        self.settings = []
+
+#    def setting_group(self, help=None):
+#        return self.SettingsGroup(help)
+#    
+#    def add_setting_group(self, group):
+#        self.settings.append(group)
+#
+#    def add_setting(self, **kwargs):
+#        self.settings.append(Setting(**kwargs))
+#
+#    setting_types =  ['store', 'store']
+#    class Setting(object):
+#        def __init__(self, **kwargs):
+#            self.shortarg = kwargs.get('shortarg', None)
+#            self.longarg = kwargs.get('shortarg', None)
+#            self.default = kwargs.get('default', None)
+#            self.help = kwargs.get('help', None)
+#            type = kwargs.get('type', 'store')
+#            if type not in setting_types:
+#                raise VMBuilderException("Invalid option type: %s" % type)
+#
+#    class SettingsGroup(Setting):
+#        pass
 

=== modified file 'VMBuilder/hypervisor.py'
--- VMBuilder/hypervisor.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/hypervisor.py	2010-02-18 16:03:14 +0000
@@ -18,12 +18,75 @@
 #
 #    Hypervisor super class
 
-import VMBuilder.plugins
+import logging
+import VMBuilder.distro
+import VMBuilder.disk
+from   VMBuilder.util    import call_hooks, run_cmd, tmpdir
 
 STORAGE_DISK_IMAGE = 0
 STORAGE_FS_IMAGE = 1
 
-class Hypervisor(VMBuilder.plugins.Plugin):
-    def finalize(self):
-        raise NotImplemented('Hypervisor subclasses need to implement the finalize method')
-
+class Hypervisor(VMBuilder.distro.Context):
+    def __init__(self, distro):
+        self.plugin_classes = VMBuilder._hypervisor_plugins
+        super(Hypervisor, self).__init__()
+        self.plugins += [distro]
+        self.distro = distro
+        self.filesystems = []
+        self.disks = []
+        self.nics = []
+
+    def add_disk(self, *args, **kwargs):
+        """Adds a disk image to the virtual machine"""
+        from VMBuilder.disk import Disk
+        disk = Disk(self, *args, **kwargs)
+        self.disks.append(disk)
+        return disk
+
+    def install_os(self):
+        self.nics = [self.NIC()]
+        self.call_hooks('configure_networking', self.nics)
+        self.call_hooks('configure_mounting', self.disks, self.filesystems)
+
+        self.chroot_dir = tmpdir()
+        self.call_hooks('mount_partitions', self.chroot_dir)
+        run_cmd('rsync', '-aHA', '%s/' % self.distro.chroot_dir, self.chroot_dir)
+        self.distro.set_chroot_dir(self.chroot_dir)
+        self.call_hooks('install_bootloader', self.chroot_dir, self.disks)
+        self.call_hooks('install_kernel', self.chroot_dir)
+        self.call_hooks('unmount_partitions')
+
+    def finalise(self, destdir):
+        self.call_hooks('convert', self.disks, destdir)
+        self.call_hooks('deploy', destdir)
+
+    def mount_partitions(self, mntdir):
+        """Mounts all the vm's partitions and filesystems below .rootmnt"""
+        logging.info('Mounting target filesystems')
+        for disk in self.disks:
+            disk.create()
+            disk.partition()
+            disk.map_partitions()
+            disk.mkfs()
+        fss = VMBuilder.disk.get_ordered_filesystems(self)
+        for fs in fss:
+            fs.mount(mntdir)
+            self.distro.post_mount(fs)
+
+    def unmount_partitions(self):
+        """Unmounts all the vm's partitions and filesystems"""
+        logging.info('Unmounting target filesystem')
+        fss = VMBuilder.disk.get_ordered_filesystems(self)
+        fss.reverse()
+        for fs in fss:
+            fs.umount()
+        for disk in self.disks:
+            disk.unmap()
+
+    def convert_disks(self, disks, destdir):
+        for disk in disks:
+            disk.convert(destdir, self.filetype)
+        
+    class NIC(object):
+        def __init__(self, type='dhcp'):
+            self.type = type

=== modified file 'VMBuilder/log.py'
--- VMBuilder/log.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/log.py	2010-02-18 16:03:14 +0000
@@ -30,7 +30,7 @@
 logging.basicConfig(format=format, level=logging.DEBUG, datefmt='%Y-%m-%d %H:%M', stream=os.fdopen(fd, 'a+'), filemode='w')
 
 console = logging.StreamHandler()
-console.setLevel(logging.INFO)
+console.setLevel(logging.DEBUG)
 console.setFormatter(logging.Formatter(format))
 logging.getLogger('').addHandler(console)
 

=== modified file 'VMBuilder/plugins/__init__.py'
--- VMBuilder/plugins/__init__.py	2010-02-09 10:06:43 +0000
+++ VMBuilder/plugins/__init__.py	2010-02-18 16:03:14 +0000
@@ -20,7 +20,7 @@
 import re
 
 import VMBuilder
-from VMBuilder.util import run_cmd
+import VMBuilder.util as util
 from VMBuilder.exception import VMBuilderException
 
 def load_plugins():
@@ -39,8 +39,8 @@
 class Plugin(object):
     priority = 10
 
-    def __init__(self, vm):
-        self.vm = vm
+    def __init__(self, context):
+        self.context = context
         self._setting_groups = []
         self.register_options()
 
@@ -64,31 +64,34 @@
         """
         pass
 
-    def deploy(self):
-        """
-        Perform deployment of the VM.
-
-        If True is returned, no further deployment will be done.
-        """
-        return False
+    def install_file(self, path, contents=None, source=None, mode=None):
+        fullpath = '%s%s' % (self.chroot_dir, path)
+        if source and not contents:
+            shutil.copy(source, fullpath) 
+        else:
+            fp = open(fullpath, 'w')
+            fp.write(contents)
+            fp.close()
+        if mode:
+            os.chmod(fullpath, mode)
+        return fullpath
 
     def install_from_template(self, path, tmplname, context=None, mode=None):
-        if not self.vm.fsmounted:
-            raise VMBuilderException('install_from_template called while file system is not mounted')
-        return self.vm.install_file(path, VMBuilder.util.render_template(self.__module__.split('.')[2], self.vm, tmplname, context), mode=mode)
+        return self.install_file(path, VMBuilder.util.render_template(self.__module__.split('.')[2], self.context, tmplname, context), mode=mode)
 
     def run_in_target(self, *args, **kwargs):
-        if not self.vm.fsmounted:
-            raise VMBuilderException('install_from_template called while file system is not mounted')
-        return run_cmd('chroot', self.vm.installdir, *args, **kwargs)
+        return util.run_cmd('chroot', self.chroot_dir, *args, **kwargs)
+
+    def call_hooks(self, *args, **kwargs):
+        return util.call_hooks(self.context, *args, **kwargs)
 
     # Settings
     class SettingGroup(object):
-        def __init__(self, plugin, vm, name):
+        def __init__(self, plugin, context, name):
             # The plugin that owns this setting
             self.plugin = plugin
             # The VM object
-            self.vm = vm
+            self.context = context
             # Name of the Setting Group
             self.name = name
             # A list of Setting objects
@@ -136,18 +139,19 @@
             self.help = help
             # Alternate names (for the CLI)
             self.extra_args = extra_args or []
+            self.metavar = metavar
             self.value = None
             self.value_set = False
             self.valid_options = valid_options
 
-            if self.name in self.setting_group.vm._config:
+            if self.name in self.setting_group.context._config:
                 raise VMBuilderException("Setting named %s already exists. Previous definition in %s/%s/%s." % 
                                             (self.name,
                                              self.setting_group.plugin.__name__,
                                              self.setting_group.plugin._config[self.name].setting_group.name,
                                              self.setting_group.plugin._config[self.name].name))
 
-            self.setting_group.vm._config[self.name] = self
+            self.setting_group.context._config[self.name] = self
 
         def get_value(self):
             """
@@ -230,37 +234,40 @@
                 raise VMBuilderException('%r is type %s, expected str.' % (value, type(value)))
 
     def setting_group(self, name):
-        setting_group = self.SettingGroup(self, self.vm, name)
+        setting_group = self.SettingGroup(self, self.context, name)
         self._setting_groups.append(setting_group)
         return setting_group
 
+    def has_setting(self, name):
+        return name in self.context._config
+
     def get_setting(self, name):
-        if not name in self._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        return self._config[name].get_value()
+        return self.context._config[name].get_value()
 
     def set_setting(self, name, value):
-        if not name in self.vm._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        self._config[name].set_value(value)
+        self.context._config[name].set_value(value)
 
     def set_setting_default(self, name, value):
-        if not name in self.vm._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        self._config[name].set_default(value)
+        self.context._config[name].set_default(value)
 
     def get_setting_default(self, name):
-        if not name in self.vm._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        return self._config[name].get_default()
+        return self.context._config[name].get_default()
 
     def get_setting_valid_options(self, name):
-        if not name in self._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        return self._config[name].get_valid_options()
+        return self.context._config[name].get_valid_options()
 
     def set_setting_valid_options(self, name, valid_options):
-        if not name in self._config:
+        if not name in self.context._config:
             raise VMBuilderException('Unknown config key: %s' % name)
-        self._config[name].set_valid_options(valid_options)
+        self.context._config[name].set_valid_options(valid_options)
 

=== modified file 'VMBuilder/plugins/cli/__init__.py'
--- VMBuilder/plugins/cli/__init__.py	2009-12-08 22:27:46 +0000
+++ VMBuilder/plugins/cli/__init__.py	2010-02-18 16:03:14 +0000
@@ -19,9 +19,12 @@
 from gettext import gettext
 import logging
 import optparse
+import os
+import pwd
 import sys
 import textwrap
 import VMBuilder
+import VMBuilder.util as util
 from VMBuilder.disk import parse_size
 import VMBuilder.hypervisor
 _ = gettext
@@ -31,89 +34,145 @@
     arg = 'cli'
        
     def run(self):
-        try:
-            next = False
-            conf = None
-            for val in sys.argv:
-                if (val == '-c') | (val == '--config'):
-                    next = True
-                elif next:
-                    conf = val
-                    break
-
-            vm = VMBuilder.VM(conf)
-            vm.register_setting('--version', action='callback', callback=self.versioninfo, callback_kwargs={ 'vm' : vm }, help='Show version information')
-            vm.register_setting('--rootsize', metavar='SIZE', default=4096, help='Size (in MB) of the root filesystem [default: %default]')
-            vm.register_setting('--optsize', metavar='SIZE', default=0, help='Size (in MB) of the /opt filesystem. If not set, no /opt filesystem will be added.')
-            vm.register_setting('--swapsize', metavar='SIZE', default=1024, help='Size (in MB) of the swap partition [default: %default]')
-            vm.register_setting('--raw', metavar='PATH', type='string', help="Specify a file (or block device) to as first disk image.")
-            vm.register_setting('--part', metavar='PATH', type='string', help="Allows to specify a partition table in PATH each line of partfile should specify (root first): \n    mountpoint size \none per line, separated by space, where size is in megabytes. You can have up to 4 virtual disks, a new disk starts on a line containing only '---'. ie: \n    root 2000 \n    /boot 512 \n    swap 1000 \n    --- \n    /var 8000 \n    /var/log 2000")
-            self.set_usage(vm)
-
-            vm.optparser.disable_interspersed_args()
-            (foo, args) = vm.optparser.parse_args()
-            self.handle_args(vm, args)
-            vm.optparser.enable_interspersed_args()
-
-            for opt in vm.optparser.option_list + sum([grp.option_list for grp in vm.optparser.option_groups], []):
-                if len(opt._long_opts) > 1 or (opt.action == 'store' and opt._long_opts[0][2:] != opt.dest):
-                    opt.help += " Config option: %s" % opt.dest
-
-            (settings, args) = vm.optparser.parse_args(values=optparse.Values())
-            for (k,v) in settings.__dict__.iteritems():
-                setattr(vm, k, v)
-
-            self.set_disk_layout(vm)
-
-            vm.create()
-        except VMBuilder.VMBuilderUserError, e:
-            print >> sys.stderr, e
-            return(1)
-
-        return(0)
-
-    def versioninfo(self, option, opt, value, parser, vm=None):
-        print '%(major)d.%(minor)d.%(micro).r%(revno)d' % vm.get_version_info()
+
+        if len(sys.argv) < 3:
+            print 'Usage: %s hypervisor distro [options]' % sys.argv[0]
+            sys.exit(1)
+
+        group = self.setting_group(' ')
+        group.add_setting('config', extra_args=['-c'], type='str', help='Configuration file')
+        group.add_setting('destdir', extra_args=['-d'], type='str', help='Destination directory')
+
+        group = self.setting_group('Disk')
+        group.add_setting('rootsize', metavar='SIZE', default=4096, help='Size (in MB) of the root filesystem [default: %default]')
+        group.add_setting('optsize', metavar='SIZE', default=0, help='Size (in MB) of the /opt filesystem. If not set, no /opt filesystem will be added.')
+        group.add_setting('swapsize', metavar='SIZE', default=1024, help='Size (in MB) of the swap partition [default: %default]')
+        group.add_setting('raw', metavar='PATH', type='str', help="Specify a file (or block device) to as first disk image.")
+        group.add_setting('part', metavar='PATH', type='str', help="Allows to specify a partition table in PATH each line of partfile should specify (root first): \n    mountpoint size \none per line, separated by space, where size is in megabytes. You can have up to 4 virtual disks, a new disk starts on a line containing only '---'. ie: \n    root 2000 \n    /boot 512 \n    swap 1000 \n    --- \n    /var 8000 \n    /var/log 2000")
+        
+        optparser = optparse.OptionParser()
+        optparser.add_option('--version', action='callback', callback=self.versioninfo, help='Show version information')
+        distro_name = sys.argv[2]
+        distro_class = VMBuilder.get_distro(distro_name)
+        distro = distro_class()
+        distro.plugins.append(self)
+        self.add_settings_from_context(optparser, distro)
+
+        hypervisor_name = sys.argv[1]
+        hypervisor_class = VMBuilder.get_hypervisor(hypervisor_name)
+        hypervisor = hypervisor_class(distro)
+        hypervisor.plugins.append(self)
+        self.add_settings_from_context(optparser, hypervisor)
+
+        self.set_setting_default('destdir', '%s-%s' % (distro_name, hypervisor_name))
+
+        (options, args) = optparser.parse_args(sys.argv[2:])
+        for option in dir(options):
+            if option.startswith('_') or option in ['ensure_value', 'read_module', 'read_file']:
+                continue
+            val = getattr(options, option)
+            if val:
+                if distro.has_setting(option):
+                    distro.set_setting(option, val)
+                else:
+                    hypervisor.set_setting(option, val)
+        
+        chroot_dir = util.tmpdir()
+
+        distro.set_chroot_dir(chroot_dir)
+        distro.build_chroot()
+
+        self.set_disk_layout(hypervisor)
+        hypervisor.install_os()
+
+        destdir = self.get_setting('destdir')
+        os.mkdir(destdir)
+        self.fix_ownership(destdir)
+        hypervisor.finalise(destdir)
+
+        sys.exit(1)
+
+    def fix_ownership(self, filename):
+        """
+        Change ownership of file to $SUDO_USER.
+
+        @type  path: string
+        @param path: file or directory to give to $SUDO_USER
+        """
+
+        if 'SUDO_USER' in os.environ:
+            logging.debug('Changing ownership of %s to %s' % (filename, os.environ['SUDO_USER']))
+            (uid, gid) = pwd.getpwnam(os.environ['SUDO_USER'])[2:4]
+            os.chown(filename, uid, gid)
+
+    def add_settings_from_context(self, optparser, context):
+        setting_groups = set([setting.setting_group for setting in context._config.values()])
+        for setting_group in setting_groups:
+            optgroup = optparse.OptionGroup(optparser, setting_group.name)
+            for setting in setting_group._settings:
+                args = ['--%s' % setting.name]
+                args += setting.extra_args
+                kwargs = {}
+                if setting.help:
+                    kwargs['help'] = setting.help
+                    if len(setting.extra_args) > 0:
+                        setting.help += " Config option: %s" % setting.name
+                if setting.metavar:
+                    kwargs['metavar'] = setting.metavar
+                if setting.get_default():
+                    kwargs['default'] = setting.get_default()
+                if type(setting) == VMBuilder.plugins.Plugin.BooleanSetting:
+                    kwargs['action'] = 'store_true'
+                if type(setting) == VMBuilder.plugins.Plugin.ListSetting:
+                    kwargs['action'] = 'append'
+                optgroup.add_option(*args, **kwargs)
+            optparser.add_option_group(optgroup)
+
+    def versioninfo(self, option, opt, value, parser):
+        print '%(major)d.%(minor)d.%(micro)s.r%(revno)d' % VMBuilder.get_version_info()
         sys.exit(0)
 
-    def set_usage(self, vm):
-        vm.optparser.set_usage('%prog hypervisor distro [options]')
-        vm.optparser.arg_help = (('hypervisor', vm.hypervisor_help), ('distro', vm.distro_help))
+    def set_usage(self, optparser):
+        optparser.set_usage('%prog hypervisor distro [options]')
+        optparser.arg_help = (('hypervisor', vm.hypervisor_help), ('distro', vm.distro_help))
 
     def handle_args(self, vm, args):
         if len(args) < 2:
             vm.optparser.error("You need to specify at least the hypervisor type and the distro")
-        vm.set_hypervisor(args[0])
-        vm.set_distro(args[1])
+        self.hypervisor = vm.get_hypervisor(args[0])
+        self.distro = distro.vm.get_distro(args[1])
 
-    def set_disk_layout(self, vm):
-        if not vm.part:
-            vm.rootsize = parse_size(vm.rootsize)
-            vm.swapsize = parse_size(vm.swapsize)
-            vm.optsize = parse_size(vm.optsize)
-            if vm.hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
-                vm.add_filesystem(size='%dM' % vm.rootsize, type='ext3', mntpnt='/')
-                vm.add_filesystem(size='%dM' % vm.swapsize, type='swap', mntpnt=None)
-                if vm.optsize > 0:
-                    vm.add_filesystem(size='%dM' % optsize, type='ext3', mntpnt='/opt')
+    def set_disk_layout(self, hypervisor):
+        if not self.get_setting('part'):
+            rootsize = parse_size(self.get_setting('rootsize'))
+            swapsize = parse_size(self.get_setting('swapsize'))
+            optsize = parse_size(self.get_setting('optsize'))
+            if hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
+                hypervisor.add_filesystem(size='%dM' % rootsize, type='ext3', mntpnt='/')
+                hypervisor.add_filesystem(size='%dM' % swapsize, type='swap', mntpnt=None)
+                if optsize > 0:
+                    hypervisor.add_filesystem(size='%dM' % optsize, type='ext3', mntpnt='/opt')
             else:
-                if vm.raw:
-                    disk = vm.add_disk(filename=vm.raw, preallocated=True)
+                raw = self.get_setting('raw')
+                if raw:
+                    disk = hypervisor.add_disk(filename=raw, preallocated=True)
                 else:
-                    size = vm.rootsize + vm.swapsize + vm.optsize
-                    disk = vm.add_disk(size='%dM' % size)
+                    size = rootsize + swapsize + optsize
+                    tmpfile = util.tmpfile(keep=False)
+                    disk = hypervisor.add_disk(tmpfile, size='%dM' % size)
                 offset = 0
-                disk.add_part(offset, vm.rootsize, 'ext3', '/')
-                offset += vm.rootsize
-                disk.add_part(offset, vm.swapsize, 'swap', 'swap')
-                offset += vm.swapsize
-                if vm.optsize > 0:
-                    disk.add_part(offset, vm.optsize, 'ext3', '/opt')
+                disk.add_part(offset, rootsize, 'ext3', '/')
+                offset += rootsize
+                disk.add_part(offset, swapsize, 'swap', 'swap')
+                offset += swapsize
+                if optsize > 0:
+                    disk.add_part(offset, optsize, 'ext3', '/opt')
         else:
             # We need to parse the file specified
+            part = self.get_setting('part')
             if vm.hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
                 try:
-                    for line in file(vm.part):
+                    for line in file(part):
                         elements = line.strip().split(' ')
                         if elements[0] == 'root':
                             vm.add_filesystem(elements[1], type='ext3', mntpnt='/')
@@ -133,7 +192,7 @@
                 try:
                     curdisk = list()
                     size = 0
-                    for line in file(vm.part):
+                    for line in file(part):
                         pair = line.strip().split(' ',1) 
                         if pair[0] == '---':
                             self.do_disk(vm, curdisk, size)
@@ -167,8 +226,8 @@
     arg = 'ubuntu-vm-builder'
 
     def set_usage(self, vm):
-        vm.optparser.set_usage('%prog hypervisor suite [options]')
-        vm.optparser.arg_help = (('hypervisor', vm.hypervisor_help), ('suite', self.suite_help))
+        optparser.set_usage('%prog hypervisor suite [options]')
+        optparser.arg_help = (('hypervisor', vm.hypervisor_help), ('suite', self.suite_help))
 
     def suite_help(self):
         return 'Suite. Valid options: %s' % " ".join(VMBuilder.plugins.ubuntu.distro.Ubuntu.suites)

=== modified file 'VMBuilder/plugins/ec2/__init__.py'
--- VMBuilder/plugins/ec2/__init__.py	2009-07-07 11:14:54 +0000
+++ VMBuilder/plugins/ec2/__init__.py	2010-02-18 16:03:14 +0000
@@ -17,7 +17,7 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 import VMBuilder
-from   VMBuilder import register_plugin, Plugin, VMBuilderUserError, VMBuilderException
+from   VMBuilder import register_distro_plugin, register_hypervisor_plugin, Plugin, VMBuilderUserError, VMBuilderException
 from   VMBuilder.util import run_cmd
 import logging
 import os
@@ -27,9 +27,9 @@
 
     def register_options(self):
         # Don't pretend like we can do EC2 
-        if not isinstance(self.vm.hypervisor, VMBuilder.plugins.xen.Xen):
+        if not isinstance(self.context.hypervisor, VMBuilder.plugins.xen.Xen):
             return
-        group = self.vm.setting_group('EC2 integation')
+        group = self.context.setting_group('EC2 integation')
         group.add_option('--ec2', action='store_true', help='Build for EC2')
         group.add_option('--ec2-name','--ec2-prefix', metavar='EC2_NAME', help='Name for the EC2 image.')
         group.add_option('--ec2-cert', metavar='CERTFILE', help='PEM encoded public certificate for EC2.')
@@ -45,106 +45,106 @@
         group.add_option('--ec2-bundle', action='store_true', help='Bundle the instance')
         group.add_option('--ec2-upload', action='store_true', help='Upload the instance')
         group.add_option('--ec2-register', action='store_true', help='Register the instance')
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def preflight_check(self):
         if not getattr(self.vm, 'ec2', False):
             return True
 
-        if not self.vm.hypervisor.name == 'Xen':
+        if not self.context.hypervisor.name == 'Xen':
             raise VMBuilderUserError('When building for EC2 you must use the xen hypervisor.')
 
-        if self.vm.ec2_bundle:
+        if self.context.ec2_bundle:
             try:
                 run_cmd('ec2-ami-tools-version')
             except VMBuilderException, e:
                 raise VMBuilderUserError('You need to have the Amazon EC2 AMI tools installed')
 
-            if not self.vm.ec2_name:
+            if not self.context.ec2_name:
                 raise VMBuilderUserError('When building for EC2 you must supply the name for the image.')
 
-            if not self.vm.ec2_cert:
+            if not self.context.ec2_cert:
                 if "EC2_CERT" in os.environ:
-                    self.vm.ec2_cert = os.environ["EC2_CERT"]
+                    self.context.ec2_cert = os.environ["EC2_CERT"]
                 else:
                     raise VMBuilderUserError('When building for EC2 you must provide your PEM encoded public key certificate')
 
-            if not self.vm.ec2_key:
+            if not self.context.ec2_key:
                 if "EC2_PRIVATE_KEY" in os.environ:
-                    self.vm.ec2_key = os.environ["EC2_PRIVATE_KEY"]
+                    self.context.ec2_key = os.environ["EC2_PRIVATE_KEY"]
                 else:
                     raise VMBuilderUserError('When building for EC2 you must provide your PEM encoded private key file')
 
-            if not self.vm.ec2_user:
+            if not self.context.ec2_user:
                 raise VMBuilderUserError('When building for EC2 you must provide your EC2 user ID (your AWS account number, not your AWS access key ID)')
 
-            if not self.vm.ec2_kernel:
-                self.vm.ec2_kernel = self.vm.distro.get_ec2_kernel()
-                logging.debug('%s - to be used for AKI.' %(self.vm.ec2_kernel))
-
-            if not self.vm.ec2_ramdisk:
-                self.vm.ec2_ramdisk = self.vm.distro.ec2_ramdisk_id()
-                logging.debug('%s - to be use for the ARI.' %(self.vm.ec2_ramdisk))
-
-            if self.vm.ec2_upload:
-                if not self.vm.ec2_bucket:
+            if not self.context.ec2_kernel:
+                self.context.ec2_kernel = self.vm.distro.get_ec2_kernel()
+                logging.debug('%s - to be used for AKI.' %(self.context.ec2_kernel))
+
+            if not self.context.ec2_ramdisk:
+                self.context.ec2_ramdisk = self.vm.distro.ec2_ramdisk_id()
+                logging.debug('%s - to be use for the ARI.' %(self.context.ec2_ramdisk))
+
+            if self.context.ec2_upload:
+                if not self.context.ec2_bucket:
                     raise VMBuilderUserError('When building for EC2 you must provide an S3 bucket to hold the AMI')
 
-                if not self.vm.ec2_access_key:
+                if not self.context.ec2_access_key:
                     raise VMBuilderUserError('When building for EC2 you must provide your AWS access key ID.')
 
-                if not self.vm.ec2_secret_key:
+                if not self.context.ec2_secret_key:
                     raise VMBuilderUserError('When building for EC2 you must provide your AWS secret access key.')
 
-        if not self.vm.ec2_version:
+        if not self.context.ec2_version:
             raise VMBuilderUserError('When building for EC2 you must provide version info.')
 
-        if not self.vm.addpkg:
-             self.vm.addpkg = []
+        if not self.context.addpkg:
+             self.context.addpkg = []
 
-        if self.vm.ec2_landscape:
+        if self.context.ec2_landscape:
             logging.info('Installing landscape support')
-            self.vm.addpkg += ['landscape-client']
+            self.context.addpkg += ['landscape-client']
 
     def post_install(self):
         if not getattr(self.vm, 'ec2', False):
             return
 
         logging.info("Running ec2 postinstall")
-        self.install_from_template('/etc/ec2_version', 'ec2_version', { 'version' : self.vm.ec2_version } )
+        self.install_from_template('/etc/ec2_version', 'ec2_version', { 'version' : self.context.ec2_version } )
         self.install_from_template('/etc/ssh/sshd_config', 'sshd_config')
         self.install_from_template('/etc/sudoers', 'sudoers')
 
-        if self.vm.ec2_landscape:
+        if self.context.ec2_landscape:
             self.install_from_template('/etc/default/landscape-client', 'landscape_client')
 
-        self.vm.distro.disable_hwclock_access()
+        self.context.distro.disable_hwclock_access()
 
     def deploy(self):
         if not getattr(self.vm, 'ec2', False):
             return False
 
-        if self.vm.ec2_bundle:
+        if self.context.ec2_bundle:
             logging.info("Building EC2 bundle")
-            bundle_cmdline = ['ec2-bundle-image', '--image', self.vm.filesystems[0].filename, '--cert', self.vm.ec2_cert, '--privatekey', self.vm.ec2_key, '--user', self.vm.ec2_user, '--prefix', self.vm.ec2_name, '-r', ['i386', 'x86_64'][self.vm.arch == 'amd64'], '-d', self.vm.workdir, '--kernel', self.vm.ec2_kernel, '--ramdisk', self.vm.ec2_ramdisk]
+            bundle_cmdline = ['ec2-bundle-image', '--image', self.context.filesystems[0].filename, '--cert', self.vm.ec2_cert, '--privatekey', self.vm.ec2_key, '--user', self.vm.ec2_user, '--prefix', self.vm.ec2_name, '-r', ['i386', 'x86_64'][self.vm.arch == 'amd64'], '-d', self.vm.workdir, '--kernel', self.vm.ec2_kernel, '--ramdisk', self.vm.ec2_ramdisk]
             run_cmd(*bundle_cmdline)
 
-            manifest = '%s/%s.manifest.xml' % (self.vm.workdir, self.vm.ec2_name)
-            if self.vm.ec2_upload:
+            manifest = '%s/%s.manifest.xml' % (self.context.workdir, self.vm.ec2_name)
+            if self.context.ec2_upload:
                 logging.info("Uploading EC2 bundle")
-                upload_cmdline = ['ec2-upload-bundle', '--retry', '--manifest', manifest, '--bucket', self.vm.ec2_bucket, '--access-key', self.vm.ec2_access_key, '--secret-key', self.vm.ec2_secret_key]
+                upload_cmdline = ['ec2-upload-bundle', '--retry', '--manifest', manifest, '--bucket', self.context.ec2_bucket, '--access-key', self.vm.ec2_access_key, '--secret-key', self.vm.ec2_secret_key]
                 run_cmd(*upload_cmdline)
 
-                if self.vm.ec2_register:
+                if self.context.ec2_register:
                     from boto.ec2.connection import EC2Connection
-                    conn = EC2Connection(self.vm.ec2_access_key, self.vm.ec2_secret_key)
-                    amiid = conn.register_image('%s/%s.manifest.xml' % (self.vm.ec2_bucket, self.vm.ec2_name))
+                    conn = EC2Connection(self.context.ec2_access_key, self.vm.ec2_secret_key)
+                    amiid = conn.register_image('%s/%s.manifest.xml' % (self.context.ec2_bucket, self.vm.ec2_name))
                     print 'Image registered as %s' % amiid
             else:
-                self.vm.result_files.append(manifest)
+                self.context.result_files.append(manifest)
         else:
-            self.vm.result_files.append(self.vm.filesystems[0].filename)
+            self.context.result_files.append(self.vm.filesystems[0].filename)
 
         return True
 
-register_plugin(EC2)
+#register_plugin(EC2)

=== modified file 'VMBuilder/plugins/firstscripts/__init__.py'
--- VMBuilder/plugins/firstscripts/__init__.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/firstscripts/__init__.py	2010-02-18 16:03:14 +0000
@@ -16,7 +16,7 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-from VMBuilder import register_plugin, Plugin, VMBuilderUserError
+from VMBuilder import register_distro_plugin, Plugin, VMBuilderUserError
 from VMBuilder.util import run_cmd
 
 import logging
@@ -31,36 +31,36 @@
     name = 'First-Scripts plugin'
 
     def register_options(self):
-        group = self.vm.setting_group('Scripts')
+        group = self.context.setting_group('Scripts')
         group.add_option('--firstboot', metavar='PATH', default='', help='Specify a script that will be copied into the guest and executed the first time the machine boots.  This script must not be interactive.')
         group.add_option('--firstlogin', metavar='PATH', default='', help='Specify a script that will be copied into the guest and will be executed the first time the user logs in. This script can be interactive.')
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def preflight_check(self):
         
-        if self.vm.firstboot:
-            logging.debug("Checking if firstboot script %s exists" % (self.vm.firstboot,))
-            if not(os.path.isfile(self.vm.firstboot)):
-                raise VMBuilderUserError('The path to the first-boot script is invalid: %s. Make sure you are providing a full path.' % self.vm.firstboot)
+        if self.context.firstboot:
+            logging.debug("Checking if firstboot script %s exists" % (self.context.firstboot,))
+            if not(os.path.isfile(self.context.firstboot)):
+                raise VMBuilderUserError('The path to the first-boot script is invalid: %s. Make sure you are providing a full path.' % self.context.firstboot)
                 
-        if self.vm.firstlogin:
-            logging.debug("Checking if first login script %s exists" % (self.vm.firstlogin,))
-            if not(os.path.isfile(self.vm.firstlogin)):
-                raise VMBuilderUserError('The path to the first-login script is invalid: %s.  Make sure you are providing a full path.' % self.vm.firstlogin)
+        if self.context.firstlogin:
+            logging.debug("Checking if first login script %s exists" % (self.context.firstlogin,))
+            if not(os.path.isfile(self.context.firstlogin)):
+                raise VMBuilderUserError('The path to the first-login script is invalid: %s.  Make sure you are providing a full path.' % self.context.firstlogin)
 
     def post_install(self):
-        logging.debug("Installing firstboot script %s" % (self.vm.firstboot,))
-        if self.vm.firstboot:
-            self.vm.install_file('/root/firstboot.sh', source=self.vm.firstboot, mode=0700)
-            os.rename('%s/etc/rc.local' % self.vm.installdir, '%s/etc/rc.local.orig' % self.vm.installdir)
+        logging.debug("Installing firstboot script %s" % (self.context.firstboot,))
+        if self.context.firstboot:
+            self.context.install_file('/root/firstboot.sh', source=self.vm.firstboot, mode=0700)
+            os.rename('%s/etc/rc.local' % self.context.installdir, '%s/etc/rc.local.orig' % self.vm.installdir)
             self.install_from_template('/etc/rc.local', 'firstbootrc', mode=0755)
 
-        logging.debug("Installing first login script %s" % (self.vm.firstlogin,))
-        if self.vm.firstlogin:
-            self.vm.install_file('/root/firstlogin.sh', source=self.vm.firstlogin, mode=0755)
-            os.rename('%s/etc/bash.bashrc' % self.vm.installdir, '%s/etc/bash.bashrc.orig' % self.vm.installdir)
+        logging.debug("Installing first login script %s" % (self.context.firstlogin,))
+        if self.context.firstlogin:
+            self.context.install_file('/root/firstlogin.sh', source=self.vm.firstlogin, mode=0755)
+            os.rename('%s/etc/bash.bashrc' % self.context.installdir, '%s/etc/bash.bashrc.orig' % self.vm.installdir)
             self.install_from_template('/etc/bash.bashrc', 'firstloginrc')
 
         return True
 
-register_plugin(Firstscripts)
+#register_plugin(Firstscripts)

=== modified file 'VMBuilder/plugins/kvm/vm.py'
--- VMBuilder/plugins/kvm/vm.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/kvm/vm.py	2010-02-18 16:03:14 +0000
@@ -30,24 +30,28 @@
     preferred_storage = VMBuilder.hypervisor.STORAGE_DISK_IMAGE
     needs_bootloader = True
 
-    def finalize(self):
+    def register_options(self):
+        group = self.setting_group('VM settings')
+        group.add_setting('mem', extra_args=['-m'], default='128', help='Assign MEM megabytes of memory to the guest vm. [default: %default]')
+        group.add_setting('cpus', type='int', default=1, help='Number of virtual CPU\'s. [default: %default]')
+
+    def convert(self, disks, destdir):
         self.imgs = []
-        self.cmdline = ['kvm', '-m', str(self.vm.mem), '-smp', str(self.vm.cpus) ]
-        for disk in self.vm.disks:
-            img_path = disk.convert(self.vm.destdir, self.filetype)
+        self.cmdline = ['kvm', '-m', str(self.context.get_setting('mem')), '-smp', str(self.context.get_setting('cpus')) ]
+        for disk in disks:
+            img_path = disk.convert(destdir, self.filetype)
             self.imgs.append(img_path)
-            self.vm.result_files.append(img_path)
+            self.call_hooks('fix_ownership', img_path)
             self.cmdline += ['-drive', 'file=%s' % os.path.basename(img_path)]
-
     
         self.cmdline += ['"$@"']
 
-    def deploy(self):
-        script = '%s/run.sh' % self.vm.destdir
+    def deploy(self, destdir):
+        script = '%s/run.sh' % destdir
         fp = open(script, 'w')
         fp.write("#!/bin/sh\n\nexec %s\n" % ' '.join(self.cmdline))
         fp.close()
         os.chmod(script, stat.S_IRWXU | stat.S_IRWXU | stat.S_IROTH | stat.S_IXOTH)
-        self.vm.result_files.append(script)
+        self.call_hooks('fix_ownership', script)
 
 register_hypervisor(KVM)

=== modified file 'VMBuilder/plugins/libvirt/__init__.py'
--- VMBuilder/plugins/libvirt/__init__.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/libvirt/__init__.py	2010-02-18 16:03:14 +0000
@@ -16,53 +16,53 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-from   VMBuilder import register_plugin, Plugin, VMBuilderUserError
+from   VMBuilder import register_hypervisor_plugin, Plugin, VMBuilderUserError
 import VMBuilder.util
 
 class Libvirt(Plugin):
     name = 'libvirt integration'
 
     def register_options(self):
-        group = self.vm.setting_group('libvirt integration')
+        group = self.context.setting_group('libvirt integration')
         group.add_option('--libvirt', metavar='URI', help='Add VM to given URI')
         group.add_option('--bridge', metavar="BRIDGE", help='Set up bridged network connected to BRIDGE.')
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def all_domains(self):
         # This does not seem to work when any domain is already running
         return self.conn.listDefinedDomains() + [self.conn.lookupByID(id).name() for id in self.conn.listDomainsID()]
 
     def preflight_check(self):
-        if not self.vm.libvirt:
+        if not self.context.libvirt:
             return True
 
         import libvirt
 
-        self.conn = libvirt.open(self.vm.libvirt)
-        if self.vm.hostname in self.all_domains() and not self.vm.overwrite:
-            raise VMBuilderUserError('Domain %s already exists at %s' % (self.vm.hostname, self.vm.libvirt))
+        self.conn = libvirt.open(self.context.libvirt)
+        if self.context.hostname in self.all_domains() and not self.vm.overwrite:
+            raise VMBuilderUserError('Domain %s already exists at %s' % (self.context.hostname, self.vm.libvirt))
         
-        if not self.vm.hypervisor.name == 'KVM':
+        if not self.context.hypervisor.name == 'KVM':
             raise VMBuilderUserError('The libvirt plugin is only equiped to work with KVM at the moment.')
 
-        if not self.vm.hypervisor.name == 'KVM':
+        if not self.context.hypervisor.name == 'KVM':
             raise VMBuilderUserError('The libvirt plugin is only equiped to work with KVM at the moment.')
 
     def deploy(self):
-        if not self.vm.libvirt:
+        if not self.context.libvirt:
             # Not for us
             return False
         
-        if self.vm.hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
+        if self.context.hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
             vmxml = VMBuilder.util.render_template('libvirt', self.vm, 'libvirtxml_fsimage')
         else:
             vmxml = VMBuilder.util.render_template('libvirt', self.vm, 'libvirtxml')
 
-        if self.vm.hostname in self.all_domains() and not self.vm.overwrite:
-            raise VMBuilderUserError('Domain %s already exists at %s' % (self.vm.hostname, self.vm.libvirt))
+        if self.context.hostname in self.all_domains() and not self.vm.overwrite:
+            raise VMBuilderUserError('Domain %s already exists at %s' % (self.context.hostname, self.vm.libvirt))
         else:
             self.conn.defineXML(vmxml)
 
         return True
 
-register_plugin(Libvirt)
+#register_plugin(Libvirt)

=== modified file 'VMBuilder/plugins/network/__init__.py'
--- VMBuilder/plugins/network/__init__.py	2010-02-02 15:36:35 +0000
+++ VMBuilder/plugins/network/__init__.py	2010-02-18 16:03:14 +0000
@@ -23,7 +23,7 @@
 import struct
 import socket
 
-from   VMBuilder           import register_plugin
+from   VMBuilder           import register_hypervisor_plugin, register_distro_plugin
 from   VMBuilder.plugins   import Plugin
 from   VMBuilder.exception import VMBuilderUserError
 
@@ -64,52 +64,80 @@
 def guess_gw_from_ip(ip):
     return ip + 0x01000000
 
-class NetworkPlugin(Plugin):
+class NetworkDistroPlugin(Plugin):
+    def register_options(self):
+        group = self.setting_group('Network')
+        domainname = '.'.join(socket.gethostbyname_ex(socket.gethostname())[0].split('.')[1:]) or "defaultdomain"
+        group.add_setting('domain', metavar='DOMAIN', default=domainname, help='Set DOMAIN as the domain name of the guest [default: %default].')
+
+    def preflight_check(self):
+        domain = self.context.get_setting('domain')
+        if domain == '':
+            raise VMBuilderUserError('Domain is undefined and host has no domain set.')
+
+class NetworkHypervisorPlugin(Plugin):
+    def register_options(self):
+        group = self.setting_group('Network')
+        group.add_setting('ip', metavar='ADDRESS', default='dhcp', help='IP address in dotted form [default: %default].')
+        group.add_setting('mac', metavar='MAC', help='MAC address of the guest [default: random].')
+        group.add_setting('mask', metavar='VALUE', help='IP mask in dotted form [default: based on ip setting]. Ignored if ip is not specified.')
+        group.add_setting('net', metavar='ADDRESS', help='IP net address in dotted form [default: based on ip setting]. Ignored if ip is not specified.')
+        group.add_setting('bcast', metavar='VALUE', help='IP broadcast in dotted form [default: based on ip setting]. Ignored if ip is not specified.')
+        group.add_setting('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_setting('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.')
+
+
     def preflight_check(self):
         """
         Validate the ip configuration given and set defaults
         """
 
-        logging.debug("ip: %s" % self.vm.ip)
+        ip = self.context.get_setting('ip')
+        logging.debug("ip: %s" % ip)
         
-        if self.vm.mac:
+        mac = self.context.get_setting('mac')
+        if mac:
             if not validate_mac(mac):
                 raise VMBuilderUserError("Malformed MAC address entered: %s" % mac)
 
-        if self.vm.ip != 'dhcp':
-            if self.vm.domain == '':
-                raise VMBuilderUserError('Domain is undefined and host has no domain set.')
-
+        if ip != 'dhcp':
             # num* are numeric representations
-            numip = dotted_to_numeric_ip(self.vm.ip)
+            numip = dotted_to_numeric_ip(ip)
             
-            if not self.vm.mask:
+            mask = self.context.get_setting('mask')
+            if not mask:
                 nummask = guess_mask_from_ip(numip)
             else:
-                nummask = dotted_to_numeric_ip(self.vm.mask)
+                nummask = dotted_to_numeric_ip(mask)
 
             numnet = calculate_net_address_from_ip_and_netmask(numip, nummask)
 
-            if not self.vm.net:
-                self.vm.net = numeric_to_dotted_ip(numnet)
+            net = self.context.get_setting('net')
+            if not net:
+                self.context.set_setting('net', numeric_to_dotted_ip(numnet))
 
-            if not self.vm.bcast:
+            bcast = self.context.get_setting('bcast')
+            if not bcast:
                 numbcast = calculate_broadcast_address_from_ip_and_netmask(numnet, nummask)
-                self.vm.bcast = numeric_to_dotted_ip(numbcast)
+                self.context.set_setting('bcast', numeric_to_dotted_ip(numbcast))
 
-            if not self.vm.gw:
+            gw = self.context.get_setting('gw')
+            if not gw:
                 numgw = guess_gw_from_ip(numip)
-                self.vm.gw = numeric_to_dotted_ip(numgw)
-
-            if not self.vm.dns:
-                self.vm.dns = self.vm.gw
-
-            self.vm.mask = numeric_to_dotted_ip(nummask)
-
-            logging.debug("net: %s" % self.vm.net)
-            logging.debug("netmask: %s" % self.vm.mask)
-            logging.debug("broadcast: %s" % self.vm.bcast)
-            logging.debug("gateway: %s" % self.vm.gw)
-            logging.debug("dns: %s" % self.vm.dns)
-
-register_plugin(NetworkPlugin)
+                self.context.set_setting('gw', numeric_to_dotted_ip(numgw))
+
+            dns = self.context.get_setting('dns')
+            if not dns:
+                self.context.dns = self.context.gw
+                self.context.set_setting('dns', self.context.get_setting('gw'))
+
+            self.context.set_setting('mask', numeric_to_dotted_ip(nummask))
+
+            logging.debug("net: %s" % self.context.get_setting('net'))
+            logging.debug("netmask: %s" % self.context.get_setting('mask'))
+            logging.debug("broadcast: %s" % self.context.get_setting('bcast'))
+            logging.debug("gateway: %s" % self.context.get_setting('gw'))
+            logging.debug("dns: %s" % self.context.get_setting('dns'))
+
+register_distro_plugin(NetworkDistroPlugin)
+register_hypervisor_plugin(NetworkHypervisorPlugin)

=== modified file 'VMBuilder/plugins/postinst/__init__.py'
--- VMBuilder/plugins/postinst/__init__.py	2009-08-12 22:45:45 +0000
+++ VMBuilder/plugins/postinst/__init__.py	2010-02-18 16:03:14 +0000
@@ -16,7 +16,7 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-from VMBuilder import register_plugin, Plugin, VMBuilderUserError
+from VMBuilder import register_distro_plugin, Plugin, VMBuilderUserError
 from VMBuilder.util import run_cmd
 
 import logging
@@ -32,43 +32,43 @@
     name ='Post install plugin'
 
     def register_options(self):
-        group = self.vm.setting_group('Post install actions')
+        group = self.context.setting_group('Post install actions')
         group.add_option('--copy', metavar='FILE', help="Read 'source dest' lines from FILE, copying source files from host to dest in the guest's file system.")
         group.add_option('--execscript', '--exec', metavar='SCRIPT', help="Run SCRIPT after distro installation finishes. Script will be called with the guest's chroot as first argument, so you can use 'chroot $1 <cmd>' to run code in the virtual machine.")
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def preflight_check(self):
-        if self.vm.copy:
-            logging.debug("Checking if --copy PATH exists: %s" % self.vm.copy)
-            if not(os.path.isfile(self.vm.copy)):
-                raise VMBuilderUserError('The path to the --copy directives is invalid: %s. Make sure you are providing a full path.' % self.vm.copy)
+        if self.context.copy:
+            logging.debug("Checking if --copy PATH exists: %s" % self.context.copy)
+            if not(os.path.isfile(self.context.copy)):
+                raise VMBuilderUserError('The path to the --copy directives is invalid: %s. Make sure you are providing a full path.' % self.context.copy)
                 
-        if self.vm.execscript:
-            logging.debug("Checking if --exec PATH exists: %s" % self.vm.execscript)
-            if not(os.path.isfile(self.vm.execscript)):
-                raise VMBuilderUserError('The path to the --execscript file is invalid: %s. Make sure you are providing a full path.' % self.vm.execscript) 
+        if self.context.execscript:
+            logging.debug("Checking if --exec PATH exists: %s" % self.context.execscript)
+            if not(os.path.isfile(self.context.execscript)):
+                raise VMBuilderUserError('The path to the --execscript file is invalid: %s. Make sure you are providing a full path.' % self.context.execscript) 
 
-            logging.debug("Checking permissions of --exec PATH: %s" % self.vm.execscript)
-            if not os.access(self.vm.execscript, os.X_OK|os.R_OK):
-                raise VMBuilderUserError('The path to the --execscript file has invalid permissions: %s. Make sure the path is readable and executable.' % self.vm.execscript)
+            logging.debug("Checking permissions of --exec PATH: %s" % self.context.execscript)
+            if not os.access(self.context.execscript, os.X_OK|os.R_OK):
+                raise VMBuilderUserError('The path to the --execscript file has invalid permissions: %s. Make sure the path is readable and executable.' % self.context.execscript)
 
     def post_install(self):
-        if self.vm.copy:
-            logging.info("Copying files specified by --copy in: %s" % self.vm.copy)
+        if self.context.copy:
+            logging.info("Copying files specified by --copy in: %s" % self.context.copy)
             try:
-                for line in file(self.vm.copy):
+                for line in file(self.context.copy):
                     pair = line.strip().split(' ')
                     if len(pair) < 2: # skip blank and incomplete lines
                         continue
-                    util.run_cmd('cp', '-LpR', pair[0], '%s%s' % (self.vm.installdir, pair[1]))
+                    util.run_cmd('cp', '-LpR', pair[0], '%s%s' % (self.context.installdir, pair[1]))
 
             except IOError, (errno, strerror):
                 raise VMBuilderUserError("%s executing --copy directives: %s" % (errno, strerror))
 
-        if self.vm.execscript:
-            logging.info("Executing script: %s" % self.vm.execscript)
-            util.run_cmd(self.vm.execscript, self.vm.installdir)
+        if self.context.execscript:
+            logging.info("Executing script: %s" % self.context.execscript)
+            util.run_cmd(self.context.execscript, self.vm.installdir)
 
         return True
 
-register_plugin(postinst)
+#register_plugin(postinst)

=== modified file 'VMBuilder/plugins/ubuntu/dapper.py'
--- VMBuilder/plugins/ubuntu/dapper.py	2009-12-12 04:12:30 +0000
+++ VMBuilder/plugins/ubuntu/dapper.py	2010-02-18 16:03:14 +0000
@@ -25,7 +25,7 @@
 import tempfile
 import VMBuilder
 import VMBuilder.disk as disk
-from   VMBuilder.util import run_cmd, give_to_caller
+from   VMBuilder.util import run_cmd #, give_to_caller
 
 class Dapper(suite.Suite):
     updategrub = "/sbin/update-grub"
@@ -48,6 +48,7 @@
         return arch in self.valid_flavours.keys()
         
     def install(self, destdir):
+        raise VMBuilderException('Do not call this method!')
         self.destdir = destdir
 
         logging.debug("debootstrapping")
@@ -67,7 +68,7 @@
         logging.debug("Creating devices")
         self.create_devices()
     
-        if self.vm.hypervisor.needs_bootloader:
+        if self.distro.hypervisor.needs_bootloader:
             logging.debug("Installing grub")
             self.install_grub()
         
@@ -80,7 +81,7 @@
         logging.debug('Binding /dev and /proc filesystems')
         self.mount_dev_proc()
 
-        if self.vm.hypervisor.needs_bootloader:
+        if self.context.hypervisor.needs_bootloader:
             logging.debug("Installing menu.list")
             self.install_menu_lst()
 
@@ -120,130 +121,166 @@
         logging.debug('Unbinding /dev and /proc filesystems')
         self.unmount_dev_proc()
 
-        if hasattr(self.vm, 'ec2') and self.vm.ec2:
+        if hasattr(self.context, 'ec2') and self.context.ec2:
             logging.debug("Configuring for ec2")
             self.install_ec2()
 
         logging.debug("Unpreventing daemons from starting")
         self.unprevent_daemons_starting()
 
-        if self.vm.manifest:
+        if self.context.manifest:
             logging.debug("Creating manifest")
             manifest_contents = self.run_in_target('dpkg-query', '-W', '--showformat=${Package} ${Version}\n')
-            fp = open(self.vm.manifest, 'w')
+            fp = open(self.context.manifest, 'w')
             fp.write(manifest_contents)
             fp.close
-            give_to_caller(self.vm.manifest)
+            give_to_caller(self.context.manifest)
 
     def update(self):
         self.run_in_target('apt-get', '-y', '--force-yes', 'dist-upgrade',
                            env={ 'DEBIAN_FRONTEND' : 'noninteractive' })
         
     def install_authorized_keys(self):
-        if self.vm.ssh_key:
-            os.mkdir('%s/root/.ssh' % self.destdir, 0700)
-            shutil.copy(self.vm.ssh_key, '%s/root/.ssh/authorized_keys' % self.destdir)
-            os.chmod('%s/root/.ssh/authorized_keys' % self.destdir, 0644)
-        if self.vm.ssh_user_key:
-            os.mkdir('%s/home/%s/.ssh' % (self.destdir, self.vm.user), 0700)
-            shutil.copy(self.vm.ssh_user_key, '%s/home/%s/.ssh/authorized_keys' % (self.destdir, self.vm.user))
-            os.chmod('%s/home/%s/.ssh/authorized_keys' % (self.destdir, self.vm.user), 0644)
-            self.run_in_target('chown', '-R', '%s:%s' % (self.vm.user,)*2, '/home/%s/.ssh/' % (self.vm.user)) 
-
-        if self.vm.ssh_user_key or self.vm.ssh_key:
-            if not self.vm.addpkg:
-                self.vm.addpkg = []
-            self.vm.addpkg += ['openssh-server']
+        ssh_key = self.context.get_setting('ssh-key')
+        if ssh_key:
+            os.mkdir('%s/root/.ssh' % self.context.chroot_dir, 0700)
+            shutil.copy(ssh_key, '%s/root/.ssh/authorized_keys' % self.context.chroot_dir)
+            os.chmod('%s/root/.ssh/authorized_keys' % self.context.chroot_dir, 0644)
+
+        user = self.context.get_setting('user')
+        ssh_user_key = self.context.get_setting('ssh-user-key')
+        if ssh_user_key:
+            os.mkdir('%s/home/%s/.ssh' % (self.context.chroot_dir, user), 0700)
+            shutil.copy(ssh_user_key, '%s/home/%s/.ssh/authorized_keys' % (self.context.chroot_dir, user))
+            os.chmod('%s/home/%s/.ssh/authorized_keys' % (self.context.chroot_dir, user), 0644)
+            self.run_in_target('chown', '-R', '%s:%s' % (user,)*2, '/home/%s/.ssh/' % (user)) 
+
+        if ssh_user_key or ssh_key:
+            addpkg = self.context.get_setting('addpkg')
+            addpkg += ['openssh-server']
+            self.context.set_setting('addpkg', addpkg)
 
     def mount_dev_proc(self):
-        run_cmd('mount', '--bind', '/dev', '%s/dev' % self.destdir)
-        self.vm.add_clean_cmd('umount', '%s/dev' % self.destdir, ignore_fail=True)
+        run_cmd('mount', '--bind', '/dev', '%s/dev' % self.context.chroot_dir)
+        self.context.add_clean_cb(self.unmount_dev)
 
-        run_cmd('mount', '--bind', '/dev/pts', '%s/dev/pts' % self.destdir)
-        self.vm.add_clean_cmd('umount', '%s/dev/pts' % self.destdir, ignore_fail=True)
+        run_cmd('mount', '--bind', '/dev/pts', '%s/dev/pts' % self.context.chroot_dir)
+        self.context.add_clean_cb(self.unmount_dev_pts)
 
         self.run_in_target('mount', '-t', 'proc', 'proc', '/proc')
-        self.vm.add_clean_cmd('umount', '%s/proc' % self.destdir, ignore_fail=True)
-
-    def unmount_dev_proc(self):
-    	run_cmd('umount', '%s/dev/pts' % self.destdir)
-        run_cmd('umount', '%s/dev' % self.destdir)
-        run_cmd('umount', '%s/proc' % self.destdir)
+        self.context.add_clean_cb(self.unmount_proc)
+
+    def unmount_proc(self):
+        self.context.cancel_cleanup(self.unmount_proc)
+        run_cmd('umount', '%s/proc' % self.context.chroot_dir)
+
+    def unmount_dev_pts(self):
+        self.context.cancel_cleanup(self.unmount_dev_pts)
+    	run_cmd('umount', '%s/dev/pts' % self.context.chroot_dir)
+
+    def unmount_dev(self):
+        self.context.cancel_cleanup(self.unmount_dev)
+        run_cmd('umount', '%s/dev' % self.context.chroot_dir)
 
     def update_passwords(self):
         # Set the user password, using md5
-        self.run_in_target(stdin=('%s:%s\n' % (self.vm.user, getattr(self.vm, 'pass'))), *self.chpasswd_cmd)
+        user   = self.context.get_setting('user')
+        passwd = self.context.get_setting('pass')
+        self.run_in_target(stdin=('%s:%s\n' % (user, passwd)), *self.chpasswd_cmd)
 
         # Lock root account only if we didn't set the root password
-        if self.vm.rootpass:
-            self.run_in_target(stdin=('%s:%s\n' % ('root', self.vm.rootpass)), *self.chpasswd_cmd)
+        rootpass = self.context.get_setting('rootpass')
+        if rootpass:
+            self.run_in_target(stdin=('%s:%s\n' % ('root', rootpass)), *self.chpasswd_cmd)
         else:
             self.run_in_target('usermod', '-L', 'root')
 
-        if self.vm.lock_user:
-            logging.info('Locking %s' %(self.vm.user))
-            self.run_in_target('usermod', '-L', self.vm.user)
+        lock_user = self.context.get_setting('lock-user')
+        if lock_user:
+            logging.info('Locking %s' % (user, ))
+            self.run_in_target('usermod', '-L', user)
 
     def create_initial_user(self):
-        if self.vm.uid:
-            self.run_in_target('adduser', '--disabled-password', '--uid', self.vm.uid, '--gecos', self.vm.name, self.vm.user)
+        uid  = self.context.get_setting('uid')
+        name = self.context.get_setting('name')
+        user = self.context.get_setting('user')
+        if uid:
+            self.run_in_target('adduser', '--disabled-password', '--uid', uid, '--gecos', name, user)
         else:
-            self.run_in_target('adduser', '--disabled-password', '--gecos', self.vm.name, self.vm.user)
+            self.run_in_target('adduser', '--disabled-password', '--gecos', name, user)
+
         self.run_in_target('addgroup', '--system', 'admin')
-        self.run_in_target('adduser', self.vm.user, 'admin')
+        self.run_in_target('adduser', user, 'admin')
 
         self.install_from_template('/etc/sudoers', 'sudoers')
         for group in ['adm', 'audio', 'cdrom', 'dialout', 'floppy', 'video', 'plugdev', 'dip', 'netdev', 'powerdev', 'lpadmin', 'scanner']:
-            self.run_in_target('adduser', self.vm.user, group, ignore_fail=True)
+            self.run_in_target('adduser', user, group, ignore_fail=True)
 
         self.update_passwords()
 
     def kernel_name(self):
-        return 'linux-image-%s' % (self.vm.flavour or self.default_flavour[self.vm.arch],)
-
-    def config_network(self):
-        self.vm.install_file('/etc/hostname', self.vm.hostname)
-        self.install_from_template('/etc/hosts', 'etc_hosts', { 'hostname' : self.vm.hostname, 'domain' : self.vm.domain }) 
-        self.install_from_template('/etc/network/interfaces', 'interfaces')
+        flavour = self.context.get_setting('flavour')
+        arch = self.context.get_setting('arch')
+        return 'linux-image-%s' % (flavour or self.default_flavour[arch],)
+
+    def config_host_and_domainname(self):
+        hostname = self.context.get_setting('hostname')
+        domain = self.context.get_setting('domain')
+        self.context.install_file('/etc/hostname', hostname)
+        self.install_from_template('/etc/hosts', 'etc_hosts', { 'hostname' : hostname, 'domain' : domain }) 
+
+    def config_interfaces(self, nics):
+        self.install_from_template('/etc/network/interfaces', 'interfaces', { 'ip' : nics[0].type == 'dhcp' and 'dhcp' or nics[0].ip })
 
     def unprevent_daemons_starting(self):
-        os.unlink('%s/usr/sbin/policy-rc.d' % self.destdir)
+        os.unlink('%s/usr/sbin/policy-rc.d' % self.context.chroot_dir)
 
     def prevent_daemons_starting(self):
         os.chmod(self.install_from_template('/usr/sbin/policy-rc.d', 'nostart-policy-rc.d'), 0755)
 
     def install_extras(self):
-        if not self.vm.addpkg and not self.vm.removepkg:
+        addpkg = self.context.get_setting('addpkg')
+        removepkg = self.context.get_setting('removepkg')
+        if not addpkg and not removepkg:
             return
         cmd = ['apt-get', 'install', '-y', '--force-yes']
-        cmd += self.vm.addpkg or []
-        cmd += ['%s-' % pkg for pkg in self.vm.removepkg or []]
+        cmd += addpkg or []
+        cmd += ['%s-' % pkg for pkg in removepkg or []]
         self.run_in_target(env={ 'DEBIAN_FRONTEND' : 'noninteractive' }, *cmd)
         
     def unmount_volatile(self):
-        for mntpnt in glob.glob('%s/lib/modules/*/volatile' % self.destdir):
+        for mntpnt in glob.glob('%s/lib/modules/*/volatile' % self.context.chroot_dir):
             logging.debug("Unmounting %s" % mntpnt)
             run_cmd('umount', mntpnt)
 
-    def install_menu_lst(self):
+    def install_menu_lst(self, disks):
         self.run_in_target(self.updategrub, '-y')
-        self.mangle_grub_menu_lst()
+        self.mangle_grub_menu_lst(disks)
         self.run_in_target(self.updategrub)
         self.run_in_target('grub-set-default', '0')
 
-    def mangle_grub_menu_lst(self):
-        bootdev = disk.bootpart(self.vm.disks)
-        run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=\/dev\/hd%s%d\\2/g' % (bootdev.disk.devletters(), bootdev.get_index()+1), '%s/boot/grub/menu.lst' % self.destdir)
-        run_cmd('sed', '-ie', 's/^# groot.*/# groot %s/g' % bootdev.get_grub_id(), '%s/boot/grub/menu.lst' % self.destdir)
-        run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.destdir)
+    def mangle_grub_menu_lst(self, disks):
+        bootdev = disk.bootpart(disks)
+        run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=\/dev\/hd%s%d\\2/g' % (bootdev.disk.devletters(), bootdev.get_index()+1), '%s/boot/grub/menu.lst' % self.context.chroot_dir)
+        run_cmd('sed', '-ie', 's/^# groot.*/# groot %s/g' % bootdev.get_grub_id(), '%s/boot/grub/menu.lst' % self.context.chroot_dir)
+        run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.context.chroot_dir)
 
     def install_sources_list(self, final=False):
         if final:
-            mirror, updates_mirror, security_mirror = self.vm.mirror, self.vm.mirror, self.vm.security_mirror
+            mirror = updates_mirror = self.context.get_setting('mirror')
+            security_mirror = self.context.get_setting('security-mirror')
         else:
             mirror, updates_mirror, security_mirror = self.install_mirrors()
 
-        self.install_from_template('/etc/apt/sources.list', 'sources.list', { 'mirror' : mirror, 'security_mirror' : security_mirror, 'updates_mirror' : updates_mirror })
+        components = self.context.get_setting('components')
+        ppa        = self.context.get_setting('ppa')
+        suite      = self.context.get_setting('suite')
+        self.install_from_template('/etc/apt/sources.list', 'sources.list', { 'mirror' : mirror,
+                                                                              'security_mirror' : security_mirror,
+                                                                              'updates_mirror' : updates_mirror,
+                                                                              'components' : components,
+                                                                              'ppa' : ppa,
+                                                                              'suite' : suite })
 
         # If setting up the final mirror, allow apt-get update to fail
         # (since we might be on a complete different network than the
@@ -251,34 +288,40 @@
         self.run_in_target('apt-get', 'update', ignore_fail=final)
 
     def install_apt_proxy(self):
-        if self.vm.proxy is not None:
-            self.vm.install_file('/etc/apt/apt.conf', '// Proxy added by vmbuilder\nAcquire::http { Proxy "%s"; };' % self.vm.proxy)
+        proxy = self.context.get_setting('proxy')
+        if proxy is not None:
+            self.context.install_file('/etc/apt/apt.conf', '// Proxy added by vmbuilder\nAcquire::http { Proxy "%s"; };' % proxy)
 
-    def install_fstab(self):
-        if self.vm.hypervisor.preferred_storage == VMBuilder.hypervisor.STORAGE_FS_IMAGE:
-            self.install_from_template('/etc/fstab', 'dapper_fstab_fsimage', { 'fss' : disk.get_ordered_filesystems(self.vm), 'prefix' : self.disk_prefix })
-        else:
-            self.install_from_template('/etc/fstab', 'dapper_fstab', { 'parts' : disk.get_ordered_partitions(self.vm.disks), 'prefix' : self.disk_prefix })
+    def install_fstab(self, disks, filesystems):
+        self.install_from_template('/etc/fstab', 'dapper_fstab', { 'parts' : disk.get_ordered_partitions(disks), 'prefix' : self.disk_prefix })
 
     def install_device_map(self):
         self.install_from_template('/boot/grub/device.map', 'devicemap', { 'prefix' : self.disk_prefix })
 
     def debootstrap(self):
-        cmd = ['/usr/sbin/debootstrap', '--arch=%s' % self.vm.arch]
-        if self.vm.variant:
-            cmd += ['--variant=%s' % self.vm.variant]
-        cmd += [self.vm.suite, self.destdir, self.debootstrap_mirror()]
+        arch = self.context.get_setting('arch')
+        cmd = ['/usr/sbin/debootstrap', '--arch=%s' % arch]
+
+        variant = self.context.get_setting('variant')
+        if variant:
+            cmd += ['--variant=%s' % variant]
+
+        suite = self.context.get_setting('suite')
+        cmd += [suite, self.context.chroot_dir, self.debootstrap_mirror()]
         kwargs = { 'env' : { 'DEBIAN_FRONTEND' : 'noninteractive' } }
-        if self.vm.proxy:
-            kwargs['env']['http_proxy'] = self.vm.proxy
+
+        proxy = self.context.get_setting('proxy')
+        if proxy:
+            kwargs['env']['http_proxy'] = proxy
         run_cmd(*cmd, **kwargs)
     
     def debootstrap_mirror(self):
-        if self.vm.iso:
+        iso = self.context.get_setting('iso')
+        if iso:
             isodir = tempfile.mkdtemp()
-            self.vm.add_clean_cb(lambda:os.rmdir(isodir))
-            run_cmd('mount', '-o', 'loop', '-t', 'iso9660', self.vm.iso, isodir)
-            self.vm.add_clean_cmd('umount', isodir)
+            self.context.add_clean_cb(lambda:os.rmdir(isodir))
+            run_cmd('mount', '-o', 'loop', '-t', 'iso9660', iso, isodir)
+            self.context.add_clean_cmd('umount', isodir)
             self.iso_mounted = True
 
             return 'file://%s' % isodir
@@ -287,46 +330,48 @@
 
 
     def install_mirrors(self):
-        if self.vm.install_mirror:
-            mirror = self.vm.install_mirror
-        else:
-            mirror = self.vm.mirror
-
-        if self.vm.install_mirror:
-            updates_mirror = self.vm.install_mirror
-        else:
-            updates_mirror = self.vm.mirror
-
-        if self.vm.install_security_mirror:
-            security_mirror = self.vm.install_security_mirror
-        else:
-            security_mirror = self.vm.security_mirror
+        install_mirror = self.context.get_setting('install-mirror')
+        if install_mirror:
+            mirror = install_mirror
+        else:
+            mirror = self.context.get_setting('mirror')
+
+        updates_mirror = mirror
+
+        install_security_mirror = self.context.get_setting('install-security-mirror')
+        if install_security_mirror:
+            security_mirror = install_security_mirror
+        else:
+            security_mirror = self.context.get_setting('security-mirror')
 
         return (mirror, updates_mirror, security_mirror)
 
-    def install_kernel(self):
+    def install_kernel(self, destdir):
         self.install_from_template('/etc/kernel-img.conf', 'kernelimg', { 'updategrub' : self.updategrub }) 
-        run_cmd('chroot', self.destdir, 'apt-get', '--force-yes', '-y', 'install', self.kernel_name(), 'grub')
+        run_cmd('chroot', destdir, 'apt-get', '--force-yes', '-y', 'install', self.kernel_name(), 'grub')
 
-    def install_grub(self):
+    def install_grub(self, chroot_dir):
+        arch = self.context.get_setting('arch')
         self.run_in_target('apt-get', '--force-yes', '-y', 'install', 'grub')
-        run_cmd('rsync', '-a', '%s%s/%s/' % (self.destdir, self.grubroot, self.vm.arch == 'amd64' and 'x86_64-pc' or 'i386-pc'), '%s/boot/grub/' % self.destdir) 
+        run_cmd('rsync', '-a', '%s%s/%s/' % (chroot_dir, self.grubroot, arch == 'amd64' and 'x86_64-pc' or 'i386-pc'), '%s/boot/grub/' % chroot_dir) 
 
     def create_devices(self):
-        import VMBuilder.plugins.xen
+        pass
+# FIXME
+#        import VMBuilder.plugins.xen
 
-        if isinstance(self.vm.hypervisor, VMBuilder.plugins.xen.Xen):
-            self.run_in_target('mknod', '/dev/xvda', 'b', '202', '0')
-            self.run_in_target('mknod', '/dev/xvda1', 'b', '202', '1')
-            self.run_in_target('mknod', '/dev/xvda2', 'b', '202', '2')
-            self.run_in_target('mknod', '/dev/xvda3', 'b', '202', '3')
-            self.run_in_target('mknod', '/dev/xvc0', 'c', '204', '191')
+#        if isinstance(self.context.hypervisor, VMBuilder.plugins.xen.Xen):
+#            self.run_in_target('mknod', '/dev/xvda', 'b', '202', '0')
+#            self.run_in_target('mknod', '/dev/xvda1', 'b', '202', '1')
+#            self.run_in_target('mknod', '/dev/xvda2', 'b', '202', '2')
+#            self.run_in_target('mknod', '/dev/xvda3', 'b', '202', '3')
+#            self.run_in_target('mknod', '/dev/xvc0', 'c', '204', '191')
 
     def install_from_template(self, *args, **kwargs):
-        return self.vm.distro.install_from_template(*args, **kwargs)
+        return self.context.install_from_template(*args, **kwargs)
 
     def run_in_target(self, *args, **kwargs):
-        return self.vm.distro.run_in_target(*args, **kwargs)
+        return self.context.run_in_target(*args, **kwargs)
 
     def copy_to_target(self, infile, destpath):
         logging.debug("Copying %s on host to %s in guest" % (infile, destpath))
@@ -350,9 +395,9 @@
             self.copy_to_target('/etc/default/locale', '/etc/default/locale')
         self.run_in_target('dpkg-reconfigure', '-fnoninteractive', '-pcritical', 'libc6')
         self.run_in_target('locale-gen', 'en_US')
-        if self.vm.lang:
-            self.run_in_target('locale-gen', self.vm.lang)
-            self.install_from_template('/etc/default/locale', 'locale', { 'lang' : self.vm.lang })
+        if self.context.lang:
+            self.run_in_target('locale-gen', self.context.lang)
+            self.install_from_template('/etc/default/locale', 'locale', { 'lang' : self.context.lang })
         self.run_in_target('dpkg-reconfigure', '-fnoninteractive', '-pcritical', 'locales')
         self.run_in_target('dpkg-reconfigure', '-pcritical', 'locales')
 
@@ -360,12 +405,13 @@
         shutil.copy(logfile, '%s/var/log/vmbuilder-install.log' % (rootdir,))
 
     def set_timezone(self):
-        if self.vm.timezone:
-            os.unlink('%s/etc/localtime' % self.destdir)
-            shutil.copy('%s/usr/share/zoneinfo/%s' % (self.destdir, self.vm.timezone), '%s/etc/localtime' % (self.destdir,))
+        timezone = self.context.get_setting('timezone')
+        if timezone:
+            os.unlink('%s/etc/localtime' % self.context.chroot_dir)
+            shutil.copy('%s/usr/share/zoneinfo/%s' % (self.context.chroot_dir, timezone), '%s/etc/localtime' % (self.context.chroot_dir,))
 
     def install_ec2(self):
-        if self.vm.ec2:
+        if self.context.ec2:
             logging.debug('This suite does not support ec2')
 
     def disable_hwclock_access(self):
@@ -373,3 +419,6 @@
         fp.write('HWCLOCKACCESS=no')
         fp.close()
 
+    def has_256_bit_inode_ext3_support(self):
+        return False
+

=== modified file 'VMBuilder/plugins/ubuntu/distro.py'
--- VMBuilder/plugins/ubuntu/distro.py	2010-01-19 17:43:04 +0000
+++ VMBuilder/plugins/ubuntu/distro.py	2010-02-18 16:03:14 +0000
@@ -39,66 +39,66 @@
     xen_kernel = ''
 
     def register_options(self):
-        group = self.vm.setting_group('Package options')
-        group.add_option('--addpkg', action='append', metavar='PKG', help='Install PKG into the guest (can be specfied multiple times).')
-        group.add_option('--removepkg', action='append', metavar='PKG', help='Remove PKG from the guest (can be specfied multiple times)')
-        self.vm.register_setting_group(group)
+        group = self.setting_group('Package options')
+        group.add_setting('addpkg', type='list', metavar='PKG', help='Install PKG into the guest (can be specfied multiple times).')
+        group.add_setting('removepkg', type='list', metavar='PKG', help='Remove PKG from the guest (can be specfied multiple times)')
 
-        group = self.vm.setting_group('General OS options')
+        group = self.setting_group('General OS options')
         self.host_arch = run_cmd('dpkg', '--print-architecture').rstrip()
-        group.add_option('-a', '--arch', default=self.host_arch, help='Specify the target architecture.  Valid options: amd64 i386 lpia (defaults to host arch)')
-        group.add_option('--hostname', default='ubuntu', help='Set NAME as the hostname of the guest. Default: ubuntu. Also uses this name as the VM name.')
-        self.vm.register_setting_group(group)
-
-        group = self.vm.setting_group('Installation options')
-        group.add_option('--suite', default='jaunty', help='Suite to install. Valid options: %s [default: %%default]' % ' '.join(self.suites))
-        group.add_option('--flavour', '--kernel-flavour', help='Kernel flavour to use. Default and valid options depend on architecture and suite')
-        group.add_option('--variant', metavar='VARIANT', help='Passed to debootstrap --variant flag; use minbase, buildd, or fakechroot.')
-        group.add_option('--iso', metavar='PATH', help='Use an iso image as the source for installation of file. Full path to the iso must be provided. If --mirror is also provided, it will be used in the final sources.list of the vm.  This requires suite and kernel parameter to match what is available on the iso, obviously.')
-        group.add_option('--mirror', metavar='URL', help='Use Ubuntu mirror at URL instead of the default, which is http://archive.ubuntu.com/ubuntu for official arches and http://ports.ubuntu.com/ubuntu-ports otherwise')
-        group.add_option('--proxy', metavar='URL', help='Use proxy at URL for cached packages')
-        group.add_option('--install-mirror', metavar='URL', help='Use Ubuntu mirror at URL for the installation only. Apt\'s sources.list will still use default or URL set by --mirror')
-        group.add_option('--security-mirror', metavar='URL', help='Use Ubuntu security mirror at URL instead of the default, which is http://security.ubuntu.com/ubuntu for official arches and http://ports.ubuntu.com/ubuntu-ports otherwise.')
-        group.add_option('--install-security-mirror', metavar='URL', help='Use the security mirror at URL for installation only. Apt\'s sources.list will still use default or URL set by --security-mirror')
-        group.add_option('--components', metavar='COMPS', help='A comma seperated list of distro components to include (e.g. main,universe).')
-        group.add_option('--ppa', metavar='PPA', action='append', help='Add ppa belonging to PPA to the vm\'s sources.list.')
-        group.add_option('--lang', metavar='LANG', default=self.get_locale(), help='Set the locale to LANG [default: %default]')
-        group.add_option('--timezone', metavar='TZ', default='UTC', help='Set the timezone to TZ in the vm. [default: %default]')
-        self.vm.register_setting_group(group)
-
-        group = self.vm.setting_group('Settings for the initial user')
-        group.add_option('--user', default='ubuntu', help='Username of initial user [default: %default]')
-        group.add_option('--name', default='Ubuntu', help='Full name of initial user [default: %default]')
-        group.add_option('--pass', default='ubuntu', help='Password of initial user [default: %default]')
-        group.add_option('--rootpass', help='Initial root password (WARNING: this has strong security implications).')
-        group.add_option('--uid', help='Initial UID value.')
-        group.add_option('--gid', help='Initial GID value.')
-        group.add_option('--lock-user', action='store_true', help='Lock the initial user [default %default]')
-        self.vm.register_setting_group(group)
-
-        group = self.vm.setting_group('Other options')
-        group.add_option('--ssh-key', metavar='PATH', help='Add PATH to root\'s ~/.ssh/authorized_keys (WARNING: this has strong security implications).')
-        group.add_option('--ssh-user-key', help='Add PATH to the user\'s ~/.ssh/authorized_keys.')
-        group.add_option('--manifest', metavar='PATH', help='If passed, a manifest will be written to PATH')
-        self.vm.register_setting_group(group)
+        group.add_setting('arch', extra_args=['-a'], default=self.host_arch, help='Specify the target architecture.  Valid options: amd64 i386 lpia (defaults to host arch)')
+        group.add_setting('hostname', default='ubuntu', help='Set NAME as the hostname of the guest. Default: ubuntu. Also uses this name as the VM name.')
+
+        group = self.setting_group('Installation options')
+        group.add_setting('suite', default='jaunty', help='Suite to install. Valid options: %s [default: %%default]' % ' '.join(self.suites))
+        group.add_setting('flavour', extra_args=['--kernel-flavour'], help='Kernel flavour to use. Default and valid options depend on architecture and suite')
+        group.add_setting('variant', metavar='VARIANT', help='Passed to debootstrap --variant flag; use minbase, buildd, or fakechroot.')
+        group.add_setting('iso', metavar='PATH', help='Use an iso image as the source for installation of file. Full path to the iso must be provided. If --mirror is also provided, it will be used in the final sources.list of the vm.  This requires suite and kernel parameter to match what is available on the iso, obviously.')
+        group.add_setting('mirror', metavar='URL', help='Use Ubuntu mirror at URL instead of the default, which is http://archive.ubuntu.com/ubuntu for official arches and http://ports.ubuntu.com/ubuntu-ports otherwise')
+        group.add_setting('proxy', metavar='URL', help='Use proxy at URL for cached packages')
+        group.add_setting('install-mirror', metavar='URL', help='Use Ubuntu mirror at URL for the installation only. Apt\'s sources.list will still use default or URL set by --mirror')
+        group.add_setting('security-mirror', metavar='URL', help='Use Ubuntu security mirror at URL instead of the default, which is http://security.ubuntu.com/ubuntu for official arches and http://ports.ubuntu.com/ubuntu-ports otherwise.')
+        group.add_setting('install-security-mirror', metavar='URL', help='Use the security mirror at URL for installation only. Apt\'s sources.list will still use default or URL set by --security-mirror')
+        group.add_setting('components', type='list', metavar='COMPS', help='A comma seperated list of distro components to include (e.g. main,universe).')
+        group.add_setting('ppa', metavar='PPA', type='list', help='Add ppa belonging to PPA to the vm\'s sources.list.')
+        group.add_setting('lang', metavar='LANG', default=self.get_locale(), help='Set the locale to LANG [default: %default]')
+        group.add_setting('timezone', metavar='TZ', default='UTC', help='Set the timezone to TZ in the vm. [default: %default]')
+
+        group = self.setting_group('Settings for the initial user')
+        group.add_setting('user', default='ubuntu', help='Username of initial user [default: %default]')
+        group.add_setting('name', default='Ubuntu', help='Full name of initial user [default: %default]')
+        group.add_setting('pass', default='ubuntu', help='Password of initial user [default: %default]')
+        group.add_setting('rootpass', help='Initial root password (WARNING: this has strong security implications).')
+        group.add_setting('uid', type='int', help='Initial UID value.')
+        group.add_setting('gid', help='Initial GID value.')
+        group.add_setting('lock-user', type='bool', default=False, help='Lock the initial user [default: %default]')
+
+        group = self.setting_group('Other options')
+        group.add_setting('ssh-key', metavar='PATH', help='Add PATH to root\'s ~/.ssh/authorized_keys (WARNING: this has strong security implications).')
+        group.add_setting('ssh-user-key', help='Add PATH to the user\'s ~/.ssh/authorized_keys.')
+        group.add_setting('manifest', metavar='PATH', help='If passed, a manifest will be written to PATH')
 
     def set_defaults(self):
-        if not self.vm.mirror:
-            if self.vm.arch == 'lpia':
-                self.vm.mirror = 'http://ports.ubuntu.com/ubuntu-ports'
-            else:
-                self.vm.mirror = 'http://archive.ubuntu.com/ubuntu'
-
-        if not self.vm.security_mirror:
-            if self.vm.arch == 'lpia':
-                self.vm.security_mirror = 'http://ports.ubuntu.com/ubuntu-ports'
-            else:
-                self.vm.security_mirror = 'http://security.ubuntu.com/ubuntu'
-
-        if not self.vm.components:
-            self.vm.components = ['main', 'restricted', 'universe']
+        mirror = self.get_setting('mirror')
+        security_mirror = self.get_setting('security-mirror')
+        arch = self.get_setting('arch')
+        components = self.get_setting('components')
+
+        if not mirror:
+            if arch == 'lpia':
+                self.set_setting_default('mirror', 'http://ports.ubuntu.com/ubuntu-ports')
+            else:
+                self.set_setting_default('mirror', 'http://archive.ubuntu.com/ubuntu')
+
+        if not security_mirror:
+            if arch == 'lpia':
+                self.set_setting_default('security-mirror', 'http://ports.ubuntu.com/ubuntu-ports')
+            else:
+                self.set_setting_default('security-mirror', 'http://security.ubuntu.com/ubuntu')
+
+        if not components:
+            self.set_setting_default('components',  ['main', 'restricted', 'universe'])
         else:
-            self.vm.components = self.vm.components.split(',')
+            self.set_setting_default('components',  components.split(','))
 
     def get_locale(self):
         return os.getenv('LANG')
@@ -108,40 +108,70 @@
         lead to failure, and since we can check them before we start setting up disk
         and whatnot, we might as well go ahead an do this now."""
 
-        if not self.vm.suite in self.suites:
-            raise VMBuilderUserError('Invalid suite. Valid suites are: %s' % ' '.join(self.suites))
+        suite = self.get_setting('suite') 
+        if not suite in self.suites:
+            raise VMBuilderUserError('Invalid suite: "%s". Valid suites are: %s' % (suite, ' '.join(self.suites)))
         
-        modname = 'VMBuilder.plugins.ubuntu.%s' % (self.vm.suite, )
-        mod = __import__(modname, fromlist=[self.vm.suite])
-        self.suite = getattr(mod, self.vm.suite.capitalize())(self.vm)
+        modname = 'VMBuilder.plugins.ubuntu.%s' % (suite, )
+        mod = __import__(modname, fromlist=[suite])
+        self.suite = getattr(mod, suite.capitalize())(self)
 
-        if self.vm.arch not in self.valid_archs[self.host_arch] or  \
-            not self.suite.check_arch_validity(self.vm.arch):
-            raise VMBuilderUserError('%s is not a valid architecture. Valid architectures are: %s' % (self.vm.arch, 
+        arch = self.get_setting('arch') 
+        if arch not in self.valid_archs[self.host_arch] or  \
+            not self.suite.check_arch_validity(arch):
+            raise VMBuilderUserError('%s is not a valid architecture. Valid architectures are: %s' % (arch,
                                                                                                       ' '.join(self.valid_archs[self.host_arch])))
 
-        if not self.vm.components:
-            self.vm.components = ['main', 'restricted', 'universe']
+        components = self.get_setting('components')
+        if not components:
+            self.set_config_value_list = ['main', 'restricted', 'universe']
         else:
-            if type(self.vm.components) is str:
+            if type(components) is str:
                 self.vm.components = self.vm.components.split(',')
 
-        if self.vm.hypervisor.name == 'Xen':
-            logging.info('Xen kernel default: linux-image-%s %s', self.suite.xen_kernel_flavour, self.xen_kernel_version())
-
-        self.vm.virtio_net = self.use_virtio_net()
-
-        if self.vm.lang:
+        self.context.virtio_net = self.use_virtio_net()
+
+        lang = self.get_setting('lang')
+        if lang:
             try:
-                run_cmd('locale-gen', '%s' % self.vm.lang)
+                run_cmd('locale-gen', '%s' % lang)
             except VMBuilderException, e:
-                msg = "locale-gen does not recognize your locale '%s'" % self.vm.lang
-                raise VMBuilderUserError(msg)
-
-        if getattr(self.vm, 'ec2', False):
-            self.get_ec2_kernel()
-            self.get_ec2_ramdisk()
-            self.apply_ec2_settings()
+                raise VMBuilderUserError("Unrecognised locale: '%s'" % (lang, ))
+
+# FIXME
+#        if getattr(self.vm, 'ec2', False):
+#            self.get_ec2_kernel()
+#            self.get_ec2_ramdisk()
+#            self.apply_ec2_settings()
+
+    def bootstrap(self):
+        self.suite.debootstrap()
+        self.suite.pre_install()
+
+    def configure_os(self):
+        self.suite.install_sources_list()
+        self.suite.install_apt_proxy()
+        self.suite.create_devices()
+        self.suite.prevent_daemons_starting()
+        self.suite.mount_dev_proc()
+        self.suite.install_extras()
+        self.suite.create_initial_user()
+        self.suite.install_authorized_keys()
+        self.suite.config_host_and_domainname()
+        self.suite.set_timezone()
+        self.suite.install_sources_list(final=True)
+        self.suite.run_in_target('apt-get', 'clean');
+        self.suite.unmount_volatile()
+        self.suite.unmount_proc()
+        self.suite.unmount_dev_pts()
+        self.suite.unmount_dev()
+        self.suite.unprevent_daemons_starting()
+
+    def configure_networking(self, nics):
+        self.suite.config_interfaces(nics)
+
+    def configure_mounting(self, disks, filesystems):
+        self.suite.install_fstab(disks, filesystems)
 
     def install(self, destdir):
         self.destdir = destdir
@@ -156,37 +186,42 @@
     def use_virtio_net(self):
         return self.suite.virtio_net
 
-    def install_bootloader_cleanup(self):
-        self.vm.cancel_cleanup(self.install_bootloader_cleanup)
-        tmpdir = '%s/tmp/vmbuilder-grub' % self.destdir
+    def install_bootloader_cleanup(self, chroot_dir):
+        self.context.cancel_cleanup(self.install_bootloader_cleanup)
+        tmpdir = '%s/tmp/vmbuilder-grub' % chroot_dir
         for disk in os.listdir(tmpdir):
             if disk != 'device.map':
                 run_cmd('umount', os.path.join(tmpdir, disk))
         shutil.rmtree(tmpdir)
 
-    def install_bootloader(self):
+    def install_kernel(self, destdir):
+        self.suite.install_kernel(destdir)
+
+    def install_bootloader(self, chroot_dir, disks):
         tmpdir = '/tmp/vmbuilder-grub'
-        os.makedirs('%s%s' % (self.destdir, tmpdir))
-        self.vm.add_clean_cb(self.install_bootloader_cleanup)
+        os.makedirs('%s%s' % (chroot_dir, tmpdir))
+        self.context.add_clean_cb(self.install_bootloader_cleanup)
         devmapfile = os.path.join(tmpdir, 'device.map')
-        devmap = open('%s%s' % (self.destdir, devmapfile), 'w')
-        for (disk, id) in zip(self.vm.disks, range(len(self.vm.disks))):
+        devmap = open('%s%s' % (chroot_dir, devmapfile), 'w')
+        for (disk, id) in zip(disks, range(len(disks))):
             new_filename = os.path.join(tmpdir, os.path.basename(disk.filename))
-            open('%s%s' % (self.destdir, new_filename), 'w').close()
-            run_cmd('mount', '--bind', disk.filename, '%s%s' % (self.destdir, new_filename))
+            open('%s%s' % (chroot_dir, new_filename), 'w').close()
+            run_cmd('mount', '--bind', disk.filename, '%s%s' % (chroot_dir, new_filename))
             devmap.write("(hd%d) %s\n" % (id, new_filename))
         devmap.close()
+        self.suite.install_grub(chroot_dir)
         self.run_in_target('grub', '--device-map=%s' % devmapfile, '--batch',  stdin='''root (hd0,0)
 setup (hd0)
-EOT''')
-        self.install_bootloader_cleanup()
+EOT''') 
+        self.suite.install_menu_lst(disks)
+        self.install_bootloader_cleanup(chroot_dir)
 
     def xen_kernel_version(self):
         if self.suite.xen_kernel_flavour:
             # if this is ec2, do not call rmadison.
             # this could be replaced with a method to get most recent
             # stable kernel, but really, this is not used at all for ec2
-            if hasattr(self.vm, 'ec2') and self.vm.ec2:
+            if hasattr(self.vm, 'ec2') and self.context.ec2:
                 logging.debug("selecting ec2 kernel")
                 self.xen_kernel = "2.6.ec2-kernel"
                 return self.xen_kernel
@@ -197,7 +232,7 @@
                 for line in rmad.splitlines():
                     sline = line.split('|')
                     
-                    if sline[2].strip().startswith(self.vm.suite):
+                    if sline[2].strip().startswith(self.context.suite):
                         vt = sline[1].strip().split('.')
                         for i in range(4):
                             if int(vt[i]) > int(version[i]):
@@ -205,7 +240,7 @@
                                 break
 
                 if version[0] == '0':
-                    raise VMBuilderException('Something is wrong, no valid xen kernel for the suite %s found by rmadison' % self.vm.suite)
+                    raise VMBuilderException('Something is wrong, no valid xen kernel for the suite %s found by rmadison' % self.context.suite)
                 
                 self.xen_kernel = '%s.%s.%s-%s' % (version[0],version[1],version[2],version[3])
             return self.xen_kernel
@@ -224,13 +259,13 @@
 
     def get_ec2_kernel(self):
         if self.suite.ec2_kernel_info:
-            return self.suite.ec2_kernel_info[self.vm.arch]
+            return self.suite.ec2_kernel_info[self.context.arch]
         else:
             raise VMBuilderUserError('EC2 is not supported for the suite selected')
 
     def get_ec2_ramdisk(self):
         if self.suite.ec2_ramdisk_info:
-            return self.suite.ec2_ramdisk_info[self.vm.arch]
+            return self.suite.ec2_ramdisk_info[self.context.arch]
         else:
             raise VMBuilderUserError('EC2 is not supported for the suite selected')
 
@@ -240,4 +275,7 @@
     def apply_ec2_settings(self):
         return self.suite.apply_ec2_settings()
 
+    def has_256_bit_inode_ext3_support(self):
+        return self.suite.has_256_bit_inode_ext3_support()
+
 register_distro(Ubuntu)

=== modified file 'VMBuilder/plugins/ubuntu/edgy.py'
--- VMBuilder/plugins/ubuntu/edgy.py	2009-08-07 16:07:55 +0000
+++ VMBuilder/plugins/ubuntu/edgy.py	2010-02-18 16:03:14 +0000
@@ -31,7 +31,7 @@
     disk_prefix = 'sd'
 
     def mangle_grub_menu_lst(self):
-        bootdev = disk.bootpart(self.vm.disks)
+        bootdev = disk.bootpart(self.context.disks)
         run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=UUID=%s\\2/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.destdir)
         run_cmd('sed', '-ie', 's/^# groot.*/# groot %s/g' % bootdev.get_grub_id(), '%s/boot/grub/menu.lst' % self.destdir)
         run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.destdir)
@@ -42,7 +42,7 @@
 # <file system>                                 <mount point>   <type>  <options>       <dump>  <pass>
 proc                                            /proc           proc    defaults        0       0
 '''
-        parts = disk.get_ordered_partitions(self.vm.disks)
+        parts = disk.get_ordered_partitions(self.context.disks)
         for part in parts:
             retval += "UUID=%-40s %15s %7s %15s %d       %d\n" % (part.fs.uuid, part.fs.mntpnt, part.fs.fstab_fstype(), part.fs.fstab_options(), 0, 0)
         return retval
@@ -58,9 +58,9 @@
             self.copy_to_target('/etc/default/console-setup', '/etc/default/console-setup')
         self.run_in_target('dpkg-reconfigure', '-fnoninteractive', '-pcritical', 'tzdata')
         self.run_in_target('locale-gen', 'en_US')
-        if self.vm.lang:
-            self.run_in_target('locale-gen', self.vm.lang)
-            self.install_from_template('/etc/default/locale', 'locale', { 'lang' : self.vm.lang })
+        if self.context.lang:
+            self.run_in_target('locale-gen', self.context.lang)
+            self.install_from_template('/etc/default/locale', 'locale', { 'lang' : self.context.lang })
         self.run_in_target('dpkg-reconfigure', '-fnoninteractive', '-pcritical', 'locales')
         if have_cs:
             self.run_in_target('dpkg-reconfigure', '-fnoninteractive', '-pcritical', 'console-setup')

=== modified file 'VMBuilder/plugins/ubuntu/hardy.py'
--- VMBuilder/plugins/ubuntu/hardy.py	2009-11-05 01:42:05 +0000
+++ VMBuilder/plugins/ubuntu/hardy.py	2010-02-18 16:03:14 +0000
@@ -25,21 +25,21 @@
     ec2_ramdisk_info = { 'i386' : 'ari-6c709705', 'amd64' : 'ari-61709708' }
 
     def apply_ec2_settings(self):
-        self.vm.addpkg += ['ec2-init',
+        self.context.addpkg += ['ec2-init',
                           'openssh-server',
                           'ec2-modules',
                           'standard^',
                           'ec2-ami-tools',
                           'update-motd']
 
-        if not self.vm.ppa:
-            self.vm.ppa = []
+        if not self.context.ppa:
+            self.context.ppa = []
 
-        self.vm.ppa += ['ubuntu-on-ec2/ppa']
+        self.context.ppa += ['ubuntu-on-ec2/ppa']
 
     def install_ec2(self):
 
-        if self.vm.arch == 'i386':
+        if self.context.arch == 'i386':
             self.run_in_target('apt-get' ,'--force-yes', '-y', 'install', 'libc6-xen')
             self.run_in_target('apt-get','--purge','--force-yes', '-y', 'remove', 'libc6-i686')
             self.install_from_template('/etc/ld.so.conf.d/libc6-xen.conf', 'xen-ld-so-conf')
@@ -54,3 +54,6 @@
 
     def xen_ramdisk_path(self):
         return '/boot/initrd.img-2.6.24-19-xen'
+
+    def has_256_bit_inode_ext3_support(self):
+        return True

=== modified file 'VMBuilder/plugins/ubuntu/intrepid.py'
--- VMBuilder/plugins/ubuntu/intrepid.py	2009-11-05 01:42:05 +0000
+++ VMBuilder/plugins/ubuntu/intrepid.py	2010-02-18 16:03:14 +0000
@@ -40,7 +40,7 @@
         self.install_from_template('/etc/ec2-init/is-compat-env', 'is-compat-env')
 
     def mangle_grub_menu_lst(self):
-        bootdev = disk.bootpart(self.vm.disks)
+        bootdev = disk.bootpart(self.context.disks)
         run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=UUID=%s\\2/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.destdir)
         run_cmd('sed', '-ie', 's/^# groot.*/# groot=%s/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.destdir)
         run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.destdir)

=== modified file 'VMBuilder/plugins/ubuntu/jaunty.py'
--- VMBuilder/plugins/ubuntu/jaunty.py	2009-09-26 17:39:48 +0000
+++ VMBuilder/plugins/ubuntu/jaunty.py	2010-02-18 16:03:14 +0000
@@ -34,9 +34,9 @@
         self.install_from_template('/etc/ec2-init/is-compat-env', 'is-compat-env')
         self.run_in_target('chmod', '755', '/etc/update-motd.d/51_update-motd')
 
-    def mangle_grub_menu_lst(self):
-        bootdev = disk.bootpart(self.vm.disks)
-        run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=UUID=%s\\2/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.destdir)
-        run_cmd('sed', '-ie', 's/^# groot.*/# groot=%s/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.destdir)
-        run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.destdir)
+    def mangle_grub_menu_lst(self, disks):
+        bootdev = disk.bootpart(disks)
+        run_cmd('sed', '-ie', 's/^# kopt=root=\([^ ]*\)\(.*\)/# kopt=root=UUID=%s\\2/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.context.chroot_dir)
+        run_cmd('sed', '-ie', 's/^# groot.*/# groot=%s/g' % bootdev.fs.uuid, '%s/boot/grub/menu.lst' % self.context.chroot_dir)
+        run_cmd('sed', '-ie', '/^# kopt_2_6/ d', '%s/boot/grub/menu.lst' % self.context.chroot_dir)
 

=== modified file 'VMBuilder/plugins/ubuntu/karmic.py'
--- VMBuilder/plugins/ubuntu/karmic.py	2009-09-25 19:14:04 +0000
+++ VMBuilder/plugins/ubuntu/karmic.py	2010-02-18 16:03:14 +0000
@@ -24,8 +24,8 @@
 
 class Karmic(Jaunty):
     def apply_ec2_settings(self):
-        self.vm.addpkg += ['standard^',
+        self.context.addpkg += ['standard^',
                           'uec^']
 
     def pre_install(self):
-        self.vm.install_file('/etc/hosts', contents='')
+        self.context.install_file('/etc/hosts', contents='')

=== modified file 'VMBuilder/plugins/ubuntu/suite.py'
--- VMBuilder/plugins/ubuntu/suite.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/ubuntu/suite.py	2010-02-18 16:03:14 +0000
@@ -24,8 +24,8 @@
 import sys
 
 class Suite(object):
-    def __init__(self, vm):
-        self.vm = vm
+    def __init__(self, context):
+        self.context = context
         self.isodir = '/media/vmbuilder_inst_image'
         self.iso_mounted = False
 

=== modified file 'VMBuilder/plugins/ubuntu/templates/dapper_fstab.tmpl'
--- VMBuilder/plugins/ubuntu/templates/dapper_fstab.tmpl	2008-09-18 09:11:09 +0000
+++ VMBuilder/plugins/ubuntu/templates/dapper_fstab.tmpl	2010-02-18 16:03:14 +0000
@@ -2,6 +2,7 @@
 #
 # <file system>                                 <mount point>   <type>  <options>       <dump>  <pass>
 proc                                            /proc           proc    defaults        0       0
+#*
 #for $part in $parts
 #echo '/dev/%s%-40s %-15s %-7s %-15s %d       %d\n' % ($prefix, part.get_suffix(), part.mntpnt, part.fs.fstab_fstype(), part.fs.fstab_options(), 0, 0)
 #*

=== modified file 'VMBuilder/plugins/virtualbox/vm.py'
--- VMBuilder/plugins/virtualbox/vm.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/virtualbox/vm.py	2010-02-18 16:03:14 +0000
@@ -32,25 +32,25 @@
     arg = 'vbox'
 
     def register_options(self):
-        group = self.vm.setting_group('VirtualBox options')
+        group = self.context.setting_group('VirtualBox options')
         group.add_option('--vbox-disk-format', metavar='FORMAT', default='vdi', help='Desired disk format. Valid options are: vdi vmdk. [default: %default]')
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def finalize(self):
         self.imgs = []
-        for disk in self.vm.disks:
-            img_path = disk.convert(self.vm.destdir, self.vm.vbox_disk_format)
+        for disk in self.context.disks:
+            img_path = disk.convert(self.context.destdir, self.context.vbox_disk_format)
             self.imgs.append(img_path)
-            self.vm.result_files.append(img_path)
+            self.context.result_files.append(img_path)
 
     def deploy(self):
-        vm_deploy_script = VMBuilder.util.render_template('virtualbox', self.vm, 'vm_deploy_script', { 'os_type' : self.vm.distro.__class__.__name__, 'vm_name' : self.vm.hostname, 'vm_disks' : self.imgs, 'memory' : self.vm.mem })
+        vm_deploy_script = VMBuilder.util.render_template('virtualbox', self.context, 'vm_deploy_script', { 'os_type' : self.context.distro.__class__.__name__, 'vm_name' : self.context.hostname, 'vm_disks' : self.imgs, 'memory' : self.context.mem })
 
-        script_file = '%s/deploy_%s.sh' % (self.vm.destdir, self.vm.hostname)
+        script_file = '%s/deploy_%s.sh' % (self.context.destdir, self.context.hostname)
         fp = open(script_file, 'w')
         fp.write(vm_deploy_script)
         fp.close()
         os.chmod(script_file, stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH)
-        self.vm.result_files.append(script_file)
+        self.context.result_files.append(script_file)
 
 register_hypervisor(VirtualBox)

=== modified file 'VMBuilder/plugins/vmware/vm.py'
--- VMBuilder/plugins/vmware/vm.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/vmware/vm.py	2010-02-18 16:03:14 +0000
@@ -33,23 +33,23 @@
 
     def finalize(self):
         self.imgs = []
-        for disk in self.vm.disks:
-            img_path = disk.convert(self.vm.destdir, self.filetype)
+        for disk in self.context.disks:
+            img_path = disk.convert(self.context.destdir, self.filetype)
             self.imgs.append(img_path)
-            self.vm.result_files.append(img_path)
+            self.context.result_files.append(img_path)
 
     def disks(self):
-        return self.vm.disks
+        return self.context.disks
 
     def deploy(self):
-        vmdesc = VMBuilder.util.render_template('vmware', self.vm, self.vmxtemplate, { 'disks' : self.disks(), 'vmhwversion' : self.vmhwversion, 'cpus' : self.vm.cpus, 'mem' : self.vm.mem, 'hostname' : self.vm.hostname, 'arch' : self.vm.arch, 'guestos' : (self.vm.arch == 'amd64' and 'ubuntu-64' or 'ubuntu') })
+        vmdesc = VMBuilder.util.render_template('vmware', self.context, self.vmxtemplate, { 'disks' : self.disks(), 'vmhwversion' : self.vmhwversion, 'cpus' : self.context.cpus, 'mem' : self.context.mem, 'hostname' : self.context.hostname, 'arch' : self.context.arch, 'guestos' : (self.context.arch == 'amd64' and 'ubuntu-64' or 'ubuntu') })
 
-        vmx = '%s/%s.vmx' % (self.vm.destdir, self.vm.hostname)
+        vmx = '%s/%s.vmx' % (self.context.destdir, self.context.hostname)
         fp = open(vmx, 'w')
         fp.write(vmdesc)
         fp.close()
         os.chmod(vmx, stat.S_IRWXU | stat.S_IRWXU | stat.S_IROTH | stat.S_IXOTH)
-        self.vm.result_files.append(vmx)
+        self.context.result_files.append(vmx)
 
 class VMWareWorkstation6(VMWare):
     name = 'VMWare Workstation 6'
@@ -72,33 +72,33 @@
 
     def finalize(self):
         self.imgs = []
-        for disk in self.vm.disks:
+        for disk in self.context.disks:
 
             # Move raw image to <imagename>-flat.vmdk
             diskfilename = os.path.basename(disk.filename)
             if '.' in diskfilename:
                 diskfilename = diskfilename[:diskfilename.rindex('.')]
 
-            flat = '%s/%s-flat.vmdk' % (self.vm.destdir, diskfilename)
+            flat = '%s/%s-flat.vmdk' % (self.context.destdir, diskfilename)
             self.vmdks.append(diskfilename)
             
             move(disk.filename, flat)
             
-            self.vm.result_files.append(flat)
+            self.context.result_files.append(flat)
             
             # Create disk descriptor file            
             sectorTotal = disk.size * 2048
             sector = int(floor(sectorTotal / 16065)) # pseudo geometry
             
-            diskdescriptor = VMBuilder.util.render_template('vmware', self.vm, 'flat.vmdk',  { 'adaptertype' : self.adaptertype, 'sectors' : sector, 'diskname' : os.path.basename(flat), 'disksize' : sectorTotal })
-            vmdk = '%s/%s.vmdk' % (self.vm.destdir, diskfilename)
+            diskdescriptor = VMBuilder.util.render_template('vmware', self.context, 'flat.vmdk',  { 'adaptertype' : self.adaptertype, 'sectors' : sector, 'diskname' : os.path.basename(flat), 'disksize' : sectorTotal })
+            vmdk = '%s/%s.vmdk' % (self.context.destdir, diskfilename)
             
             fp = open(vmdk, 'w')
             fp.write(diskdescriptor)
             fp.close()
             os.chmod(vmdk, stat.S_IRWXU | stat.S_IRWXU | stat.S_IROTH | stat.S_IXOTH)
             
-            self.vm.result_files.append(vmdk)            
+            self.context.result_files.append(vmdk)            
 
     def disks(self):
         return self.vmdks

=== modified file 'VMBuilder/plugins/xen/vm.py'
--- VMBuilder/plugins/xen/vm.py	2009-06-10 13:40:41 +0000
+++ VMBuilder/plugins/xen/vm.py	2010-02-18 16:03:14 +0000
@@ -31,29 +31,29 @@
     needs_bootloader = False
 
     def register_options(self):
-        group = self.vm.setting_group('Xen option')
+        group = self.context.setting_group('Xen option')
         group.add_option('--xen-kernel', metavar='PATH', help='Path to the kernel to use (e.g.: /boot/vmlinux-2.6.27-7-server). Default depends on distribution and suite')
         group.add_option('--xen-ramdisk', metavar='PATH', help='Path to the ramdisk to use (e.g.: /boot/initrd.img-2.6.27-7-server). Default depends on distribution and suite.')
-        self.vm.register_setting_group(group)
+        self.context.register_setting_group(group)
 
     def finalize(self):
         destimages = []
-        for filesystem in self.vm.filesystems:
+        for filesystem in self.context.filesystems:
             if not filesystem.preallocated:
-                destfile = '%s/%s' % (self.vm.destdir, os.path.basename(filesystem.filename))
+                destfile = '%s/%s' % (self.context.destdir, os.path.basename(filesystem.filename))
                 logging.info('Moving %s to %s' % (filesystem.filename, destfile))
-                self.vm.result_files.append(destfile)
+                self.context.result_files.append(destfile)
                 run_cmd('cp', '--sparse=always', filesystem.filename, destfile)
                 os.unlink(filesystem.filename)
                 filesystem.filename = os.path.abspath(destfile)
                 destimages.append(destfile)
     
-        if not self.vm.xen_kernel:
-            self.vm.xen_kernel = self.vm.distro.xen_kernel_path()
-        if not self.vm.xen_ramdisk:
-            self.vm.xen_ramdisk = self.vm.distro.xen_ramdisk_path()
+        if not self.context.xen_kernel:
+            self.context.xen_kernel = self.context.distro.xen_kernel_path()
+        if not self.context.xen_ramdisk:
+            self.context.xen_ramdisk = self.context.distro.xen_ramdisk_path()
 
-        xenconf = '%s/xen.conf' % self.vm.destdir
+        xenconf = '%s/xen.conf' % self.context.destdir
         fp = open(xenconf, 'w')
         fp.write("""
 # Configuration file for the Xen instance %s, created
@@ -78,13 +78,13 @@
 
 extra = 'xencons=tty console=tty1 console=hvc0'
 
-"""  %   (self.vm.name,
-          self.vm.xen_kernel,
-          self.vm.xen_ramdisk,
-          self.vm.mem,
+"""  %   (self.context.name,
+          self.context.xen_kernel,
+          self.context.xen_ramdisk,
+          self.context.mem,
           ',\n'.join(["'tap:aio:%s,xvda%d,w'" % (os.path.abspath(img), id+1) for (img, id) in zip(destimages, range(len(destimages)))]),
-          self.vm.name))
+          self.context.name))
         fp.close()
-        self.vm.result_files.append(xenconf)
+        self.context.result_files.append(xenconf)
 
 register_hypervisor(Xen)

=== modified file 'VMBuilder/util.py'
--- VMBuilder/util.py	2009-09-16 15:27:15 +0000
+++ VMBuilder/util.py	2010-02-18 16:03:14 +0000
@@ -21,10 +21,10 @@
 import logging
 import os
 import os.path
-import pwd
 import select
 import subprocess
 import sys
+import tempfile
 import time
 from   exception        import VMBuilderException, VMBuilderUserError
 
@@ -135,19 +135,6 @@
         raise VMBuilderException, "Process (%s) returned %d. stdout: %s, stderr: %s" % (args.__repr__(), status, stdout, stderr)
     return stdout
 
-def give_to_caller(path):
-    """
-    Change ownership of file to $SUDO_USER.
-
-    @type  path: string
-    @param path: file or directory to give to $SUDO_USER
-    """
-
-    if 'SUDO_USER' in os.environ:
-        logging.debug('Changing ownership of %s to %s' % (path, os.environ['SUDO_USER']))
-        (uid, gid) = pwd.getpwnam(os.environ['SUDO_USER'])[2:4]
-        os.chown(path, uid, gid)
-
 def checkroot():
     """
     Check if we're running as root, and bail out if we're not.
@@ -156,18 +143,6 @@
     if os.geteuid() != 0:
         raise VMBuilderUserError("This script must be run as root (e.g. via sudo)")
 
-def fix_ownership(files):
-    """
-    Goes through files and fixes their ownership of them. 
-    
-    @type  files: list
-    @param files: files whose ownership should be fixed up (currently 
-                  simply calls L{give_to_caller})
-
-    """
-    for file in files:
-        give_to_caller(file)
-
 def render_template(plugin, vm, tmplname, context=None):
     # Import here to avoid having to build-dep on python-cheetah
     from   Cheetah.Template import Template
@@ -180,8 +155,8 @@
                 os.path.dirname(__file__) + '/plugins/%s/templates',
                 '/etc/vmbuilder/%s']
 
-    if vm.templates:
-        tmpldirs.insert(0,'%s/%%s' % vm.templates)
+#    if vm.templates:
+#        tmpldirs.insert(0,'%s/%%s' % vm.templates)
     
     tmpldirs = [dir % plugin for dir in tmpldirs]
 
@@ -194,3 +169,30 @@
             return output
 
     raise VMBuilderException('Template %s.tmpl not found in any of %s' % (tmplname, ', '.join(tmpldirs)))
+
+def call_hooks(context, func, *args, **kwargs):
+    logging.debug('Calling hook: %s(args=%r, kwargs=%r)' % (func, args, kwargs))
+    for plugin in context.plugins:
+        logging.debug('Calling %s method in %s plugin.' % (func, plugin.__module__))
+        getattr(plugin, func, log_no_such_method)(*args, **kwargs)
+
+    logging.debug('Calling %s method in context plugin %s.' % (func, context.__module__))
+    getattr(context, func, log_no_such_method)(*args, **kwargs)
+
+def log_no_such_method(*args, **kwargs):
+    logging.debug('No such method')
+    return
+
+def tmpfile(suffix='', keep=True):
+    (fd, filename) = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    if not keep:
+        os.unlink(filename)
+    return filename
+
+def tmpdir(suffix='', keep=True):
+    dir = tempfile.mkdtemp(suffix=suffix)
+    if not keep:
+        os.rmdir(dir)
+    return dir
+

=== modified file 'VMBuilder/vm.py'
--- VMBuilder/vm.py	2010-02-02 15:36:35 +0000
+++ VMBuilder/vm.py	2010-02-18 16:03:14 +0000
@@ -92,34 +92,6 @@
 
         self.add_clean_cmd('rm', log.logfile)
 
-    def get_version_info(self):
-        import vcsversion
-        info = vcsversion.version_info
-        info['major'] = 0
-        info['minor'] = 11
-        info['micro'] = 3
-        return info
-       
-    def cleanup(self):
-        logging.info("Cleaning up")
-        while len(self._cleanup_cbs) > 0:
-            self._cleanup_cbs.pop(0)()
-
-    def add_clean_cb(self, cb):
-        self._cleanup_cbs.insert(0, cb)
-
-    def add_clean_cmd(self, *argv, **kwargs):
-        cb = lambda : util.run_cmd(*argv, **kwargs)
-        self.add_clean_cb(cb)
-        return cb
-
-    def cancel_cleanup(self, cb):
-        try:
-            self._cleanup_cbs.remove(cb)
-        except ValueError, e:
-            # Wasn't in there. No worries.
-            pass
-
     def distro_help(self):
         return 'Distro. Valid options: %s' % " ".join(VMBuilder.distros.keys())
 
@@ -149,18 +121,6 @@
         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)
-
     def add_disk(self, *args, **kwargs):
         """Adds a disk image to the virtual machine"""
         disk = Disk(self, *args, **kwargs)
@@ -319,28 +279,6 @@
         """Creates the working directory for this vm and returns its path"""
         return tempfile.mkdtemp('', 'vmbuilder', self.tmp)
 
-    def mount_partitions(self):
-        """Mounts all the vm's partitions and filesystems below .rootmnt"""
-        logging.info('Mounting target filesystems')
-        fss = disk.get_ordered_filesystems(self)
-        for fs in fss:
-            fs.mount()
-            self.distro.post_mount(fs)
-
-        self.fsmounted = True
-
-    def umount_partitions(self):
-        """Unmounts all the vm's partitions and filesystems"""
-        logging.info('Unmounting target filesystem')
-        fss = VMBuilder.disk.get_ordered_filesystems(self)
-        fss.reverse()
-        for fs in fss:
-            fs.umount()
-        for disk in self.disks:
-            disk.unmap()
-
-        self.fsmounted = False
-
     def install(self):
         if self.in_place:
             self.installdir = self.rootmnt
@@ -383,18 +321,6 @@
 
         testnet.close()
 
-    def install_file(self, path, contents=None, source=None, mode=None):
-        fullpath = '%s%s' % (self.installdir, path)
-        if source and not contents:
-            shutil.copy(source, fullpath) 
-        else:
-            fp = open(fullpath, 'w')
-            fp.write(contents)
-            fp.close()
-        if mode:
-            os.chmod(fullpath, mode)
-        return fullpath
-
     def create(self):
         """
         The core vm creation method

=== modified file 'test/disk_tests.py'
--- test/disk_tests.py	2009-10-23 09:34:18 +0000
+++ test/disk_tests.py	2010-02-18 16:03:14 +0000
@@ -15,9 +15,36 @@
 #
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import os
+import stat
+import tempfile
 import unittest
 
-from VMBuilder.disk import parse_size, index_to_devname, devname_to_index
+import VMBuilder
+from VMBuilder.disk import parse_size, index_to_devname, devname_to_index, Disk
+from VMBuilder.exception import VMBuilderUserError
+
+def get_temp_filename():
+    (fd, tmpfile) = tempfile.mkstemp()
+    os.close(fd)
+    return tmpfile
+
+class MockDistro(object):
+    def has_256_bit_inode_ext3_support(self):
+        return True
+    
+class MockHypervisor(object):
+    def __init__(self):
+        self.disks = []
+        self.distro = MockDistro()
+
+    def add_clean_cb(self, *args, **kwargs):
+        pass
+
+    def add_disk(self, *args, **kwargs):
+        disk = Disk(self, *args, **kwargs)
+        self.disks.append(disk)
+        return disk
 
 class TestSizeParser(unittest.TestCase):
     def test_suffixesAreCaseInsensitive(self):
@@ -67,4 +94,171 @@
         for i in range(18277):
             self.assertEqual(i, devname_to_index(index_to_devname(i)))
 
-
+class TestDiskPlugin(unittest.TestCase):
+    def test_detect_size(self):
+        "detect_size returns the correct size"
+        from VMBuilder.util import run_cmd
+        from VMBuilder.disk import detect_size
+
+        tmpfile = get_temp_filename()
+        try:
+            # We assume qemu-img is well-behaved
+            run_cmd('qemu-img', 'create', tmpfile, '5G')
+            self.assertTrue(detect_size(tmpfile), 5*1024)
+
+            imgdev = run_cmd('losetup', '-f', '--show', tmpfile).strip()
+            try:
+                self.assertTrue(detect_size(imgdev), 5*1024)
+            except:
+                raise
+            finally:
+                run_cmd('losetup', '-d', imgdev)
+        except:
+            raise
+        finally:
+            os.unlink(tmpfile)
+
+    def test_disk_filename(self):
+        tmpfile = get_temp_filename()
+        os.unlink(tmpfile)
+
+        disk = Disk(MockHypervisor(), tmpfile, size='1G')
+        disk.create()
+        self.assertTrue(os.path.exists(tmpfile))
+        os.unlink(tmpfile)
+
+    def test_disk_size(self):
+        # parse_size only deals with MB resolution
+        sizes = [('10G', 10*1024*1024*1024),
+                 ('400M', 400*1024*1024),
+                 ('345', 345*1024*1024),
+                 ('10240k', 10*1024*1024),
+                 ('10250k', 10*1024*1024),
+                 ('10230k', 9*1024*1024)]
+
+        for (sizestr, size) in sizes:
+            tmpfile = get_temp_filename()
+            os.unlink(tmpfile)
+
+            disk = Disk(MockHypervisor(), filename=tmpfile, size=sizestr)
+            disk.create()
+            actual_size = os.stat(tmpfile)[stat.ST_SIZE]
+            self.assertEqual(size, actual_size, 'Asked for %s, expected %d, got %d' % (sizestr, size, actual_size))
+            os.unlink(tmpfile)
+
+
+    def test_disk_no_size_given(self):
+        tmpname = get_temp_filename()
+        os.unlink(tmpname)
+
+        self.assertRaises(VMBuilderUserError, Disk, MockHypervisor(), filename=tmpname)
+
+    def test_disk_size_given_file_exists(self):
+        tmpname = get_temp_filename()
+
+        self.assertRaises(VMBuilderUserError, Disk, MockHypervisor(), filename=tmpname, size='1G')
+
+    def test_existing_image_no_overwrite(self):
+        tmpfile = get_temp_filename()
+
+        fp = open(tmpfile, 'w')
+        fp.write('canary')
+        fp.close()
+
+        disk = Disk(MockHypervisor(), tmpfile)
+        disk.create()
+        fp = open(tmpfile, 'r')
+        self.assertEqual(fp.read(), 'canary')
+        fp.close()
+        os.unlink(tmpfile)
+
+class TestDiskPartitioningPlugin(unittest.TestCase):
+    def setUp(self):
+        self.tmpfile = get_temp_filename()
+        os.unlink(self.tmpfile)
+
+        self.vm = MockHypervisor()
+        self.disk = self.vm.add_disk(self.tmpfile, size='1G')
+        self.disk.create()
+
+    def tearDown(self):
+        os.unlink(self.tmpfile)
+
+    def test_partition_overlap(self):
+        self.disk.add_part(1, 512, 'ext3', '/')
+        self.assertRaises(VMBuilderUserError, self.disk.add_part, 512, 512, 'ext3', '/mnt')
+
+    def test_partition_extends_beyond_disk(self):
+        self.assertRaises(VMBuilderUserError, self.disk.add_part, 512, 514, 'ext3', '/')
+
+    def test_partition_table_empty(self):
+        from VMBuilder.util import run_cmd
+
+        file_output = run_cmd('file', self.tmpfile)
+        self.assertEqual('%s: data' % self.tmpfile, file_output.strip())
+        self.disk.partition()
+        file_output = run_cmd('file', self.tmpfile)
+        self.assertEqual('%s: x86 boot sector, code offset 0xb8' % self.tmpfile, file_output.strip())
+
+        file_output = run_cmd('parted', '--script', self.tmpfile, 'print')
+        self.assertEqual('''Model:  (file)
+Disk %s: 1074MB
+Sector size (logical/physical): 512B/512B
+Partition Table: msdos
+
+Number  Start  End  Size  Type  File system  Flags''' % self.tmpfile, file_output.strip())
+        
+    def test_partition_table_nonempty(self):
+        from VMBuilder.util import run_cmd
+
+        self.disk.add_part(1, 1023, 'ext3', '/')
+        self.disk.partition()
+        file_output = run_cmd('parted', '--script', self.tmpfile, 'print')
+        self.assertEqual('''Model:  (file)
+Disk %s: 1074MB
+Sector size (logical/physical): 512B/512B
+Partition Table: msdos
+
+Number  Start   End     Size    Type     File system  Flags
+ 1      16.4kB  1023MB  1023MB  primary''' % self.tmpfile, file_output.strip())
+
+    def test_map_partitions(self):
+        self.disk.add_part(1, 1023, 'ext3', '/')
+        self.disk.partition()
+        self.disk.map_partitions()
+        try:
+            from VMBuilder.disk import detect_size
+            self.assertEqual(detect_size(self.disk.partitions[0].filename), 1023000576)
+        except:
+            raise
+        finally:
+            self.disk.unmap()
+
+    def test_mkfs(self):
+        self.disk.add_part(1, 1023, 'ext3', '/')
+        self.disk.partition()
+        self.disk.map_partitions()
+        try:
+            self.disk.mkfs()
+        except:
+            raise
+        finally:
+            self.disk.unmap()
+
+    def test_get_grub_id(self):
+        self.assertEqual(self.disk.get_grub_id(), '(hd0)')
+
+        tmpfile2 = get_temp_filename()
+        os.unlink(tmpfile2)
+        disk2 = self.vm.add_disk(tmpfile2, '1G')
+        self.assertEqual(self.disk.get_grub_id(), '(hd0)')
+        self.assertEqual(disk2.get_grub_id(), '(hd1)')
+
+    def test_get_index(self):
+        self.assertEqual(self.disk.get_index(), 0)
+
+        tmpfile2 = get_temp_filename()
+        os.unlink(tmpfile2)
+        disk2 = self.vm.add_disk(tmpfile2, '1G')
+        self.assertEqual(self.disk.get_index(), 0)
+        self.assertEqual(disk2.get_index(), 1)

=== modified file 'test/plugin_tests.py'
--- test/plugin_tests.py	2010-01-27 13:38:16 +0000
+++ test/plugin_tests.py	2010-02-18 16:03:14 +0000
@@ -7,7 +7,7 @@
     class VM(VMBuilder.plugins.Plugin):
         def __init__(self, *args, **kwargs):
             self._config = {}
-            self.vm = self
+            self.context = self
 
     class TestPlugin(VMBuilder.plugins.Plugin):
         pass

=== modified file 'test/ubuntu_tests.py'
--- test/ubuntu_tests.py	2009-10-23 09:27:26 +0000
+++ test/ubuntu_tests.py	2010-02-18 16:03:14 +0000
@@ -33,7 +33,6 @@
     def test_invalid_suite_raises_UserError(self):
     	'Building Ubuntu VMs with an invalid suite raises UserError'
 
-        vm = VMBuilder.VM()
-        vm.suite = 'foo'
-        ubuntu = Ubuntu(vm)
+        ubuntu = Ubuntu()
+        ubuntu.set_setting('suite', 'foo')
         self.assertRaises(VMBuilderUserError, ubuntu.preflight_check)

=== modified file 'test/util_tests.py'
--- test/util_tests.py	2010-01-22 13:27:16 +0000
+++ test/util_tests.py	2010-02-18 16:03:14 +0000
@@ -20,12 +20,12 @@
         class PluginC(Plugin):
             priority = 15
 
-        saved_plugins = VMBuilder._plugins
-        VMBuilder._plugins = []
-        VMBuilder.register_plugin(PluginA)
-        VMBuilder.register_plugin(PluginB)
-        VMBuilder.register_plugin(PluginC)
-        self.assertEqual(VMBuilder._plugins[0], PluginB)
-        self.assertEqual(VMBuilder._plugins[1], PluginA)
-        self.assertEqual(VMBuilder._plugins[2], PluginC)
-        VMBuilder._plugins = saved_plugins
+        saved_hypervisor_plugins = VMBuilder._hypervisor_plugins
+        VMBuilder._hypervisor_plugins = []
+        VMBuilder.register_hypervisor_plugin(PluginA)
+        VMBuilder.register_hypervisor_plugin(PluginB)
+        VMBuilder.register_hypervisor_plugin(PluginC)
+        self.assertEqual(VMBuilder._hypervisor_plugins[0], PluginB)
+        self.assertEqual(VMBuilder._hypervisor_plugins[1], PluginA)
+        self.assertEqual(VMBuilder._hypervisor_plugins[2], PluginC)
+        VMBuilder._hypervisor_plugins = saved_hypervisor_plugins