merge with trunk

45 files changed, 896 insertions, 407 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 1bf8bbd35..8138567d0 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -1095,7 +1095,8 @@ class CloudController(object):
                 changes[field] = kwargs[field]
         if changes:
             instance_id = ec2utils.ec2_id_to_id(instance_id)
-            self.compute_api.update(context, instance_id=instance_id, **kwargs)
+            self.compute_api.update(context, instance_id=instance_id,
+                                    **changes)
         return True
 
     @staticmethod
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index ddd9580d7..f24017df0 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -113,8 +113,7 @@ class APIRouter(base_wsgi.Router):
                         collection={'detail': 'GET',
                                     'info': 'GET',
                                     'select': 'POST',
-                                    'boot': 'POST'
-                                   })
+                                    'boot': 'POST'})
 
         mapper.resource("console", "consoles",
                     controller=consoles.create_resource(),
diff --git a/nova/api/openstack/contrib/volumes.py b/nova/api/openstack/contrib/volumes.py
index feabdce89..e5e2c5b50 100644
--- a/nova/api/openstack/contrib/volumes.py
+++ b/nova/api/openstack/contrib/volumes.py
@@ -301,7 +301,7 @@ class Volumes(extensions.ExtensionDescriptor):
         return "Volumes"
 
     def get_alias(self):
-        return "VOLUMES"
+        return "os-volumes"
 
     def get_description(self):
         return "Volumes support"
@@ -317,12 +317,12 @@ class Volumes(extensions.ExtensionDescriptor):
 
         # NOTE(justinsb): No way to provide singular name ('volume')
         # Does this matter?
-        res = extensions.ResourceExtension('volumes',
+        res = extensions.ResourceExtension('os-volumes',
                                         VolumeController(),
                                         collection_actions={'detail': 'GET'})
         resources.append(res)
 
-        res = extensions.ResourceExtension('volume_attachments',
+        res = extensions.ResourceExtension('os-volume_attachments',
                                            VolumeAttachmentController(),
                                            parent=dict(
                                                 member_name='server',
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index fbc6318ef..436e524c1 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -94,7 +94,7 @@ class CreateInstanceHelper(object):
         except Exception, e:
             msg = _("Cannot find requested image %(image_href)s: %(e)s" %
                                                                     locals())
-            raise faults.Fault(exc.HTTPBadRequest(msg))
+            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
 
         personality = body['server'].get('personality')
 
@@ -106,7 +106,7 @@ class CreateInstanceHelper(object):
 
         if not 'name' in body['server']:
             msg = _("Server name is not defined")
-            raise exc.HTTPBadRequest(msg)
+            raise exc.HTTPBadRequest(explanation=msg)
 
         zone_blob = body['server'].get('blob')
         name = body['server']['name']
@@ -121,8 +121,7 @@ class CreateInstanceHelper(object):
             extra_values = {
                 'instance_type': inst_type,
                 'image_ref': image_href,
-                'password': password
-            }
+                'password': password}
 
             return (extra_values,
                     create_method(context,
@@ -138,14 +137,12 @@ class CreateInstanceHelper(object):
                                   injected_files=injected_files,
                                   admin_password=password,
                                   zone_blob=zone_blob,
-                                  reservation_id=reservation_id
-                    )
-                )
+                                  reservation_id=reservation_id))
         except quota.QuotaError as error:
             self._handle_quota_error(error)
         except exception.ImageNotFound as error:
             msg = _("Can not find requested image")
-            raise faults.Fault(exc.HTTPBadRequest(msg))
+            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
 
         # Let the caller deal with unhandled exceptions.
 
@@ -180,11 +177,11 @@ class CreateInstanceHelper(object):
     def _validate_server_name(self, value):
         if not isinstance(value, basestring):
             msg = _("Server name is not a string or unicode")
-            raise exc.HTTPBadRequest(msg)
+            raise exc.HTTPBadRequest(explanation=msg)
 
         if value.strip() == '':
             msg = _("Server name is an empty string")
-            raise exc.HTTPBadRequest(msg)
+            raise exc.HTTPBadRequest(explanation=msg)
 
     def _get_kernel_ramdisk_from_image(self, req, image_id):
         """Fetch an image from the ImageService, then if present, return the
@@ -265,7 +262,7 @@ class CreateInstanceHelper(object):
             return utils.generate_password(16)
         if not isinstance(password, basestring) or password == '':
             msg = _("Invalid adminPass")
-            raise exc.HTTPBadRequest(msg)
+            raise exc.HTTPBadRequest(explanation=msg)
         return password
 
 
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 54e17e23d..da06ecd15 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -374,6 +374,8 @@ class ExtensionManager(object):
             LOG.debug(_('Ext updated: %s'), extension.get_updated())
         except AttributeError as ex:
             LOG.exception(_("Exception loading extension: %s"), unicode(ex))
+            return False
+        return True
 
     def _load_all_extensions(self):
         """Load extensions from the configured path.
@@ -412,15 +414,16 @@ class ExtensionManager(object):
                               'file': ext_path})
                     continue
                 new_ext = new_ext_class()
-                self._check_extension(new_ext)
-                self._add_extension(new_ext)
+                self.add_extension(new_ext)
+
+    def add_extension(self, ext):
+        # Do nothing if the extension doesn't check out
+        if not self._check_extension(ext):
+            return
 
-    def _add_extension(self, ext):
         alias = ext.get_alias()
         LOG.audit(_('Loaded extension: %s'), alias)
 
-        self._check_extension(ext)
-
         if alias in self.extensions:
             raise exception.Error("Found duplicate extension: %s" % alias)
         self.extensions[alias] = ext
diff --git a/nova/api/openstack/ips.py b/nova/api/openstack/ips.py
index abea71830..71646b6d3 100644
--- a/nova/api/openstack/ips.py
+++ b/nova/api/openstack/ips.py
@@ -32,25 +32,24 @@ class Controller(object):
         self.compute_api = nova.compute.API()
         self.builder = nova.api.openstack.views.addresses.ViewBuilderV10()
 
-    def index(self, req, server_id):
+    def _get_instance(self, req, server_id):
         try:
-            instance = self.compute_api.get(req.environ['nova.context'], id)
+            instance = self.compute_api.get(
+                req.environ['nova.context'], server_id)
         except nova.exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
+        return instance
+
+    def index(self, req, server_id):
+        instance = self._get_instance(req, server_id)
         return {'addresses': self.builder.build(instance)}
 
     def public(self, req, server_id):
-        try:
-            instance = self.compute_api.get(req.environ['nova.context'], id)
-        except nova.exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+        instance = self._get_instance(req, server_id)
         return {'public': self.builder.build_public_parts(instance)}
 
     def private(self, req, server_id):
-        try:
-            instance = self.compute_api.get(req.environ['nova.context'], id)
-        except nova.exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+        instance = self._get_instance(req, server_id)
         return {'private': self.builder.build_private_parts(instance)}
 
     def show(self, req, server_id, id):
diff --git a/nova/api/openstack/notes.txt b/nova/api/openstack/notes.txt
index 2330f1002..4e95bffc8 100644
--- a/nova/api/openstack/notes.txt
+++ b/nova/api/openstack/notes.txt
@@ -7,9 +7,6 @@ image ids.
 GlanceImageService(ImageService):
 image ids are URIs.
 
-LocalImageService(ImageService):
-image ids are random strings.
-
 OpenstackAPITranslationStore:
 translates RS server/images/flavor/etc ids into formats required
 by a given ImageService strategy.
diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
index 57666f6b7..8a314de22 100644
--- a/nova/api/openstack/server_metadata.py
+++ b/nova/api/openstack/server_metadata.py
@@ -18,9 +18,10 @@
 from webob import exc
 
 from nova import compute
-from nova import quota
 from nova.api.openstack import faults
 from nova.api.openstack import wsgi
+from nova import exception
+from nova import quota
 
 
 class Controller(object):
@@ -45,7 +46,11 @@ class Controller(object):
     def index(self, req, server_id):
         """ Returns the list of metadata for a given instance """
         context = req.environ['nova.context']
-        return self._get_metadata(context, server_id)
+        try:
+            return self._get_metadata(context, server_id)
+        except exception.InstanceNotFound:
+            msg = _('Server %(server_id)s does not exist') % locals()
+            raise exc.HTTPNotFound(explanation=msg)
 
     def create(self, req, server_id, body):
         self._check_body(body)
@@ -55,8 +60,13 @@ class Controller(object):
             self.compute_api.update_or_create_instance_metadata(context,
                                                                 server_id,
                                                                 metadata)
+        except exception.InstanceNotFound:
+            msg = _('Server %(server_id)s does not exist') % locals()
+            raise exc.HTTPNotFound(explanation=msg)
+
         except quota.QuotaError as error:
             self._handle_quota_error(error)
+
         return body
 
     def update(self, req, server_id, id, body):
@@ -72,6 +82,10 @@ class Controller(object):
             self.compute_api.update_or_create_instance_metadata(context,
                                                                 server_id,
                                                                 body)
+        except exception.InstanceNotFound:
+            msg = _('Server %(server_id)s does not exist') % locals()
+            raise exc.HTTPNotFound(explanation=msg)
+
         except quota.QuotaError as error:
             self._handle_quota_error(error)
 
@@ -80,16 +94,26 @@ class Controller(object):
     def show(self, req, server_id, id):
         """ Return a single metadata item """
         context = req.environ['nova.context']
-        data = self._get_metadata(context, server_id)
-        if id in data['metadata']:
+        try:
+            data = self._get_metadata(context, server_id)
+        except exception.InstanceNotFound:
+            msg = _('Server %(server_id)s does not exist') % locals()
+            raise exc.HTTPNotFound(explanation=msg)
+
+        try:
             return {id: data['metadata'][id]}
-        else:
-            return faults.Fault(exc.HTTPNotFound())
+        except KeyError:
+            msg = _("metadata item %s was not found" % (id))
+            raise exc.HTTPNotFound(explanation=msg)
 
     def delete(self, req, server_id, id):
         """ Deletes an existing metadata """
         context = req.environ['nova.context']
-        self.compute_api.delete_instance_metadata(context, server_id, id)
+        try:
+            self.compute_api.delete_instance_metadata(context, server_id, id)
+        except exception.InstanceNotFound:
+            msg = _('Server %(server_id)s does not exist') % locals()
+            raise exc.HTTPNotFound(explanation=msg)
 
     def _handle_quota_error(self, error):
         """Reraise quota errors as api-specific http exceptions."""
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 798fdd7f7..b82a6de19 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -51,7 +51,7 @@ class Controller(object):
         try:
             servers = self._items(req, is_detail=False)
         except exception.Invalid as err:
-            return exc.HTTPBadRequest(str(err))
+            return exc.HTTPBadRequest(explanation=str(err))
         return servers
 
     def detail(self, req):
@@ -59,7 +59,7 @@ class Controller(object):
         try:
             servers = self._items(req, is_detail=True)
         except exception.Invalid as err:
-            return exc.HTTPBadRequest(str(err))
+            return exc.HTTPBadRequest(explanation=str(err))
         return servers
 
     def _get_view_builder(self, req):
@@ -488,11 +488,11 @@ class ControllerV11(Controller):
         if (not 'changePassword' in input_dict
             or not 'adminPass' in input_dict['changePassword']):
             msg = _("No adminPass was specified")
-            return exc.HTTPBadRequest(msg)
+            return exc.HTTPBadRequest(explanation=msg)
         password = input_dict['changePassword']['adminPass']
         if not isinstance(password, basestring) or password == '':
             msg = _("Invalid adminPass")
-            return exc.HTTPBadRequest(msg)
+            return exc.HTTPBadRequest(explanation=msg)
         self.compute_api.set_admin_password(context, id, password)
         return exc.HTTPAccepted()
 
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 245d0e3fa..cbfa5aae7 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -75,7 +75,7 @@ class ViewBuilder(object):
         }
 
         inst_dict = {
-            'id': int(inst['id']),
+            'id': inst['id'],
             'name': inst['display_name'],
             'addresses': self.addresses_builder.build(inst),
             'status': power_mapping[inst.get('state')]}
@@ -99,6 +99,7 @@ class ViewBuilder(object):
         self._build_image(inst_dict, inst)
         self._build_flavor(inst_dict, inst)
 
+        inst_dict['uuid'] = inst['uuid']
         return dict(server=inst_dict)
 
     def _build_image(self, response, inst):
diff --git a/nova/api/openstack/wsgi.py b/nova/api/openstack/wsgi.py
index 3f8acf339..a57b7f72b 100644
--- a/nova/api/openstack/wsgi.py
+++ b/nova/api/openstack/wsgi.py
@@ -363,11 +363,11 @@ class Resource(wsgi.Application):
             action, action_args, accept = self.deserializer.deserialize(
                                                                       request)
         except exception.InvalidContentType:
-            return webob.exc.HTTPBadRequest(_("Unsupported Content-Type"))
+            msg = _("Unsupported Content-Type")
+            return webob.exc.HTTPBadRequest(explanation=msg)
         except exception.MalformedRequestBody:
-            explanation = _("Malformed request body")
-            return faults.Fault(webob.exc.HTTPBadRequest(
-                                            explanation=explanation))
+            msg = _("Malformed request body")
+            return faults.Fault(webob.exc.HTTPBadRequest(explanation=msg))
 
         action_result = self.dispatch(request, action, action_args)
 
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 5b56d7865..e2692a42f 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -179,6 +179,9 @@ class API(base.Base):
         os_type = None
         if 'properties' in image and 'os_type' in image['properties']:
             os_type = image['properties']['os_type']
+        architecture = None
+        if 'properties' in image and 'arch' in image['properties']:
+            architecture = image['properties']['arch']
         vm_mode = None
         if 'properties' in image and 'vm_mode' in image['properties']:
             vm_mode = image['properties']['vm_mode']
@@ -247,6 +250,7 @@ class API(base.Base):
             'metadata': metadata,
             'availability_zone': availability_zone,
             'os_type': os_type,
+            'architecture': architecture,
             'vm_mode': vm_mode,
             'root_device_name': root_device_name}
 
@@ -346,8 +350,6 @@ class API(base.Base):
 
         return instance
 
-
-
     def _ask_scheduler_to_create_instance(self, context, base_options,
                                           instance_type, zone_blob,
                                           availability_zone, injected_files,
@@ -629,8 +631,15 @@ class API(base.Base):
 
     def get(self, context, instance_id):
         """Get a single instance with the given instance_id."""
-        rv = self.db.instance_get(context, instance_id)
-        return dict(rv.iteritems())
+        # NOTE(sirp): id used to be exclusively integer IDs; now we're
+        # accepting both UUIDs and integer IDs. The handling of this
+        # is done in db/sqlalchemy/api/instance_get
+        if utils.is_uuid_like(instance_id):
+            uuid = instance_id
+            instance = self.db.instance_get_by_uuid(context, uuid)
+        else:
+            instance = self.db.instance_get(context, instance_id)
+        return dict(instance.iteritems())
 
     @scheduler_api.reroute_compute("get")
     def routing_get(self, context, instance_id):
@@ -646,6 +655,7 @@ class API(base.Base):
         """Get all instances with this reservation_id, across
         all available Zones (if any).
         """
+        context = context.elevated()
         instances = self.db.instance_get_all_by_reservation(
                                     context, reservation_id)
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 146cdbb9f..34baa6d77 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -564,6 +564,24 @@ class ComputeManager(manager.SchedulerDependentManager):
 
     @exception.wrap_exception
     @checks_instance_lock
+    def agent_update(self, context, instance_id, url, md5hash):
+        """Update agent running on an instance on this host."""
+        context = context.elevated()
+        instance_ref = self.db.instance_get(context, instance_id)
+        instance_id = instance_ref['id']
+        instance_state = instance_ref['state']
+        expected_state = power_state.RUNNING
+        if instance_state != expected_state:
+            LOG.warn(_('trying to update agent on a non-running '
+                    'instance: %(instance_id)s (state: %(instance_state)s '
+                    'expected: %(expected_state)s)') % locals())
+        nm = instance_ref['name']
+        msg = _('instance %(nm)s: updating agent to %(url)s') % locals()
+        LOG.audit(msg)
+        self.driver.agent_update(instance_ref, url, md5hash)
+
+    @exception.wrap_exception
+    @checks_instance_lock
     def rescue_instance(self, context, instance_id):
         """Rescue an instance on this host."""
         context = context.elevated()
@@ -785,7 +803,6 @@ class ComputeManager(manager.SchedulerDependentManager):
     def get_diagnostics(self, context, instance_id):
         """Retrieve diagnostics for an instance on this host."""
         instance_ref = self.db.instance_get(context, instance_id)
-
         if instance_ref["state"] == power_state.RUNNING:
             LOG.audit(_("instance %s: retrieving diagnostics"), instance_id,
                       context=context)
diff --git a/nova/db/api.py b/nova/db/api.py
index 117c235ea..8f8e856b8 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -419,6 +419,11 @@ def instance_stop(context, instance_id):
     return IMPL.instance_stop(context, instance_id)
 
 
+def instance_get_by_uuid(context, uuid):
+    """Get an instance or raise if it does not exist."""
+    return IMPL.instance_get_by_uuid(context, uuid)
+
+
 def instance_get(context, instance_id):
     """Get an instance or raise if it does not exist."""
     return IMPL.instance_get(context, instance_id)
@@ -1282,3 +1287,32 @@ def instance_metadata_delete(context, instance_id, key):
 def instance_metadata_update_or_create(context, instance_id, metadata):
     """Create or update instance metadata."""
     IMPL.instance_metadata_update_or_create(context, instance_id, metadata)
+
+
+####################
+
+
+def agent_build_create(context, values):
+    """Create a new agent build entry."""
+    return IMPL.agent_build_create(context, values)
+
+
+def agent_build_get_by_triple(context, hypervisor, os, architecture):
+    """Get agent build by hypervisor/OS/architecture triple."""
+    return IMPL.agent_build_get_by_triple(context, hypervisor, os,
+            architecture)
+
+
+def agent_build_get_all(context):
+    """Get all agent builds."""
+    return IMPL.agent_build_get_all(context)
+
+
+def agent_build_destroy(context, agent_update_id):
+    """Destroy agent build entry."""
+    IMPL.agent_build_destroy(context, agent_update_id)
+
+
+def agent_build_update(context, agent_build_id, values):
+    """Update agent build entry."""
+    IMPL.agent_build_update(context, agent_build_id, values)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 9ce955eae..a2500a38d 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -18,7 +18,7 @@
 """
 Implementation of SQLAlchemy backend.
 """
-
+import traceback
 import warnings
 
 from nova import db
@@ -797,6 +797,8 @@ def instance_create(context, values):
     values['metadata'] = _metadata_refs(values.get('metadata'))
 
     instance_ref = models.Instance()
+    instance_ref['uuid'] = str(utils.gen_uuid())
+
     instance_ref.update(values)
 
     session = get_session()
@@ -859,37 +861,46 @@ def instance_stop(context, instance_id):
 
 
 @require_context
+def instance_get_by_uuid(context, uuid, session=None):
+    partial = _build_instance_get(context, session=session)
+    result = partial.filter_by(uuid=uuid)
+    result = result.first()
+    if not result:
+        # FIXME(sirp): it would be nice if InstanceNotFound would accept a
+        # uuid parameter as well
+        raise exception.InstanceNotFound(instance_id=uuid)
+    return result
+
+
+@require_context
 def instance_get(context, instance_id, session=None):
+    partial = _build_instance_get(context, session=session)
+    result = partial.filter_by(id=instance_id)
+    result = result.first()
+    if not result:
+        raise exception.InstanceNotFound(instance_id=instance_id)
+    return result
+
+
+@require_context
+def _build_instance_get(context, session=None):
     if not session:
         session = get_session()
-    result = None
+
+    partial = session.query(models.Instance).\
+                     options(joinedload_all('fixed_ip.floating_ips')).\
+                     options(joinedload_all('security_groups.rules')).\
+                     options(joinedload('volumes')).\
+                     options(joinedload_all('fixed_ip.network')).\
+                     options(joinedload('metadata')).\
+                     options(joinedload('instance_type'))
 
     if is_admin_context(context):
-        result = session.query(models.Instance).\
-                         options(joinedload_all('fixed_ip.floating_ips')).\
-                         options(joinedload_all('security_groups.rules')).\
-                         options(joinedload('volumes')).\
-                         options(joinedload_all('fixed_ip.network')).\
-                         options(joinedload('metadata')).\
-                         options(joinedload('instance_type')).\
-                         filter_by(id=instance_id).\
-                         filter_by(deleted=can_read_deleted(context)).\
-                         first()
+        partial = partial.filter_by(deleted=can_read_deleted(context))
     elif is_user_context(context):
-        result = session.query(models.Instance).\
-                         options(joinedload_all('fixed_ip.floating_ips')).\
-                         options(joinedload_all('security_groups.rules')).\
-                         options(joinedload('volumes')).\
-                         options(joinedload('metadata')).\
-                         options(joinedload('instance_type')).\
-                         filter_by(project_id=context.project_id).\
-                         filter_by(id=instance_id).\
-                         filter_by(deleted=False).\
-                         first()
-    if not result:
-        raise exception.InstanceNotFound(instance_id=instance_id)
-
-    return result
+        partial = partial.filter_by(project_id=context.project_id).\
+                        filter_by(deleted=False)
+    return partial
 
 
 @require_admin_context
@@ -926,6 +937,7 @@ def instance_get_all_by_host(context, host):
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('metadata')).\
                    options(joinedload('instance_type')).\
                    filter_by(host=host).\
                    filter_by(deleted=can_read_deleted(context)).\
@@ -941,6 +953,7 @@ def instance_get_all_by_project(context, project_id):
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('metadata')).\
                    options(joinedload('instance_type')).\
                    filter_by(project_id=project_id).\
                    filter_by(deleted=can_read_deleted(context)).\
@@ -956,6 +969,7 @@ def instance_get_all_by_reservation(context, reservation_id):
                        options(joinedload_all('fixed_ip.floating_ips')).\
                        options(joinedload('security_groups')).\
                        options(joinedload_all('fixed_ip.network')).\
+                       options(joinedload('metadata')).\
                        options(joinedload('instance_type')).\
                        filter_by(reservation_id=reservation_id).\
                        filter_by(deleted=can_read_deleted(context)).\
@@ -965,6 +979,7 @@ def instance_get_all_by_reservation(context, reservation_id):
                        options(joinedload_all('fixed_ip.floating_ips')).\
                        options(joinedload('security_groups')).\
                        options(joinedload_all('fixed_ip.network')).\
+                       options(joinedload('metadata')).\
                        options(joinedload('instance_type')).\
                        filter_by(project_id=context.project_id).\
                        filter_by(reservation_id=reservation_id).\
@@ -978,6 +993,8 @@ def instance_get_project_vpn(context, project_id):
     return session.query(models.Instance).\
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
+                   options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('metadata')).\
                    options(joinedload('instance_type')).\
                    filter_by(project_id=project_id).\
                    filter_by(image_ref=str(FLAGS.vpn_image_id)).\
@@ -2688,7 +2705,17 @@ def zone_get_all(context):
 
 ####################
 
+
+def require_instance_exists(func):
+    def new_func(context, instance_id, *args, **kwargs):
+        db.api.instance_get(context, instance_id)
+        return func(context, instance_id, *args, **kwargs)
+    new_func.__name__ = func.__name__
+    return new_func
+
+
 @require_context
+@require_instance_exists
 def instance_metadata_get(context, instance_id):
     session = get_session()
 
@@ -2704,6 +2731,7 @@ def instance_metadata_get(context, instance_id):
 
 
 @require_context
+@require_instance_exists
 def instance_metadata_delete(context, instance_id, key):
     session = get_session()
     session.query(models.InstanceMetadata).\
@@ -2716,6 +2744,7 @@ def instance_metadata_delete(context, instance_id, key):
 
 
 @require_context
+@require_instance_exists
 def instance_metadata_delete_all(context, instance_id):
     session = get_session()
     session.query(models.InstanceMetadata).\
@@ -2727,6 +2756,7 @@ def instance_metadata_delete_all(context, instance_id):
 
 
 @require_context
+@require_instance_exists
 def instance_metadata_get_item(context, instance_id, key):
     session = get_session()
 
@@ -2743,6 +2773,7 @@ def instance_metadata_get_item(context, instance_id, key):
 
 
 @require_context
+@require_instance_exists
 def instance_metadata_update_or_create(context, instance_id, metadata):
     session = get_session()
 
@@ -2761,3 +2792,54 @@ def instance_metadata_update_or_create(context, instance_id, metadata):
         meta_ref.save(session=session)
 
     return metadata
+
+
+@require_admin_context
+def agent_build_create(context, values):
+    agent_build_ref = models.AgentBuild()
+    agent_build_ref.update(values)
+    agent_build_ref.save()
+    return agent_build_ref
+
+
+@require_admin_context
+def agent_build_get_by_triple(context, hypervisor, os, architecture,
+                              session=None):
+    if not session:
+        session = get_session()
+    return session.query(models.AgentBuild).\
+                   filter_by(hypervisor=hypervisor).\
+                   filter_by(os=os).\
+                   filter_by(architecture=architecture).\
+                   filter_by(deleted=False).\
+                   first()
+
+
+@require_admin_context
+def agent_build_get_all(context):
+    session = get_session()
+    return session.query(models.AgentBuild).\
+                   filter_by(deleted=False).\
+                   all()
+
+
+@require_admin_context
+def agent_build_destroy(context, agent_build_id):
+    session = get_session()
+    with session.begin():
+        session.query(models.AgentBuild).\
+                filter_by(id=agent_build_id).\
+                update({'deleted': 1,
+                        'deleted_at': datetime.datetime.utcnow(),
+                        'updated_at': literal_column('updated_at')})
+
+
+@require_admin_context
+def agent_build_update(context, agent_build_id, values):
+    session = get_session()
+    with session.begin():
+        agent_build_ref = session.query(models.AgentBuild).\
+                   filter_by(id=agent_build_id). \
+                   first()
+        agent_build_ref.update(values)
+        agent_build_ref.save(session=session)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/025_add_uuid_to_instances.py b/nova/db/sqlalchemy/migrate_repo/versions/025_add_uuid_to_instances.py
new file mode 100644
index 000000000..27f30d536
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/025_add_uuid_to_instances.py
@@ -0,0 +1,43 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from sqlalchemy import Column, Integer, MetaData, String, Table
+
+from nova import utils
+
+
+meta = MetaData()
+
+instances = Table("instances", meta,
+        Column("id", Integer(), primary_key=True, nullable=False))
+uuid_column = Column("uuid", String(36))
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+    instances.create_column(uuid_column)
+
+    rows = migrate_engine.execute(instances.select())
+    for row in rows:
+        instance_uuid = str(utils.gen_uuid())
+        migrate_engine.execute(instances.update()\
+                .where(instances.c.id == row[0])\
+                .values(uuid=instance_uuid))
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+    instances.drop_column(uuid_column)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/026_add_agent_table.py b/nova/db/sqlalchemy/migrate_repo/versions/026_add_agent_table.py
new file mode 100644
index 000000000..640e96138
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/026_add_agent_table.py
@@ -0,0 +1,73 @@
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from sqlalchemy import Boolean, Column, DateTime, Integer
+from sqlalchemy import MetaData, String, Table
+from nova import log as logging
+
+meta = MetaData()
+
+#
+# New Tables
+#
+builds = Table('agent_builds', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('hypervisor',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('os',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('architecture',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('version',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('url',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        Column('md5hash',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False)),
+        )
+
+
+#
+# New Column
+#
+
+architecture = Column('architecture', String(length=255))
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    for table in (builds, ):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+
+    instances = Table('instances', meta, autoload=True,
+                      autoload_with=migrate_engine)
+
+    # Add columns to existing tables
+    instances.create_column(architecture)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 62293daba..75eaaf68e 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -232,7 +232,9 @@ class Instance(BASE, NovaBase):
     locked = Column(Boolean)
 
     os_type = Column(String(255))
+    architecture = Column(String(255))
     vm_mode = Column(String(255))
+    uuid = Column(String(36))
 
     root_device_name = Column(String(255))
 
@@ -714,6 +716,18 @@ class Zone(BASE, NovaBase):
     password = Column(String(255))
 
 
+class AgentBuild(BASE, NovaBase):
+    """Represents an agent build."""
+    __tablename__ = 'agent_builds'
+    id = Column(Integer, primary_key=True)
+    hypervisor = Column(String(255))
+    os = Column(String(255))
+    architecture = Column(String(255))
+    version = Column(String(255))
+    url = Column(String(255))
+    md5hash = Column(String(255))
+
+
 def register_models():
     """Register Models and create metadata.
 
@@ -727,7 +741,7 @@ def register_models():
               Network, SecurityGroup, SecurityGroupIngressRule,
               SecurityGroupInstanceAssociation, AuthToken, User,
               Project, Certificate, ConsolePool, Console, Zone,
-              InstanceMetadata, Migration)
+              AgentBuild, InstanceMetadata, Migration)
     engine = create_engine(FLAGS.sql_connection, echo=False)
     for model in models:
         model.metadata.create_all(engine)
diff --git a/nova/flags.py b/nova/flags.py
index acfcf8d68..57a4ecf2f 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -272,7 +272,7 @@ DEFINE_string('aws_access_key_id', 'admin', 'AWS Access ID')
 DEFINE_string('aws_secret_access_key', 'admin', 'AWS Access Key')
 # NOTE(sirp): my_ip interpolation doesn't work within nested structures
 DEFINE_list('glance_api_servers',
-            ['127.0.0.1:9292'],
+            ['%s:9292' % _get_my_ip()],
             'list of glance api servers available to nova (host:port)')
 DEFINE_integer('s3_port', 3333, 's3 port')
 DEFINE_string('s3_host', '$my_ip', 's3 host (for infrastructure)')
@@ -364,7 +364,7 @@ DEFINE_string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager',
               'Manager for scheduler')
 
 # The service to use for image search and retrieval
-DEFINE_string('image_service', 'nova.image.local.LocalImageService',
+DEFINE_string('image_service', 'nova.image.glance.GlanceImageService',
               'The service to use for retrieving and searching for images.')
 
 DEFINE_string('host', socket.gethostname(),
diff --git a/nova/image/fake.py b/nova/image/fake.py
index 70a5f0e22..c4b3d5fd6 100644
--- a/nova/image/fake.py
+++ b/nova/image/fake.py
@@ -120,6 +120,14 @@ class _FakeImageService(service.BaseImageService):
                  image_id, self.images)
         raise exception.ImageNotFound(image_id=image_id)
 
+    def show_by_name(self, context, name):
+        """Returns a dict containing image data for the given name."""
+        images = copy.deepcopy(self.images.values())
+        for image in images:
+            if name == image.get('name'):
+                return image
+        raise exception.ImageNotFound(image_id=name)
+
     def create(self, context, metadata, data=None):
         """Store the image data and return the new image id.
 
diff --git a/nova/image/local.py b/nova/image/local.py
deleted file mode 100644
index c7dee4573..000000000
--- a/nova/image/local.py
+++ /dev/null
@@ -1,167 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import json
-import os.path
-import random
-import shutil
-
-from nova import exception
-from nova import flags
-from nova import log as logging
-from nova import utils
-from nova.image import service
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('images_path', '$state_path/images',
-                    'path to decrypted images')
-
-
-LOG = logging.getLogger('nova.image.local')
-
-
-class LocalImageService(service.BaseImageService):
-    """Image service storing images to local disk.
-
-    It assumes that image_ids are integers.
-
-    """
-
-    def __init__(self):
-        self._path = FLAGS.images_path
-
-    def _path_to(self, image_id, fname='info.json'):
-        if fname:
-            return os.path.join(self._path, '%08x' % int(image_id), fname)
-        return os.path.join(self._path, '%08x' % int(image_id))
-
-    def _ids(self):
-        """The list of all image ids."""
-        images = []
-        for image_dir in os.listdir(self._path):
-            try:
-                unhexed_image_id = int(image_dir, 16)
-            except ValueError:
-                LOG.error(_('%s is not in correct directory naming format')
-                          % image_dir)
-            else:
-                images.append(unhexed_image_id)
-        return images
-
-    def index(self, context, filters=None, marker=None, limit=None):
-        # TODO(blamar): Make use of filters, marker, and limit
-        filtered = []
-        image_metas = self.detail(context)
-        for image_meta in image_metas:
-            meta = utils.subset_dict(image_meta, ('id', 'name'))
-            filtered.append(meta)
-        return filtered
-
-    def detail(self, context, filters=None, marker=None, limit=None):
-        # TODO(blamar): Make use of filters, marker, and limit
-        images = []
-        for image_id in self._ids():
-            try:
-                image = self.show(context, image_id)
-                images.append(image)
-            except exception.NotFound:
-                continue
-        return images
-
-    def show(self, context, image_id):
-        try:
-            with open(self._path_to(image_id)) as metadata_file:
-                image_meta = json.load(metadata_file)
-                if not self._is_image_available(context, image_meta):
-                    raise exception.ImageNotFound(image_id=image_id)
-                return image_meta
-        except (IOError, ValueError):
-            raise exception.ImageNotFound(image_id=image_id)
-
-    def show_by_name(self, context, name):
-        """Returns a dict containing image data for the given name."""
-        # NOTE(vish): Not very efficient, but the local image service
-        #             is for testing so it should be fine.
-        images = self.detail(context)
-        image = None
-        for cantidate in images:
-            if name == cantidate.get('name'):
-                image = cantidate
-                break
-        if image is None:
-            raise exception.ImageNotFound(image_id=name)
-        return image
-
-    def get(self, context, image_id, data):
-        """Get image and metadata."""
-        try:
-            with open(self._path_to(image_id)) as metadata_file:
-                metadata = json.load(metadata_file)
-            with open(self._path_to(image_id, 'image')) as image_file:
-                shutil.copyfileobj(image_file, data)
-        except (IOError, ValueError):
-            raise exception.ImageNotFound(image_id=image_id)
-        return metadata
-
-    def create(self, context, metadata, data=None):
-        """Store the image data and return the new image."""
-        image_id = random.randint(0, 2 ** 31 - 1)
-        image_path = self._path_to(image_id, None)
-        if not os.path.exists(image_path):
-            os.mkdir(image_path)
-        return self._store(context, image_id, metadata, data)
-
-    def update(self, context, image_id, metadata, data=None):
-        """Replace the contents of the given image with the new data."""
-        # NOTE(vish): show is to check if image is available
-        self.show(context, image_id)
-        return self._store(context, image_id, metadata, data)
-
-    def _store(self, context, image_id, metadata, data=None):
-        metadata['id'] = image_id
-        try:
-            if data:
-                location = self._path_to(image_id, 'image')
-                with open(location, 'w') as image_file:
-                    shutil.copyfileobj(data, image_file)
-                # NOTE(vish): update metadata similarly to glance
-                metadata['status'] = 'active'
-                metadata['location'] = location
-            with open(self._path_to(image_id), 'w') as metadata_file:
-                json.dump(metadata, metadata_file)
-        except (IOError, ValueError):
-            raise exception.ImageNotFound(image_id=image_id)
-        return metadata
-
-    def delete(self, context, image_id):
-        """Delete the given image.
-
-        :raises: ImageNotFound if the image does not exist.
-
-        """
-        # NOTE(vish): show is to check if image is available
-        self.show(context, image_id)
-        try:
-            shutil.rmtree(self._path_to(image_id, None))
-        except (IOError, ValueError):
-            raise exception.ImageNotFound(image_id=image_id)
-
-    def delete_all(self):
-        """Clears out all images in local directory."""
-        for image_id in self._ids():
-            shutil.rmtree(self._path_to(image_id, None))
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index ffe59d2c1..1bb047e2e 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -24,6 +24,7 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import rpc
+from nova import utils
 
 from eventlet import greenpool
 
@@ -106,7 +107,8 @@ def _wrap_method(function, self):
 def _process(func, zone):
     """Worker stub for green thread pool. Give the worker
     an authenticated nova client and zone info."""
-    nova = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
+    nova = novaclient.OpenStack(zone.username, zone.password, None,
+                                zone.api_url)
     nova.authenticate()
     return func(nova, zone)
 
@@ -122,7 +124,7 @@ def call_zone_method(context, method_name, errors_to_ignore=None,
     results = []
     for zone in db.zone_get_all(context):
         try:
-            nova = novaclient.OpenStack(zone.username, zone.password,
+            nova = novaclient.OpenStack(zone.username, zone.password, None,
                     zone.api_url)
             nova.authenticate()
         except novaclient.exceptions.BadRequest, e:
@@ -200,38 +202,78 @@ class RedirectResult(exception.Error):
 
 
 class reroute_compute(object):
-    """Decorator used to indicate that the method should
-       delegate the call the child zones if the db query
-       can't find anything."""
+    """
+    reroute_compute is responsible for trying to lookup a resource in the
+    current zone and if it's not found there, delegating the call to the
+    child zones.
+
+    Since reroute_compute will be making 'cross-zone' calls, the ID for the
+    object must come in as a UUID-- if we receive an integer ID, we bail.
+
+    The steps involved are:
+
+        1. Validate that item_id is UUID like
+
+        2. Lookup item by UUID in the zone local database
+
+        3. If the item was found, then extract integer ID, and pass that to
+           the wrapped method. (This ensures that zone-local code can
+           continue to use integer IDs).
+
+        4. If the item was not found, we delgate the call to a child zone
+           using the UUID.
+    """
     def __init__(self, method_name):
         self.method_name = method_name
 
+    def _route_to_child_zones(self, context, collection, item_uuid):
+        if not FLAGS.enable_zone_routing:
+            raise exception.InstanceNotFound(instance_id=item_uuid)
+
+        zones = db.zone_get_all(context)
+        if not zones:
+            raise exception.InstanceNotFound(instance_id=item_uuid)
+
+        # Ask the children to provide an answer ...
+        LOG.debug(_("Asking child zones ..."))
+        result = self._call_child_zones(zones,
+                    wrap_novaclient_function(_issue_novaclient_command,
+                           collection, self.method_name, item_uuid))
+        # Scrub the results and raise another exception
+        # so the API layers can bail out gracefully ...
+        raise RedirectResult(self.unmarshall_result(result))
+
     def __call__(self, f):
         def wrapped_f(*args, **kwargs):
-            collection, context, item_id = \
+            collection, context, item_id_or_uuid = \
                             self.get_collection_context_and_id(args, kwargs)
-            try:
-                # Call the original function ...
+
+            attempt_reroute = False
+            if utils.is_uuid_like(item_id_or_uuid):
+                item_uuid = item_id_or_uuid
+                try:
+                    instance = db.instance_get_by_uuid(context, item_uuid)
+                except exception.InstanceNotFound, e:
+                    # NOTE(sirp): since a UUID was passed in, we can attempt
+                    # to reroute to a child zone
+                    attempt_reroute = True
+                    LOG.debug(_("Instance %(item_uuid)s not found "
+                                        "locally: '%(e)s'" % locals()))
+                else:
+                    # NOTE(sirp): since we're not re-routing in this case, and
+                    # we we were passed a UUID, we need to replace that UUID
+                    # with an integer ID in the argument list so that the
+                    # zone-local code can continue to use integer IDs.
+                    item_id = instance['id']
+                    args = list(args)      # needs to be mutable to replace
+                    self.replace_uuid_with_id(args, kwargs, item_id)
+
+            if attempt_reroute:
+                return self._route_to_child_zones(context, collection,
+                        item_uuid)
+            else:
                 return f(*args, **kwargs)
-            except exception.InstanceNotFound, e:
-                LOG.debug(_("Instance %(item_id)s not found "
-                                    "locally: '%(e)s'" % locals()))
-
-                if not FLAGS.enable_zone_routing:
-                    raise
-
-                zones = db.zone_get_all(context)
-                if not zones:
-                    raise
-
-                # Ask the children to provide an answer ...
-                LOG.debug(_("Asking child zones ..."))
-                result = self._call_child_zones(zones,
-                            wrap_novaclient_function(_issue_novaclient_command,
-                                   collection, self.method_name, item_id))
-                # Scrub the results and raise another exception
-                # so the API layers can bail out gracefully ...
-                raise RedirectResult(self.unmarshall_result(result))
+
         return wrapped_f
 
     def _call_child_zones(self, zones, function):
@@ -250,6 +292,18 @@ class reroute_compute(object):
             instance_id = args[2]
         return ("servers", context, instance_id)
 
+    @staticmethod
+    def replace_uuid_with_id(args, kwargs, replacement_id):
+        """
+        Extracts the UUID parameter from the arg or kwarg list and replaces
+        it with an integer ID.
+        """
+        if 'instance_id' in kwargs:
+            kwargs['instance_id'] = replacement_id
+        elif len(args) > 1:
+            args.pop(2)
+            args.insert(2, replacement_id)
+
     def unmarshall_result(self, zone_responses):
         """Result is a list of responses from each child zone.
         Each decorator derivation is responsible to turning this
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index f04defa64..e7bff2faa 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -88,7 +88,7 @@ class ZoneAwareScheduler(driver.Scheduler):
         instance_properties = request_spec['instance_properties']
 
         name = instance_properties['display_name']
-        image_id = instance_properties['image_id']
+        image_ref = instance_properties['image_ref']
         meta = instance_properties['metadata']
         flavor_id = instance_type['flavorid']
         reservation_id = instance_properties['reservation_id']
@@ -105,13 +105,14 @@ class ZoneAwareScheduler(driver.Scheduler):
                     % locals())
         nova = None
         try:
-            nova = novaclient.OpenStack(zone.username, zone.password, url)
+            nova = novaclient.OpenStack(zone.username, zone.password, None,
+                                        url)
             nova.authenticate()
         except novaclient.exceptions.BadRequest, e:
             raise exception.NotAuthorized(_("Bad credentials attempting "
                             "to talk to zone at %(url)s.") % locals())
 
-        nova.servers.create(name, image_id, flavor_id, ipgroup, meta, files,
+        nova.servers.create(name, image_ref, flavor_id, ipgroup, meta, files,
                             child_blob, reservation_id=reservation_id)
 
     def _provision_resource_from_blob(self, context, item, instance_id,
@@ -184,7 +185,11 @@ class ZoneAwareScheduler(driver.Scheduler):
         if not build_plan:
             raise driver.NoValidHost(_('No hosts were available'))
 
-        for item in build_plan:
+        for num in xrange(request_spec['num_instances']):
+            if not build_plan:
+                break
+
+            item = build_plan.pop(0)
             self._provision_resource(context, item, instance_id, request_spec,
                                     kwargs)
 
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 3f483adff..ba7403c15 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -89,7 +89,8 @@ class ZoneState(object):
 
 def _call_novaclient(zone):
     """Call novaclient. Broken out for testing purposes."""
-    client = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
+    client = novaclient.OpenStack(zone.username, zone.password, None,
+                                  zone.api_url)
     return client.zones.info()._info
 
 
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index a10fb7433..f8d158ddd 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -39,7 +39,6 @@ from nova.api.openstack import limits
 from nova.auth.manager import User, Project
 import nova.image.fake
 from nova.image import glance
-from nova.image import local
 from nova.image import service
 from nova.tests import fake_flags
 from nova.wsgi import Router
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 60914c0a3..697c62e5c 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -128,6 +128,11 @@ class ResourceExtensionTest(unittest.TestCase):
         self.assertEqual(response_body, response.body)
 
 
+class InvalidExtension(object):
+    def get_alias(self):
+        return "THIRD"
+
+
 class ExtensionManagerTest(unittest.TestCase):
 
     response_body = "Try to say this Mr. Knox, sir..."
@@ -144,6 +149,14 @@ class ExtensionManagerTest(unittest.TestCase):
         self.assertEqual(200, response.status_int)
         self.assertEqual(response_body, response.body)
 
+    def test_invalid_extensions(self):
+        app = openstack.APIRouterV11()
+        ext_midware = extensions.ExtensionMiddleware(app)
+        ext_mgr = ext_midware.ext_mgr
+        ext_mgr.add_extension(InvalidExtension())
+        self.assertTrue('FOXNSOX' in ext_mgr.extensions)
+        self.assertTrue('THIRD' not in ext_mgr.extensions)
+
 
 class ActionExtensionTest(unittest.TestCase):
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index be777df9b..e4204809f 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -135,36 +135,6 @@ class _BaseImageServiceTests(test.TestCase):
         return fixture
 
 
-class LocalImageServiceTest(_BaseImageServiceTests):
-
-    """Tests the local image service"""
-
-    def setUp(self):
-        super(LocalImageServiceTest, self).setUp()
-        self.tempdir = tempfile.mkdtemp()
-        self.flags(images_path=self.tempdir)
-        self.stubs = stubout.StubOutForTesting()
-        service_class = 'nova.image.local.LocalImageService'
-        self.service = utils.import_object(service_class)
-        self.context = context.RequestContext(None, None)
-
-    def tearDown(self):
-        shutil.rmtree(self.tempdir)
-        self.stubs.UnsetAll()
-        super(LocalImageServiceTest, self).tearDown()
-
-    def test_get_all_ids_with_incorrect_directory_formats(self):
-        # create some old-style image directories (starting with 'ami-')
-        for x in [1, 2, 3]:
-            tempfile.mkstemp(prefix='ami-', dir=self.tempdir)
-        # create some valid image directories names
-        for x in ["1485baed", "1a60f0ee", "3123a73d"]:
-            os.makedirs(os.path.join(self.tempdir, x))
-        found_image_ids = self.service._ids()
-        self.assertEqual(True, isinstance(found_image_ids, list))
-        self.assertEqual(3, len(found_image_ids), len(found_image_ids))
-
-
 class GlanceImageServiceTest(_BaseImageServiceTests):
 
     """Tests the Glance image service, in particular that metadata translation
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index 01613d1d8..38c959fae 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -672,8 +672,7 @@ class WsgiLimiterTest(BaseLimitTestSuite):
         """Only POSTs should work."""
         requests = []
         for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
-            request = webob.Request.blank("/")
-            request.body = self._request_data("GET", "/something")
+            request = webob.Request.blank("/", method=method)
             response = request.get_response(self.app)
             self.assertEqual(response.status_int, 405)
 
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
index b583d40fe..0431e68d2 100644
--- a/nova/tests/api/openstack/test_server_metadata.py
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -21,6 +21,7 @@ import unittest
 import webob
 
 
+from nova import exception
 from nova import flags
 from nova.api import openstack
 from nova.tests.api.openstack import fakes
@@ -67,6 +68,14 @@ def stub_max_server_metadata():
     return metadata
 
 
+def return_server(context, server_id):
+    return {'id': server_id}
+
+
+def return_server_nonexistant(context, server_id):
+    raise exception.InstanceNotFound()
+
+
 class ServerMetaDataTest(unittest.TestCase):
 
     def setUp(self):
@@ -76,6 +85,7 @@ class ServerMetaDataTest(unittest.TestCase):
         fakes.FakeAuthDatabase.data = {}
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server)
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -92,6 +102,13 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('application/json', res.headers['Content-Type'])
         self.assertEqual('value1', res_dict['metadata']['key1'])
 
+    def test_index_nonexistant_server(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
+        req = webob.Request.blank('/v1.1/servers/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
     def test_index_no_data(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_get',
                        return_empty_server_metadata)
@@ -114,13 +131,19 @@ class ServerMetaDataTest(unittest.TestCase):
         self.assertEqual('application/json', res.headers['Content-Type'])
         self.assertEqual('value5', res_dict['key5'])
 
+    def test_show_nonexistant_server(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
     def test_show_meta_not_found(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_get',
                        return_empty_server_metadata)
         req = webob.Request.blank('/v1.1/servers/1/meta/key6')
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
         self.assertEqual(404, res.status_int)
 
     def test_delete(self):
@@ -132,6 +155,14 @@ class ServerMetaDataTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(200, res.status_int)
 
+    def test_delete_nonexistant_server(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
+        req = webob.Request.blank('/v1.1/servers/1/meta/key5')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
     def test_create(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                        return_create_instance_metadata)
@@ -141,8 +172,8 @@ class ServerMetaDataTest(unittest.TestCase):
         req.body = '{"metadata": {"key1": "value1"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        res_dict = json.loads(res.body)
         self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
         self.assertEqual('application/json', res.headers['Content-Type'])
         self.assertEqual('value1', res_dict['metadata']['key1'])
 
@@ -156,6 +187,16 @@ class ServerMetaDataTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, res.status_int)
 
+    def test_create_nonexistant_server(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
+        req = webob.Request.blank('/v1.1/servers/100/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key1": "value1"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
     def test_update_item(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                        return_create_instance_metadata)
@@ -170,6 +211,16 @@ class ServerMetaDataTest(unittest.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual('value1', res_dict['key1'])
 
+    def test_update_item_nonexistant_server(self):
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_nonexistant)
+        req = webob.Request.blank('/v1.1/servers/asdf/100/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
     def test_update_item_empty_body(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_update_or_create',
                        return_create_instance_metadata)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 8357df594..b53c6c9be 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -49,10 +49,22 @@ FLAGS = flags.FLAGS
 FLAGS.verbose = True
 
 
-def return_server(context, id):
+FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+
+
+def fake_gen_uuid():
+    return FAKE_UUID
+
+
+def return_server_by_id(context, id):
     return stub_instance(id)
 
 
+def return_server_by_uuid(context, uuid):
+    id = 1
+    return stub_instance(id, uuid=uuid)
+
+
 def return_server_with_addresses(private, public):
     def _return_server(context, id):
         return stub_instance(id, private_address=private,
@@ -111,7 +123,8 @@ def instance_address(context, instance_id):
 
 
 def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
-                  host=None, power_state=0, reservation_id=""):
+                  host=None, power_state=0, reservation_id="",
+                  uuid=FAKE_UUID):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
@@ -129,7 +142,7 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
         server_name = "reservation_%s" % (reservation_id, )
 
     instance = {
-        "id": id,
+        "id": int(id),
         "admin_pass": "",
         "user_id": user_id,
         "project_id": "",
@@ -157,7 +170,8 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
         "display_name": server_name,
         "display_description": "",
         "locked": False,
-        "metadata": metadata}
+        "metadata": metadata,
+        "uuid": uuid}
 
     instance["fixed_ip"] = {
         "address": private_address,
@@ -196,8 +210,11 @@ class ServersTest(test.TestCase):
         fakes.stub_out_auth(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
         fakes.stub_out_image_service(self.stubs)
+        self.stubs.Set(utils, 'gen_uuid', fake_gen_uuid)
         self.stubs.Set(nova.db.api, 'instance_get_all', return_servers)
-        self.stubs.Set(nova.db.api, 'instance_get', return_server)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
+        self.stubs.Set(nova.db, 'instance_get_by_uuid',
+                       return_server_by_uuid)
         self.stubs.Set(nova.db.api, 'instance_get_all_by_user',
                        return_servers)
         self.stubs.Set(nova.db.api, 'instance_add_security_group',
@@ -229,6 +246,36 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
+    def test_get_server_by_uuid(self):
+        """
+        The steps involved with resolving a UUID are pretty complicated;
+        here's what's happening in this scenario:
+
+        1. Show is calling `routing_get`
+
+        2. `routing_get` is wrapped by `reroute_compute` which does the work
+           of resolving requests to child zones.
+
+        3. `reroute_compute` looks up the UUID by hitting the stub
+           (returns_server_by_uuid)
+
+        4. Since the stub return that the record exists, `reroute_compute`
+           considers the request to be 'zone local', so it replaces the UUID
+           in the argument list with an integer ID and then calls the inner
+           function ('get').
+
+        5. The call to `get` hits the other stub 'returns_server_by_id` which
+           has the UUID set to FAKE_UUID
+
+        So, counterintuitively, we call `get` twice on the `show` command.
+        """
+        req = webob.Request.blank('/v1.0/servers/%s' % FAKE_UUID)
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['uuid'], FAKE_UUID)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+
     def test_get_server_by_id_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/1')
         res = req.get_response(fakes.wsgi_app())
@@ -540,7 +587,8 @@ class ServersTest(test.TestCase):
     def _setup_for_create_instance(self):
         """Shared implementation for tests below that create instance"""
         def instance_create(context, inst):
-            return {'id': '1', 'display_name': 'server_test'}
+            return {'id': 1, 'display_name': 'server_test',
+                    'uuid': FAKE_UUID}
 
         def server_update(context, id, params):
             return instance_create(context, id)
@@ -594,11 +642,22 @@ class ServersTest(test.TestCase):
         self.assertEqual(1, server['id'])
         self.assertEqual(2, server['flavorId'])
         self.assertEqual(3, server['imageId'])
+        self.assertEqual(FAKE_UUID, server['uuid'])
         self.assertEqual(res.status_int, 200)
 
     def test_create_instance(self):
         self._test_create_instance_helper()
 
+    def test_create_instance_has_uuid(self):
+        """Tests at the db-layer instead of API layer since that's where the
+           UUID is generated
+        """
+        ctxt = context.RequestContext(1, 1)
+        values = {}
+        instance = nova.db.api.instance_create(ctxt, values)
+        expected = FAKE_UUID
+        self.assertEqual(instance['uuid'], expected)
+
     def test_create_instance_via_zones(self):
         """Server generated ReservationID"""
         self._setup_for_create_instance()
@@ -1443,7 +1502,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 400)
 
     def test_resized_server_has_correct_status(self):
-        req = self.webreq('/1', 'GET', dict(resize=dict(flavorId=3)))
+        req = self.webreq('/1', 'GET')
 
         def fake_migration_get(*args):
             return {}
@@ -1850,7 +1909,8 @@ class TestServerInstanceCreation(test.TestCase):
                     self.injected_files = kwargs['injected_files']
                 else:
                     self.injected_files = None
-                return [{'id': '1234', 'display_name': 'fakeinstance'}]
+                return [{'id': '1234', 'display_name': 'fakeinstance',
+                         'uuid': FAKE_UUID}]
 
             def set_admin_password(self, *args, **kwargs):
                 pass
diff --git a/nova/tests/api/openstack/test_wsgi.py b/nova/tests/api/openstack/test_wsgi.py
index 2fa50ac9b..73a26a087 100644
--- a/nova/tests/api/openstack/test_wsgi.py
+++ b/nova/tests/api/openstack/test_wsgi.py
@@ -10,13 +10,13 @@ from nova.api.openstack import wsgi
 
 class RequestTest(test.TestCase):
     def test_content_type_missing(self):
-        request = wsgi.Request.blank('/tests/123')
+        request = wsgi.Request.blank('/tests/123', method='POST')
         request.body = "<body />"
         self.assertRaises(exception.InvalidContentType,
                           request.get_content_type)
 
     def test_content_type_unsupported(self):
-        request = wsgi.Request.blank('/tests/123')
+        request = wsgi.Request.blank('/tests/123', method='POST')
         request.headers["Content-Type"] = "text/html"
         request.body = "asdf<br />"
         self.assertRaises(exception.InvalidContentType,
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index ecefc464a..2297d2f0e 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -32,7 +32,7 @@ flags.DECLARE('fake_network', 'nova.network.manager')
 FLAGS['network_size'].SetDefault(8)
 FLAGS['num_networks'].SetDefault(2)
 FLAGS['fake_network'].SetDefault(True)
-FLAGS['image_service'].SetDefault('nova.image.local.LocalImageService')
+FLAGS['image_service'].SetDefault('nova.image.fake.FakeImageService')
 flags.DECLARE('num_shelves', 'nova.volume.driver')
 flags.DECLARE('blades_per_shelf', 'nova.volume.driver')
 flags.DECLARE('iscsi_num_targets', 'nova.volume.driver')
diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index eb9a3056e..76c03c5fa 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -221,30 +221,30 @@ class TestOpenStackClient(object):
         return self.api_delete('/flavors/%s' % flavor_id)
 
     def get_volume(self, volume_id):
-        return self.api_get('/volumes/%s' % volume_id)['volume']
+        return self.api_get('/os-volumes/%s' % volume_id)['volume']
 
     def get_volumes(self, detail=True):
-        rel_url = '/volumes/detail' if detail else '/volumes'
+        rel_url = '/os-volumes/detail' if detail else '/os-volumes'
         return self.api_get(rel_url)['volumes']
 
     def post_volume(self, volume):
-        return self.api_post('/volumes', volume)['volume']
+        return self.api_post('/os-volumes', volume)['volume']
 
     def delete_volume(self, volume_id):
-        return self.api_delete('/volumes/%s' % volume_id)
+        return self.api_delete('/os-volumes/%s' % volume_id)
 
     def get_server_volume(self, server_id, attachment_id):
-        return self.api_get('/servers/%s/volume_attachments/%s' %
+        return self.api_get('/servers/%s/os-volume_attachments/%s' %
                             (server_id, attachment_id))['volumeAttachment']
 
     def get_server_volumes(self, server_id):
-        return self.api_get('/servers/%s/volume_attachments' %
+        return self.api_get('/servers/%s/os-volume_attachments' %
                             (server_id))['volumeAttachments']
 
     def post_server_volume(self, server_id, volume_attachment):
-        return self.api_post('/servers/%s/volume_attachments' %
+        return self.api_post('/servers/%s/os-volume_attachments' %
                         (server_id), volume_attachment)['volumeAttachment']
 
     def delete_server_volume(self, server_id, attachment_id):
-        return self.api_delete('/servers/%s/volume_attachments/%s' %
+        return self.api_delete('/servers/%s/os-volume_attachments/%s' %
                             (server_id, attachment_id))
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 0d7929996..4be59d411 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -48,6 +48,10 @@ flags.DECLARE('stub_network', 'nova.compute.manager')
 flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
+FAKE_UUID_NOT_FOUND = 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+
+
 class TestDriver(driver.Scheduler):
     """Scheduler Driver for Tests"""
     def schedule(context, topic, *args, **kwargs):
@@ -926,12 +930,23 @@ def zone_get_all(context):
            ]
 
 
+def fake_instance_get_by_uuid(context, uuid):
+    if FAKE_UUID_NOT_FOUND:
+        raise exception.InstanceNotFound(instance_id=uuid)
+    else:
+        return {'id': 1}
+
+
 class FakeRerouteCompute(api.reroute_compute):
+    def __init__(self, method_name, id_to_return=1):
+        super(FakeRerouteCompute, self).__init__(method_name)
+        self.id_to_return = id_to_return
+
     def _call_child_zones(self, zones, function):
         return []
 
     def get_collection_context_and_id(self, args, kwargs):
-        return ("servers", None, 1)
+        return ("servers", None, self.id_to_return)
 
     def unmarshall_result(self, zone_responses):
         return dict(magic="found me")
@@ -960,6 +975,8 @@ class ZoneRedirectTest(test.TestCase):
         self.stubs = stubout.StubOutForTesting()
 
         self.stubs.Set(db, 'zone_get_all', zone_get_all)
+        self.stubs.Set(db, 'instance_get_by_uuid',
+                       fake_instance_get_by_uuid)
 
         self.enable_zone_routing = FLAGS.enable_zone_routing
         FLAGS.enable_zone_routing = True
@@ -976,8 +993,19 @@ class ZoneRedirectTest(test.TestCase):
         except api.RedirectResult, e:
             self.fail(_("Successful database hit should succeed"))
 
-    def test_trap_not_found_locally(self):
+    def test_trap_not_found_locally_id_passed(self):
+        """When an integer ID is not found locally, we cannot reroute to
+        another zone, so just return InstanceNotFound exception
+        """
         decorator = FakeRerouteCompute("foo")
+        self.assertRaises(exception.InstanceNotFound,
+            decorator(go_boom), None, None, 1)
+
+    def test_trap_not_found_locally_uuid_passed(self):
+        """When a UUID is found, if the item isn't found locally, we should
+        try to reroute to a child zone to see if they have it
+        """
+        decorator = FakeRerouteCompute("foo", id_to_return=FAKE_UUID_NOT_FOUND)
         try:
             result = decorator(go_boom)(None, None, 1)
             self.assertFail(_("Should have rerouted."))
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 2efcd304d..fd1c21386 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -35,7 +35,7 @@ from nova import utils
 from nova.auth import manager
 from nova.api.ec2 import cloud
 from nova.api.ec2 import ec2utils
-from nova.image import local
+from nova.image import fake
 
 
 FLAGS = flags.FLAGS
@@ -70,8 +70,8 @@ class CloudTestCase(test.TestCase):
             return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
                     'type': 'machine', 'image_state': 'available'}}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_show)
-        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'show_by_name', fake_show)
 
         # NOTE(vish): set up a manual wait so rpc.cast has a chance to finish
         rpc_cast = rpc.cast
@@ -304,7 +304,7 @@ class CloudTestCase(test.TestCase):
         def fake_show_none(meh, context, id):
             raise exception.ImageNotFound(image_id='bad_image_id')
 
-        self.stubs.Set(local.LocalImageService, 'detail', fake_detail)
+        self.stubs.Set(fake._FakeImageService, 'detail', fake_detail)
         # list all
         result1 = describe_images(self.context)
         result1 = result1['imagesSet'][0]
@@ -318,8 +318,8 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(2, len(result3['imagesSet']))
         # provide an non-existing image_id
         self.stubs.UnsetAll()
-        self.stubs.Set(local.LocalImageService, 'show', fake_show_none)
-        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show_none)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show_none)
+        self.stubs.Set(fake._FakeImageService, 'show_by_name', fake_show_none)
         self.assertRaises(exception.ImageNotFound, describe_images,
                           self.context, ['ami-fake'])
 
@@ -330,8 +330,8 @@ class CloudTestCase(test.TestCase):
             return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
                     'type': 'machine'}, 'is_public': True}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_show)
-        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'show_by_name', fake_show)
         result = describe_image_attribute(self.context, 'ami-00000001',
                                           'launchPermission')
         self.assertEqual([{'group': 'all'}], result['launchPermission'])
@@ -346,9 +346,9 @@ class CloudTestCase(test.TestCase):
         def fake_update(meh, context, image_id, metadata, data=None):
             return metadata
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_show)
-        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
-        self.stubs.Set(local.LocalImageService, 'update', fake_update)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'show_by_name', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'update', fake_update)
         result = modify_image_attribute(self.context, 'ami-00000001',
                                           'launchPermission', 'add',
                                            user_group=['all'])
@@ -360,7 +360,7 @@ class CloudTestCase(test.TestCase):
         def fake_delete(self, context, id):
             return None
 
-        self.stubs.Set(local.LocalImageService, 'delete', fake_delete)
+        self.stubs.Set(fake._FakeImageService, 'delete', fake_delete)
         # valid image
         result = deregister_image(self.context, 'ami-00000001')
         self.assertEqual(result['imageId'], 'ami-00000001')
@@ -370,7 +370,7 @@ class CloudTestCase(test.TestCase):
         def fake_detail_empty(self, context):
             return []
 
-        self.stubs.Set(local.LocalImageService, 'detail', fake_detail_empty)
+        self.stubs.Set(fake._FakeImageService, 'detail', fake_detail_empty)
         self.assertRaises(exception.ImageNotFound, deregister_image,
                           self.context, 'ami-bad001')
 
@@ -463,6 +463,12 @@ class CloudTestCase(test.TestCase):
         self.cloud.delete_key_pair(self.context, 'test')
 
     def test_run_instances(self):
+        # stub out the rpc call
+        def stub_cast(*args, **kwargs):
+            pass
+
+        self.stubs.Set(rpc, 'cast', stub_cast)
+
         kwargs = {'image_id': FLAGS.default_image,
                   'instance_type': FLAGS.default_instance_type,
                   'max_count': 1}
@@ -472,7 +478,7 @@ class CloudTestCase(test.TestCase):
         self.assertEqual(instance['imageId'], 'ami-00000001')
         self.assertEqual(instance['displayName'], 'Server 1')
         self.assertEqual(instance['instanceId'], 'i-00000001')
-        self.assertEqual(instance['instanceState']['name'], 'networking')
+        self.assertEqual(instance['instanceState']['name'], 'scheduling')
         self.assertEqual(instance['instanceType'], 'm1.small')
 
     def test_run_instances_image_state_none(self):
@@ -486,7 +492,7 @@ class CloudTestCase(test.TestCase):
                     'type': 'machine'}}
 
         self.stubs.UnsetAll()
-        self.stubs.Set(local.LocalImageService, 'show', fake_show_no_state)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show_no_state)
         self.assertRaises(exception.ApiError, run_instances,
                           self.context, **kwargs)
 
@@ -501,7 +507,7 @@ class CloudTestCase(test.TestCase):
                     'type': 'machine', 'image_state': 'decrypting'}}
 
         self.stubs.UnsetAll()
-        self.stubs.Set(local.LocalImageService, 'show', fake_show_decrypt)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show_decrypt)
         self.assertRaises(exception.ApiError, run_instances,
                           self.context, **kwargs)
 
@@ -515,7 +521,7 @@ class CloudTestCase(test.TestCase):
             return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1,
                     'type': 'machine'}, 'status': 'active'}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_show_stat_active)
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show_stat_active)
 
         result = run_instances(self.context, **kwargs)
         self.assertEqual(len(result['instancesSet']), 1)
@@ -544,7 +550,9 @@ class CloudTestCase(test.TestCase):
 
     def test_update_of_instance_wont_update_private_fields(self):
         inst = db.instance_create(self.context, {})
-        self.cloud.update_instance(self.context, inst['id'],
+        ec2_id = ec2utils.id_to_ec2_id(inst['id'])
+        self.cloud.update_instance(self.context, ec2_id,
+                                   display_name='c00l 1m4g3',
                                    mac_address='DE:AD:BE:EF')
         inst = db.instance_get(self.context, inst['id'])
         self.assertEqual(None, inst['mac_address'])
@@ -671,7 +679,7 @@ class CloudTestCase(test.TestCase):
                   'max_count': 1,
                   'block_device_mapping': [{'device_name': '/dev/vdb',
                                             'volume_id': vol1['id'],
-                                            'delete_on_termination': False,},
+                                            'delete_on_termination': False, },
                                            {'device_name': '/dev/vdc',
                                             'volume_id': vol2['id'],
                                             'delete_on_termination': True, },
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index ae5761ef9..439508b27 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -22,21 +22,21 @@ Tests For Compute
 import mox
 import stubout
 
+from nova.auth import manager
 from nova import compute
+from nova.compute import instance_types
+from nova.compute import manager as compute_manager
+from nova.compute import power_state
 from nova import context
 from nova import db
+from nova.db.sqlalchemy import models
 from nova import exception
 from nova import flags
+import nova.image.fake
 from nova import log as logging
 from nova import rpc
 from nova import test
 from nova import utils
-from nova.auth import manager
-from nova.compute import instance_types
-from nova.compute import manager as compute_manager
-from nova.compute import power_state
-from nova.db.sqlalchemy import models
-from nova.image import local
 
 LOG = logging.getLogger('nova.tests.compute')
 FLAGS = flags.FLAGS
@@ -73,7 +73,7 @@ class ComputeTestCase(test.TestCase):
         def fake_show(meh, context, id):
             return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+        self.stubs.Set(nova.image.fake._FakeImageService, 'show', fake_show)
 
     def tearDown(self):
         self.manager.delete_user(self.user)
@@ -281,6 +281,14 @@ class ComputeTestCase(test.TestCase):
                 "File Contents")
         self.compute.terminate_instance(self.context, instance_id)
 
+    def test_agent_update(self):
+        """Ensure instance can have its agent updated"""
+        instance_id = self._create_instance()
+        self.compute.run_instance(self.context, instance_id)
+        self.compute.agent_update(self.context, instance_id,
+                'http://127.0.0.1/agent', '00112233445566778899aabbccddeeff')
+        self.compute.terminate_instance(self.context, instance_id)
+
     def test_snapshot(self):
         """Ensure instance can be snapshotted"""
         instance_id = self._create_instance()
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index 8f7e83c3e..3a3f914e4 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -275,3 +275,21 @@ class GenericUtilsTestCase(test.TestCase):
         # error case
         result = utils.parse_server_string('www.exa:mple.com:8443')
         self.assertEqual(('', ''), result)
+
+
+class IsUUIDLikeTestCase(test.TestCase):
+    def assertUUIDLike(self, val, expected):
+        result = utils.is_uuid_like(val)
+        self.assertEqual(result, expected)
+
+    def test_good_uuid(self):
+        val = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+        self.assertUUIDLike(val, True)
+
+    def test_integer_passed(self):
+        val = 1
+        self.assertUUIDLike(val, False)
+
+    def test_non_uuid_string_passed(self):
+        val = 'foo-fooo'
+        self.assertUUIDLike(val, False)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index d1c88287a..d9a514745 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -33,12 +33,12 @@ from nova import utils
 from nova.auth import manager
 from nova.compute import instance_types
 from nova.compute import power_state
+from nova import exception
 from nova.virt import xenapi_conn
 from nova.virt.xenapi import fake as xenapi_fake
 from nova.virt.xenapi import volume_utils
+from nova.virt.xenapi import vmops
 from nova.virt.xenapi import vm_utils
-from nova.virt.xenapi.vmops import SimpleDH
-from nova.virt.xenapi.vmops import VMOps
 from nova.tests.db import fakes as db_fakes
 from nova.tests.xenapi import stubs
 from nova.tests.glance import stubs as glance_stubs
@@ -84,7 +84,8 @@ class XenAPIVolumeTestCase(test.TestCase):
                   'ramdisk_id': 3,
                   'instance_type_id': '3',  # m1.large
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'}
+                  'os_type': 'linux',
+                  'architecture': 'x86-64'}
 
     def _create_volume(self, size='0'):
         """Create a volume object."""
@@ -191,7 +192,7 @@ class XenAPIVMTestCase(test.TestCase):
         stubs.stubout_get_this_vm_uuid(self.stubs)
         stubs.stubout_stream_disk(self.stubs)
         stubs.stubout_is_vdi_pv(self.stubs)
-        self.stubs.Set(VMOps, 'reset_network', reset_network)
+        self.stubs.Set(vmops.VMOps, 'reset_network', reset_network)
         stubs.stub_out_vm_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs)
         fake_utils.stub_out_utils_execute(self.stubs)
@@ -211,7 +212,8 @@ class XenAPIVMTestCase(test.TestCase):
                 'ramdisk_id': 3,
                 'instance_type_id': '3',  # m1.large
                 'mac_address': 'aa:bb:cc:dd:ee:ff',
-                'os_type': 'linux'}
+                'os_type': 'linux',
+                'architecture': 'x86-64'}
             instance = db.instance_create(self.context, values)
             self.conn.spawn(instance)
 
@@ -228,6 +230,23 @@ class XenAPIVMTestCase(test.TestCase):
         instance = self._create_instance()
         self.conn.get_diagnostics(instance)
 
+    def test_instance_snapshot_fails_with_no_primary_vdi(self):
+        def create_bad_vbd(vm_ref, vdi_ref):
+            vbd_rec = {'VM': vm_ref,
+               'VDI': vdi_ref,
+               'userdevice': 'fake',
+               'currently_attached': False}
+            vbd_ref = xenapi_fake._create_object('VBD', vbd_rec)
+            xenapi_fake.after_VBD_create(vbd_ref, vbd_rec)
+            return vbd_ref
+
+        self.stubs.Set(xenapi_fake, 'create_vbd', create_bad_vbd)
+        stubs.stubout_instance_snapshot(self.stubs)
+        instance = self._create_instance()
+
+        name = "MySnapshot"
+        self.assertRaises(exception.Error, self.conn.snapshot, instance, name)
+
     def test_instance_snapshot(self):
         stubs.stubout_instance_snapshot(self.stubs)
         instance = self._create_instance()
@@ -352,7 +371,8 @@ class XenAPIVMTestCase(test.TestCase):
 
     def _test_spawn(self, image_ref, kernel_id, ramdisk_id,
                     instance_type_id="3", os_type="linux",
-                    instance_id=1, check_injection=False):
+                    architecture="x86-64", instance_id=1,
+                    check_injection=False):
         stubs.stubout_loopingcall_start(self.stubs)
         values = {'id': instance_id,
                   'project_id': self.project.id,
@@ -362,11 +382,14 @@ class XenAPIVMTestCase(test.TestCase):
                   'ramdisk_id': ramdisk_id,
                   'instance_type_id': instance_type_id,
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': os_type}
+                  'os_type': os_type,
+                  'architecture': architecture}
         instance = db.instance_create(self.context, values)
         self.conn.spawn(instance)
         self.create_vm_record(self.conn, os_type, instance_id)
         self.check_vm_record(self.conn, check_injection)
+        self.assertTrue(instance.os_type)
+        self.assertTrue(instance.architecture)
 
     def test_spawn_not_enough_memory(self):
         FLAGS.xenapi_image_service = 'glance'
@@ -391,7 +414,7 @@ class XenAPIVMTestCase(test.TestCase):
     def test_spawn_vhd_glance_linux(self):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None,
-                         os_type="linux")
+                         os_type="linux", architecture="x86-64")
         self.check_vm_params_for_linux()
 
     def test_spawn_vhd_glance_swapdisk(self):
@@ -420,7 +443,7 @@ class XenAPIVMTestCase(test.TestCase):
     def test_spawn_vhd_glance_windows(self):
         FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_VHD, None, None,
-                         os_type="windows")
+                         os_type="windows", architecture="i386")
         self.check_vm_params_for_windows()
 
     def test_spawn_glance(self):
@@ -571,7 +594,8 @@ class XenAPIVMTestCase(test.TestCase):
             'ramdisk_id': 3,
             'instance_type_id': '3',  # m1.large
             'mac_address': 'aa:bb:cc:dd:ee:ff',
-            'os_type': 'linux'}
+            'os_type': 'linux',
+            'architecture': 'x86-64'}
         instance = db.instance_create(self.context, values)
         self.conn.spawn(instance)
         return instance
@@ -581,8 +605,8 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
     """Unit tests for Diffie-Hellman code."""
     def setUp(self):
         super(XenAPIDiffieHellmanTestCase, self).setUp()
-        self.alice = SimpleDH()
-        self.bob = SimpleDH()
+        self.alice = vmops.SimpleDH()
+        self.bob = vmops.SimpleDH()
 
     def test_shared(self):
         alice_pub = self.alice.get_public()
@@ -646,7 +670,8 @@ class XenAPIMigrateInstance(test.TestCase):
                   'local_gb': 5,
                   'instance_type_id': '3',  # m1.large
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
-                  'os_type': 'linux'}
+                  'os_type': 'linux',
+                  'architecture': 'x86-64'}
 
         fake_utils.stub_out_utils_execute(self.stubs)
         stubs.stub_out_migration_methods(self.stubs)
@@ -685,6 +710,7 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         self.fake_instance = FakeInstance()
         self.fake_instance.id = 42
         self.fake_instance.os_type = 'linux'
+        self.fake_instance.architecture = 'x86-64'
 
     def assert_disk_type(self, disk_type):
         dt = vm_utils.VMHelper.determine_disk_image_type(
@@ -729,6 +755,28 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         self.assert_disk_type(vm_utils.ImageType.DISK_VHD)
 
 
+class CompareVersionTestCase(test.TestCase):
+    def test_less_than(self):
+        """Test that cmp_version compares a as less than b"""
+        self.assertTrue(vmops.cmp_version('1.2.3.4', '1.2.3.5') < 0)
+
+    def test_greater_than(self):
+        """Test that cmp_version compares a as greater than b"""
+        self.assertTrue(vmops.cmp_version('1.2.3.5', '1.2.3.4') > 0)
+
+    def test_equal(self):
+        """Test that cmp_version compares a as equal to b"""
+        self.assertTrue(vmops.cmp_version('1.2.3.4', '1.2.3.4') == 0)
+
+    def test_non_lexical(self):
+        """Test that cmp_version compares non-lexically"""
+        self.assertTrue(vmops.cmp_version('1.2.3.10', '1.2.3.4') > 0)
+
+    def test_length(self):
+        """Test that cmp_version compares by length as last resort"""
+        self.assertTrue(vmops.cmp_version('1.2.3', '1.2.3.4') < 0)
+
+
 class FakeXenApi(object):
     """Fake XenApi for testing HostState."""
 
diff --git a/nova/utils.py b/nova/utils.py
index 691134ada..e2ac16f31 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -35,6 +35,7 @@ import struct
 import sys
 import time
 import types
+import uuid
 from xml.sax import saxutils
 
 from eventlet import event
@@ -726,3 +727,17 @@ def parse_server_string(server_str):
     except:
         LOG.debug(_('Invalid server_string: %s' % server_str))
         return ('', '')
+
+
+def gen_uuid():
+    return uuid.uuid4()
+
+
+def is_uuid_like(val):
+    """For our purposes, a UUID is a string in canoical form:
+
+        aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa
+    """
+    if not isinstance(val, basestring):
+        return False
+    return (len(val) == 36) and (val.count('-') == 4)
diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index 6341e81d2..8dd7057a3 100644
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -234,6 +234,10 @@ class ComputeDriver(object):
         """
         raise NotImplementedError()
 
+    def agent_update(self, instance, url, md5hash):
+        """Update agent on the VM instance."""
+        raise NotImplementedError()
+
     def inject_network_info(self, instance):
         """inject network info for specified instance"""
         raise NotImplementedError()
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index 3a65fec8b..94aecec24 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -225,6 +225,21 @@ class FakeConnection(driver.ComputeDriver):
         """
         pass
 
+    def agent_update(self, instance, url, md5hash):
+        """
+        Update agent on the specified instance.
+
+        The first parameter is an instance of nova.compute.service.Instance,
+        and so the instance is being specified as instance.name. The second
+        parameter is the URL of the agent to be fetched and updated on the
+        instance; the third is the md5 hash of the file for verification
+        purposes.
+
+        The work will be done asynchronously.  This function returns a
+        task that allows the caller to detect when it is complete.
+        """
+        pass
+
     def rescue(self, instance):
         """
         Rescue the specified instance.
diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py
index 48edc5384..70adba74f 100644
--- a/nova/virt/vmwareapi/vmware_images.py
+++ b/nova/virt/vmwareapi/vmware_images.py
@@ -90,8 +90,6 @@ def fetch_image(image, instance, **kwargs):
         func = _get_glance_image

     elif FLAGS.image_service == "nova.image.s3.S3ImageService":

         func = _get_s3_image

-    elif FLAGS.image_service == "nova.image.local.LocalImageService":

-        func = _get_local_image

     else:

         raise NotImplementedError(_("The Image Service %s is not implemented")

                                   % FLAGS.image_service)

@@ -105,8 +103,6 @@ def upload_image(image, instance, **kwargs):
         func = _put_glance_image

     elif FLAGS.image_service == "nova.image.s3.S3ImageService":

         func = _put_s3_image

-    elif FLAGS.image_service == "nova.image.local.LocalImageService":

-        func = _put_local_image

     else:

         raise NotImplementedError(_("The Image Service %s is not implemented")

                                   % FLAGS.image_service)

@@ -192,8 +188,6 @@ def get_vmdk_size_and_properties(image, instance):
         size, properties = meta_data["size"], meta_data["properties"]

     elif FLAGS.image_service == "nova.image.s3.S3ImageService":

         raise NotImplementedError

-    elif FLAGS.image_service == "nova.image.local.LocalImageService":

-        raise NotImplementedError

     LOG.debug(_("Got image size of %(size)s for the image %(image)s") %

               locals())

     return size, properties

diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py
index 113198689..d5ac39473 100644
--- a/nova/virt/xenapi/fake.py
+++ b/nova/virt/xenapi/fake.py
@@ -146,6 +146,7 @@ def create_vdi(name_label, read_only, sr_ref, sharable):
 def create_vbd(vm_ref, vdi_ref):
     vbd_rec = {'VM': vm_ref,
                'VDI': vdi_ref,
+               'userdevice': '0',
                'currently_attached': False}
     vbd_ref = _create_object('VBD', vbd_rec)
     after_VBD_create(vbd_ref, vbd_rec)
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 11da221f2..f91958c57 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -283,19 +283,16 @@ class VMHelper(HelperBase):
 
     @classmethod
     def get_vdi_for_vm_safely(cls, session, vm_ref):
-        vdi_refs = VMHelper.lookup_vm_vdis(session, vm_ref)
-        if vdi_refs is None:
-            raise Exception(_("No VDIs found for VM %s") % vm_ref)
-        else:
-            num_vdis = len(vdi_refs)
-            if num_vdis != 1:
-                raise Exception(
-                        _("Unexpected number of VDIs (%(num_vdis)s) found"
-                        " for VM %(vm_ref)s") % locals())
-
-        vdi_ref = vdi_refs[0]
-        vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
-        return vdi_ref, vdi_rec
+        """Retrieves the primary VDI for a VM"""
+        vbd_refs = session.get_xenapi().VM.get_VBDs(vm_ref)
+        for vbd in vbd_refs:
+            vbd_rec = session.get_xenapi().VBD.get_record(vbd)
+            # Convention dictates the primary VDI will be userdevice 0
+            if vbd_rec['userdevice'] == '0':
+                vdi_rec = session.get_xenapi().VDI.get_record(vbd_rec['VDI'])
+                return vbd_rec['VDI'], vdi_rec
+        raise exception.Error(_("No primary VDI found for"
+                "%(vm_ref)s") % locals())
 
     @classmethod
     def create_snapshot(cls, session, instance_id, vm_ref, label):
@@ -329,12 +326,6 @@ class VMHelper(HelperBase):
         return template_vm_ref, template_vdi_uuids
 
     @classmethod
-    def get_sr(cls, session, sr_label='slices'):
-        """Finds the SR named by the given name label and returns
-        the UUID"""
-        return session.call_xenapi('SR.get_by_name_label', sr_label)[0]
-
-    @classmethod
     def get_sr_path(cls, session):
         """Return the path to our storage repository
 
@@ -789,8 +780,7 @@ class VMHelper(HelperBase):
     @classmethod
     def scan_default_sr(cls, session):
         """Looks for the system default SR and triggers a re-scan"""
-        #FIXME(sirp/mdietz): refactor scan_default_sr in there
-        sr_ref = cls.get_sr(session)
+        sr_ref = find_sr(session)
         session.call_xenapi('SR.scan', sr_ref)
 
 
@@ -882,7 +872,8 @@ def get_vdi_for_vm_safely(session, vm_ref):
     else:
         num_vdis = len(vdi_refs)
         if num_vdis != 1:
-            raise Exception(_("Unexpected number of VDIs (%(num_vdis)s) found"
+            raise exception.Exception(_("Unexpected number of VDIs"
+                    "(%(num_vdis)s) found"
                     " for VM %(vm_ref)s") % locals())
 
     vdi_ref = vdi_refs[0]
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index d105cf300..2f4286184 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -47,6 +47,21 @@ LOG = logging.getLogger("nova.virt.xenapi.vmops")
 FLAGS = flags.FLAGS
 
 
+def cmp_version(a, b):
+    """Compare two version strings (eg 0.0.1.10 > 0.0.1.9)"""
+    a = a.split('.')
+    b = b.split('.')
+
+    # Compare each individual portion of both version strings
+    for va, vb in zip(a, b):
+        ret = int(va) - int(vb)
+        if ret:
+            return ret
+
+    # Fallback to comparing length last
+    return len(a) - len(b)
+
+
 class VMOps(object):
     """
     Management class for VM-related tasks
@@ -218,6 +233,34 @@ class VMOps(object):
         LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.')
                  % locals())
 
+        ctx = context.get_admin_context()
+        agent_build = db.agent_build_get_by_triple(ctx, 'xen',
+                              instance.os_type, instance.architecture)
+        if agent_build:
+            LOG.info(_('Latest agent build for %(hypervisor)s/%(os)s' + \
+                       '/%(architecture)s is %(version)s') % agent_build)
+        else:
+            LOG.info(_('No agent build found for %(hypervisor)s/%(os)s' + \
+                       '/%(architecture)s') % {
+                        'hypervisor': 'xen',
+                        'os': instance.os_type,
+                        'architecture': instance.architecture})
+
+        def _check_agent_version():
+            version = self.get_agent_version(instance)
+            if not version:
+                LOG.info(_('No agent version returned by instance'))
+                return
+
+            LOG.info(_('Instance agent version: %s') % version)
+            if not agent_build:
+                return
+
+            if cmp_version(version, agent_build['version']) < 0:
+                LOG.info(_('Updating Agent to %s') % agent_build['version'])
+                self.agent_update(instance, agent_build['url'],
+                              agent_build['md5hash'])
+
         def _inject_files():
             injected_files = instance.injected_files
             if injected_files:
@@ -252,6 +295,7 @@ class VMOps(object):
                 if state == power_state.RUNNING:
                     LOG.debug(_('Instance %s: booted'), instance_name)
                     timer.stop()
+                    _check_agent_version()
                     _inject_files()
                     _set_admin_password()
                     return True
@@ -458,6 +502,34 @@ class VMOps(object):
         task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref)
         self._session.wait_for_task(task, instance.id)
 
+    def get_agent_version(self, instance):
+        """Get the version of the agent running on the VM instance."""
+
+        # Send the encrypted password
+        transaction_id = str(uuid.uuid4())
+        args = {'id': transaction_id}
+        resp = self._make_agent_call('version', instance, '', args)
+        if resp is None:
+            # No response from the agent
+            return
+        resp_dict = json.loads(resp)
+        return resp_dict['message']
+
+    def agent_update(self, instance, url, md5sum):
+        """Update agent on the VM instance."""
+
+        # Send the encrypted password
+        transaction_id = str(uuid.uuid4())
+        args = {'id': transaction_id, 'url': url, 'md5sum': md5sum}
+        resp = self._make_agent_call('agentupdate', instance, '', args)
+        if resp is None:
+            # No response from the agent
+            return
+        resp_dict = json.loads(resp)
+        if resp_dict['returncode'] != '0':
+            raise RuntimeError(resp_dict['message'])
+        return resp_dict['message']
+
     def set_admin_password(self, instance, new_pass):
         """Set the root/admin password on the VM instance.