Revert to using context; to avoid conflict, we import context module as nova_context; add context to rescue

11 files changed, 86 insertions, 85 deletions

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 56331f86b..cf4ee229d 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -660,7 +660,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         _update_state = lambda result: self._update_state_callback(
                 self, context, instance_id, result)
         network_info = self._get_instance_nw_info(context, instance_ref)
-        self.driver.rescue(instance_ref, _update_state, network_info)
+        self.driver.rescue(context, instance_ref, _update_state, network_info)
         self._update_state(context, instance_id)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index 4be847dc6..4f3cfefad 100644
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -65,7 +65,7 @@ class ComputeDriver(object):
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def spawn(self, cxt, instance, network_info,
+    def spawn(self, context, instance, network_info,
               block_device_mapping=None):
         """Launch a VM for the specified instance"""
         raise NotImplementedError()
@@ -131,11 +131,11 @@ class ComputeDriver(object):
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def snapshot(self, cxt, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """Create snapshot from a running VM instance."""
         raise NotImplementedError()
 
-    def finish_migration(self, cxt, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                          resize_instance):
         """Completes a resize, turning on the migrated instance"""
         raise NotImplementedError()
@@ -165,9 +165,8 @@ class ComputeDriver(object):
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance"""
-        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def unrescue(self, instance, callback, network_info):
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index 23aa603ef..c08f8069d 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -129,7 +129,7 @@ class FakeConnection(driver.ComputeDriver):
             info_list.append(self._map_to_instance_info(instance))
         return info_list
 
-    def spawn(self, cxt, instance, network_info,
+    def spawn(self, context, instance, network_info,
               block_device_mapping=None):
         """
         Create a new instance/VM/domain on the virtualization platform.
@@ -154,7 +154,7 @@ class FakeConnection(driver.ComputeDriver):
         fake_instance = FakeInstance(name, state)
         self.instances[name] = fake_instance
 
-    def snapshot(self, cxt, instance, name):
+    def snapshot(self, context, instance, name):
         """
         Snapshots the specified instance.
 
@@ -241,7 +241,7 @@ class FakeConnection(driver.ComputeDriver):
         """
         pass
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """
         Rescue the specified instance.
         """
diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py
index cbfe5fad1..3428a7fc1 100644
--- a/nova/virt/hyperv.py
+++ b/nova/virt/hyperv.py
@@ -138,7 +138,7 @@ class HyperVConnection(driver.ComputeDriver):
 
         return instance_infos
 
-    def spawn(self, cxt, instance, network_info,
+    def spawn(self, context, instance, network_info,
               block_device_mapping=None):
         """ Create a new VM and start it."""
         vm = self._lookup(instance.name)
diff --git a/nova/virt/images.py b/nova/virt/images.py
index 2e9fca3d6..54c691a40 100644
--- a/nova/virt/images.py
+++ b/nova/virt/images.py
@@ -21,7 +21,6 @@
 Handling of VM disk images.
 """
 
-from nova import context
 from nova import flags
 from nova.image import glance as glance_image_service
 import nova.image
@@ -33,13 +32,12 @@ FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.virt.images')
 
 
-def fetch(image_href, path, _user_id, _project_id):
+def fetch(context, image_href, path, _user_id, _project_id):
     # TODO(vish): Improve context handling and add owner and auth data
     #             when it is added to glance.  Right now there is no
     #             auth checking in glance, so we assume that access was
     #             checked before we got here.
     (image_service, image_id) = nova.image.get_image_service(image_href)
     with open(path, "wb") as image_file:
-        elevated = context.get_admin_context()
-        metadata = image_service.get(elevated, image_id, image_file)
+        metadata = image_service.get(context, image_id, image_file)
     return metadata
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 81d302ea6..71ccdf57d 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -54,7 +54,7 @@ from xml.etree import ElementTree
 from eventlet import greenthread
 from eventlet import tpool
 
-from nova import context
+from nova import context as nova_context
 from nova import db
 from nova import exception
 from nova import flags
@@ -174,7 +174,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def init_host(self, host):
         # Adopt existing VM's running here
-        ctxt = context.get_admin_context()
+        ctxt = nova_context.get_admin_context()
         for instance in db.instance_get_all_by_host(ctxt, host):
             try:
                 LOG.debug(_('Checking state of %s'), instance['name'])
@@ -396,7 +396,7 @@ class LibvirtConnection(driver.ComputeDriver):
         virt_dom.detachDevice(xml)
 
     @exception.wrap_exception()
-    def snapshot(self, cxt, instance, image_href):
+    def snapshot(self, context, instance, image_href):
         """Create snapshot from a running VM instance.
 
         This command only works with qemu 0.14+, the qemu_img flag is
@@ -405,14 +405,13 @@ class LibvirtConnection(driver.ComputeDriver):
 
         """
         virt_dom = self._lookup_by_name(instance['name'])
-        elevated = context.get_admin_context()
 
         (image_service, image_id) = nova.image.get_image_service(
             instance['image_ref'])
-        base = image_service.show(elevated, image_id)
+        base = image_service.show(context, image_id)
         (snapshot_image_service, snapshot_image_id) = \
             nova.image.get_image_service(image_href)
-        snapshot = snapshot_image_service.show(elevated, snapshot_image_id)
+        snapshot = snapshot_image_service.show(context, snapshot_image_id)
 
         metadata = {'disk_format': base['disk_format'],
                     'container_format': base['container_format'],
@@ -463,7 +462,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
         # Upload that image to the image service
         with open(out_path) as image_file:
-            image_service.update(elevated,
+            image_service.update(context,
                                  image_href,
                                  metadata,
                                  image_file)
@@ -538,7 +537,7 @@ class LibvirtConnection(driver.ComputeDriver):
         dom.create()
 
     @exception.wrap_exception()
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Loads a VM using rescue images.
 
         A rescue is normally performed when something goes wrong with the
@@ -553,7 +552,7 @@ class LibvirtConnection(driver.ComputeDriver):
         rescue_images = {'image_id': FLAGS.rescue_image_id,
                          'kernel_id': FLAGS.rescue_kernel_id,
                          'ramdisk_id': FLAGS.rescue_ramdisk_id}
-        self._create_image(instance, xml, '.rescue', rescue_images)
+        self._create_image(context, instance, xml, '.rescue', rescue_images)
         self._create_new_domain(xml)
 
         def _wait_for_rescue():
@@ -592,14 +591,14 @@ class LibvirtConnection(driver.ComputeDriver):
     # NOTE(ilyaalekseyev): Implementation like in multinics
     # for xenapi(tr3buchet)
     @exception.wrap_exception()
-    def spawn(self, cxt, instance, network_info,
+    def spawn(self, context, instance, network_info,
               block_device_mapping=None):
         xml = self.to_xml(instance, False, network_info=network_info,
                           block_device_mapping=block_device_mapping)
         block_device_mapping = block_device_mapping or []
         self.firewall_driver.setup_basic_filtering(instance, network_info)
         self.firewall_driver.prepare_instance_filter(instance, network_info)
-        self._create_image(instance, xml, network_info=network_info,
+        self._create_image(context, instance, xml, network_info=network_info,
                            block_device_mapping=block_device_mapping)
         domain = self._create_new_domain(xml)
         LOG.debug(_("instance %s: is running"), instance['name'])
@@ -770,9 +769,10 @@ class LibvirtConnection(driver.ComputeDriver):
             else:
                 utils.execute('cp', base, target)
 
-    def _fetch_image(self, target, image_id, user_id, project_id, size=None):
+    def _fetch_image(self, context, target, image_id, user_id, project_id,
+                     size=None):
         """Grab image and optionally attempt to resize it"""
-        images.fetch(image_id, target, user_id, project_id)
+        images.fetch(context, image_id, target, user_id, project_id)
         if size:
             disk.extend(target, size)
 
@@ -781,8 +781,9 @@ class LibvirtConnection(driver.ComputeDriver):
         utils.execute('truncate', target, '-s', "%dG" % local_gb)
         # TODO(vish): should we format disk by default?
 
-    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None,
-                        network_info=None, block_device_mapping=None):
+    def _create_image(self, context, inst, libvirt_xml, suffix='',
+                      disk_images=None, network_info=None,
+                      block_device_mapping=None):
         block_device_mapping = block_device_mapping or []
 
         if not suffix:
@@ -818,6 +819,7 @@ class LibvirtConnection(driver.ComputeDriver):
         if disk_images['kernel_id']:
             fname = '%08x' % int(disk_images['kernel_id'])
             self._cache_image(fn=self._fetch_image,
+                              context=context,
                               target=basepath('kernel'),
                               fname=fname,
                               image_id=disk_images['kernel_id'],
@@ -826,6 +828,7 @@ class LibvirtConnection(driver.ComputeDriver):
             if disk_images['ramdisk_id']:
                 fname = '%08x' % int(disk_images['ramdisk_id'])
                 self._cache_image(fn=self._fetch_image,
+                                  context=context,
                                   target=basepath('ramdisk'),
                                   fname=fname,
                                   image_id=disk_images['ramdisk_id'],
@@ -844,6 +847,7 @@ class LibvirtConnection(driver.ComputeDriver):
         if not self._volume_in_mapping(self.root_mount_device,
                                        block_device_mapping):
             self._cache_image(fn=self._fetch_image,
+                              context=context,
                               target=basepath('disk'),
                               fname=root_fname,
                               cow=FLAGS.use_cow_images,
@@ -880,7 +884,7 @@ class LibvirtConnection(driver.ComputeDriver):
         ifc_template = open(FLAGS.injected_network_template).read()
         ifc_num = -1
         have_injected_networks = False
-        admin_context = context.get_admin_context()
+        admin_context = nova_context.get_admin_context()
         for (network_ref, mapping) in network_info:
             ifc_num += 1
 
diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
index ad354bc3a..07a6ba6ab 100644
--- a/nova/virt/vmwareapi/vmops.py
+++ b/nova/virt/vmwareapi/vmops.py
@@ -26,7 +26,7 @@ import urllib
 import urllib2

 import uuid

 

-from nova import context

+from nova import context as nova_context

 from nova import db

 from nova import exception

 from nova import flags

@@ -89,7 +89,7 @@ class VMWareVMOps(object):
         LOG.debug(_("Got total of %s instances") % str(len(lst_vm_names)))

         return lst_vm_names

 

-    def spawn(self, cxt, instance, network_info):

+    def spawn(self, context, instance, network_info):

         """

         Creates a VM instance.

 

@@ -111,7 +111,7 @@ class VMWareVMOps(object):
         client_factory = self._session._get_vim().client.factory

         service_content = self._session._get_vim().get_service_content()

 

-        network = db.network_get_by_instance(context.get_admin_context(),

+        network = db.network_get_by_instance(nova_context.get_admin_context(),

                                             instance['id'])

 

         net_name = network['bridge']

@@ -329,7 +329,7 @@ class VMWareVMOps(object):
             LOG.debug(_("Powered on the VM instance %s") % instance.name)

         _power_on_vm()

 

-    def snapshot(self, cxt, instance, snapshot_name):

+    def snapshot(self, context, instance, snapshot_name):

         """

         Create snapshot from a running VM instance.

         Steps followed are:

@@ -721,11 +721,11 @@ class VMWareVMOps(object):
         Set the machine id of the VM for guest tools to pick up and change

         the IP.

         """

-        admin_context = context.get_admin_context()

+        admin_context = nova_context.get_admin_context()

         vm_ref = self._get_vm_ref_from_the_name(instance.name)

         if vm_ref is None:

             raise exception.InstanceNotFound(instance_id=instance.id)

-        network = db.network_get_by_instance(context.get_admin_context(),

+        network = db.network_get_by_instance(nova_context.get_admin_context(),

                                             instance['id'])

         mac_address = None

         if instance['mac_addresses']:

diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py
index a26a02290..3d209fa99 100644
--- a/nova/virt/vmwareapi_conn.py
+++ b/nova/virt/vmwareapi_conn.py
@@ -124,14 +124,14 @@ class VMWareESXConnection(driver.ComputeDriver):
         """List VM instances."""

         return self._vmops.list_instances()

 

-    def spawn(self, cxt, instance, network_info,

+    def spawn(self, context, instance, network_info,

               block_device_mapping=None):

         """Create VM instance."""

-        self._vmops.spawn(cxt, instance, network_info)

+        self._vmops.spawn(context, instance, network_info)

 

-    def snapshot(self, cxt, instance, name):

+    def snapshot(self, context, instance, name):

         """Create snapshot from a running VM instance."""

-        self._vmops.snapshot(cxt, instance, name)

+        self._vmops.snapshot(context, instance, name)

 

     def reboot(self, instance, network_info):

         """Reboot VM instance."""

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index b696bdb02..6bbe6072c 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -342,7 +342,7 @@ class VMHelper(HelperBase):
         return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid)
 
     @classmethod
-    def upload_image(cls, ctx, session, instance, vdi_uuids, image_id):
+    def upload_image(cls, context, session, instance, vdi_uuids, image_id):
         """ Requests that the Glance plugin bundle the specified VDIs and
         push them into Glance using the specified human-friendly name.
         """
@@ -361,15 +361,15 @@ class VMHelper(HelperBase):
                   'glance_port': glance_port,
                   'sr_path': cls.get_sr_path(session),
                   'os_type': os_type,
-                  'auth_token': getattr(ctx, 'auth_token', None)}
+                  'auth_token': getattr(context, 'auth_token', None)}
 
         kwargs = {'params': pickle.dumps(params)}
         task = session.async_call_plugin('glance', 'upload_vhd', kwargs)
         session.wait_for_task(task, instance.id)
 
     @classmethod
-    def fetch_image(cls, ctx, session, instance_id, image, user_id, project_id,
-                    image_type):
+    def fetch_image(cls, context, session, instance_id, image, user_id,
+                    project_id, image_type):
         """
         image_type is interpreted as an ImageType instance
         Related flags:
@@ -382,7 +382,7 @@ class VMHelper(HelperBase):
         """
 
         if FLAGS.xenapi_image_service == 'glance':
-            return cls._fetch_image_glance(ctx, session, instance_id,
+            return cls._fetch_image_glance(context, session, instance_id,
                                            image, image_type)
         else:
             # TODO(vish): this shouldn't be used anywhere anymore and
@@ -396,7 +396,7 @@ class VMHelper(HelperBase):
                                                 image_type)
 
     @classmethod
-    def _fetch_image_glance_vhd(cls, ctx, session, instance_id, image,
+    def _fetch_image_glance_vhd(cls, context, session, instance_id, image,
                                 image_type):
         """Tell glance to download an image and put the VHDs into the SR
 
@@ -419,7 +419,7 @@ class VMHelper(HelperBase):
                   'glance_port': glance_port,
                   'uuid_stack': uuid_stack,
                   'sr_path': cls.get_sr_path(session),
-                  'auth_token': getattr(ctx, 'auth_token', None)}
+                  'auth_token': getattr(context, 'auth_token', None)}
 
         kwargs = {'params': pickle.dumps(params)}
         task = session.async_call_plugin('glance', 'download_vhd', kwargs)
@@ -445,7 +445,7 @@ class VMHelper(HelperBase):
         return vdis
 
     @classmethod
-    def _fetch_image_glance_disk(cls, ctx, session, instance_id, image,
+    def _fetch_image_glance_disk(cls, context, session, instance_id, image,
                                  image_type):
         """Fetch the image from Glance
 
@@ -465,7 +465,7 @@ class VMHelper(HelperBase):
         sr_ref = safe_find_sr(session)
 
         glance_client, image_id = nova.image.get_glance_client(image)
-        glance_client.set_auth_token(getattr(ctx, 'auth_token', None))
+        glance_client.set_auth_token(getattr(context, 'auth_token', None))
         meta, image_file = glance_client.get_image(image_id)
         virtual_size = int(meta['size'])
         vdi_size = virtual_size
@@ -580,7 +580,7 @@ class VMHelper(HelperBase):
         return image_type
 
     @classmethod
-    def _fetch_image_glance(cls, ctx, session, instance_id, image,
+    def _fetch_image_glance(cls, context, session, instance_id, image,
                             image_type):
         """Fetch image from glance based on image type.
 
@@ -588,10 +588,10 @@ class VMHelper(HelperBase):
                  A list of dictionaries that describe VDIs, otherwise
         """
         if image_type == ImageType.DISK_VHD:
-            return cls._fetch_image_glance_vhd(ctx,
+            return cls._fetch_image_glance_vhd(context,
                 session, instance_id, image, image_type)
         else:
-            return cls._fetch_image_glance_disk(ctx,
+            return cls._fetch_image_glance_disk(context,
                 session, instance_id, image, image_type)
 
     @classmethod
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index f6c86566b..b3b812a48 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -30,7 +30,7 @@ import sys
 import time
 import uuid
 
-from nova import context
+from nova import context as nova_context
 from nova import db
 from nova import exception
 from nova import flags
@@ -113,11 +113,11 @@ class VMOps(object):
         vm_ref = VMHelper.lookup(self._session, instance.name)
         self._start(instance, vm_ref)
 
-    def finish_migration(self, ctx, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                       resize_instance):
         vdi_uuid = self.link_disks(instance, disk_info['base_copy'],
                 disk_info['cow'])
-        vm_ref = self._create_vm(ctx, instance,
+        vm_ref = self._create_vm(context, instance,
                                  [dict(vdi_type='os', vdi_uuid=vdi_uuid)],
                                  network_info)
         if resize_instance:
@@ -134,19 +134,19 @@ class VMOps(object):
         LOG.debug(_("Starting instance %s"), instance.name)
         self._session.call_xenapi('VM.start', vm_ref, False, False)
 
-    def _create_disks(self, ctx, instance):
+    def _create_disks(self, context, instance):
         disk_image_type = VMHelper.determine_disk_image_type(instance)
-        vdis = VMHelper.fetch_image(ctx, self._session,
+        vdis = VMHelper.fetch_image(context, self._session,
                 instance.id, instance.image_ref,
                 instance.user_id, instance.project_id,
                 disk_image_type)
         return vdis
 
-    def spawn(self, ctx, instance, network_info):
+    def spawn(self, context, instance, network_info):
         vdis = None
         try:
-            vdis = self._create_disks(ctx, instance)
-            vm_ref = self._create_vm(ctx, instance, vdis, network_info)
+            vdis = self._create_disks(context, instance)
+            vm_ref = self._create_vm(context, instance, vdis, network_info)
             self._spawn(instance, vm_ref)
         except (self.XenAPI.Failure, OSError, IOError) as spawn_error:
             LOG.exception(_("instance %s: Failed to spawn"),
@@ -156,11 +156,11 @@ class VMOps(object):
             self._handle_spawn_error(vdis, spawn_error)
             raise spawn_error
 
-    def spawn_rescue(self, instance):
+    def spawn_rescue(self, context, instance, network_info):
         """Spawn a rescue instance."""
-        self.spawn(instance)
+        self.spawn(context, instance, network_info)
 
-    def _create_vm(self, ctx, instance, vdis, network_info):
+    def _create_vm(self, context, instance, vdis, network_info):
         """Create VM instance."""
         instance_name = instance.name
         vm_ref = VMHelper.lookup(self._session, instance_name)
@@ -171,7 +171,7 @@ class VMOps(object):
         if not VMHelper.ensure_free_mem(self._session, instance):
             LOG.exception(_('instance %(instance_name)s: not enough free '
                           'memory') % locals())
-            db.instance_set_state(context.get_admin_context(),
+            db.instance_set_state(nova_context.get_admin_context(),
                                   instance['id'],
                                   power_state.SHUTDOWN)
             return
@@ -181,12 +181,12 @@ class VMOps(object):
         ramdisk = None
         try:
             if instance.kernel_id:
-                kernel = VMHelper.fetch_image(ctx, self._session, instance.id,
-                        instance.kernel_id, instance.user_id,
+                kernel = VMHelper.fetch_image(context, self._session,
+                        instance.id, instance.kernel_id, instance.user_id,
                         instance.project_id, ImageType.KERNEL)[0]
             if instance.ramdisk_id:
-                ramdisk = VMHelper.fetch_image(ctx, self._session, instance.id,
-                        instance.kernel_id, instance.user_id,
+                ramdisk = VMHelper.fetch_image(context, self._session,
+                        instance.id, instance.kernel_id, instance.user_id,
                         instance.project_id, ImageType.RAMDISK)[0]
             # Create the VM ref and attach the first disk
             first_vdi_ref = self._session.call_xenapi('VDI.get_by_uuid',
@@ -206,7 +206,7 @@ class VMOps(object):
 
             if instance.vm_mode != vm_mode:
                 # Update database with normalized (or determined) value
-                db.instance_update(context.get_admin_context(),
+                db.instance_update(nova_context.get_admin_context(),
                                    instance['id'], {'vm_mode': vm_mode})
             vm_ref = VMHelper.create_vm(self._session, instance,
                     kernel and kernel.get('file', None) or None,
@@ -268,7 +268,7 @@ class VMOps(object):
         LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.')
                  % locals())
 
-        ctx = context.get_admin_context()
+        ctx = nova_context.get_admin_context()
         agent_build = db.agent_build_get_by_triple(ctx, 'xen',
                               instance.os_type, instance.architecture)
         if agent_build:
@@ -412,7 +412,7 @@ class VMOps(object):
 
         # if instance_or_vm is an int/long it must be instance id
         elif isinstance(instance_or_vm, (int, long)):
-            ctx = context.get_admin_context()
+            ctx = nova_context.get_admin_context()
             instance_obj = db.instance_get(ctx, instance_or_vm)
             instance_name = instance_obj.name
         else:
@@ -437,10 +437,10 @@ class VMOps(object):
             vm,
             "start")
 
-    def snapshot(self, ctx, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """Create snapshot from a running VM instance.
 
-        :param ctx: request context
+        :param context: request context
         :param instance: instance to be snapshotted
         :param image_id: id of image to upload to
 
@@ -465,7 +465,7 @@ class VMOps(object):
         try:
             template_vm_ref, template_vdi_uuids = self._get_snapshot(instance)
             # call plugin to ship snapshot off to glance
-            VMHelper.upload_image(ctx,
+            VMHelper.upload_image(context,
                     self._session, instance, template_vdi_uuids, image_id)
         finally:
             if template_vm_ref:
@@ -686,7 +686,7 @@ class VMOps(object):
         # Successful return code from password is '0'
         if resp_dict['returncode'] != '0':
             raise RuntimeError(resp_dict['message'])
-        db.instance_update(context.get_admin_context(),
+        db.instance_update(nova_context.get_admin_context(),
                                   instance['id'],
                                   dict(admin_pass=new_pass))
         return resp_dict['message']
@@ -914,7 +914,7 @@ class VMOps(object):
                                          True)
         self._wait_with_callback(instance.id, task, callback)
 
-    def rescue(self, instance, callback):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance.
 
             - shutdown the instance VM.
@@ -932,7 +932,7 @@ class VMOps(object):
         self._shutdown(instance, vm_ref)
         self._acquire_bootlock(vm_ref)
         instance._rescue = True
-        self.spawn_rescue(instance)
+        self.spawn_rescue(context, instance, network_info)
         rescue_vm_ref = VMHelper.lookup(self._session, instance.name)
 
         vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0]
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index 9315c2f4a..665b7eed6 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -187,24 +187,24 @@ class XenAPIConnection(driver.ComputeDriver):
     def list_instances_detail(self):
         return self._vmops.list_instances_detail()
 
-    def spawn(self, cxt, instance, network_info,
+    def spawn(self, context, instance, network_info,
               block_device_mapping=None):
         """Create VM instance"""
-        self._vmops.spawn(cxt, instance, network_info)
+        self._vmops.spawn(context, instance, network_info)
 
     def revert_migration(self, instance):
         """Reverts a resize, powering back on the instance"""
         self._vmops.revert_resize(instance)
 
-    def finish_migration(self, cxt, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                          resize_instance=False):
         """Completes a resize, turning on the migrated instance"""
-        self._vmops.finish_migration(cxt, instance, disk_info,
+        self._vmops.finish_migration(context, instance, disk_info,
                                      network_info, resize_instance)
 
-    def snapshot(self, cxt, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """ Create snapshot from a running VM instance """
-        self._vmops.snapshot(cxt, instance, image_id)
+        self._vmops.snapshot(context, instance, image_id)
 
     def reboot(self, instance, network_info):
         """Reboot VM instance"""
@@ -245,9 +245,9 @@ class XenAPIConnection(driver.ComputeDriver):
         """resume the specified instance"""
         self._vmops.resume(instance, callback)
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance"""
-        self._vmops.rescue(instance, callback)
+        self._vmops.rescue(instance, callback, network_info)
 
     def unrescue(self, instance, callback, network_info):
         """Unrescue the specified instance"""