Removing the xenapi_image_service flag in favor of image_service.

3 files changed, 15 insertions, 168 deletions

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index d4bca1281..6b7d5df76 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -432,7 +432,6 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertTrue(instance.architecture)
 
     def test_spawn_not_enough_memory(self):
-        FLAGS.xenapi_image_service = 'glance'
         self.assertRaises(Exception,
                           self._test_spawn,
                           1, 2, 3, "4")  # m1.xlarge
@@ -444,7 +443,6 @@ class XenAPIVMTestCase(test.TestCase):
 
         """
         vdi_recs_start = self._list_vdis()
-        FLAGS.xenapi_image_service = 'glance'
         stubs.stubout_fetch_image_glance_disk(self.stubs)
         self.assertRaises(xenapi_fake.Failure,
                           self._test_spawn, 1, 2, 3)
@@ -459,7 +457,6 @@ class XenAPIVMTestCase(test.TestCase):
 
         """
         vdi_recs_start = self._list_vdis()
-        FLAGS.xenapi_image_service = 'glance'
         stubs.stubout_create_vm(self.stubs)
         self.assertRaises(xenapi_fake.Failure,
                           self._test_spawn, 1, 2, 3)
@@ -467,40 +464,12 @@ class XenAPIVMTestCase(test.TestCase):
         vdi_recs_end = self._list_vdis()
         self._check_vdis(vdi_recs_start, vdi_recs_end)
 
-    def test_spawn_raw_objectstore(self):
-        # TODO(vish): deprecated
-        from nova.auth import manager
-        authman = manager.AuthManager()
-        authman.create_user('fake', 'fake')
-        authman.create_project('fake', 'fake')
-        try:
-            FLAGS.xenapi_image_service = 'objectstore'
-            self._test_spawn(1, None, None)
-        finally:
-            authman.delete_project('fake')
-            authman.delete_user('fake')
-
-    def test_spawn_objectstore(self):
-        # TODO(vish): deprecated
-        from nova.auth import manager
-        authman = manager.AuthManager()
-        authman.create_user('fake', 'fake')
-        authman.create_project('fake', 'fake')
-        try:
-            FLAGS.xenapi_image_service = 'objectstore'
-            self._test_spawn(1, 2, 3)
-        finally:
-            authman.delete_project('fake')
-            authman.delete_user('fake')
-
     @stub_vm_utils_with_vdi_attached_here
     def test_spawn_raw_glance(self):
-        FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_RAW, None, None)
         self.check_vm_params_for_linux()
 
     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", architecture="x86-64")
         self.check_vm_params_for_linux()
@@ -529,20 +498,17 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertEqual(len(self.vm['VBDs']), 1)
 
     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", architecture="i386")
         self.check_vm_params_for_windows()
 
     def test_spawn_glance(self):
-        FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK)
         self.check_vm_params_for_linux_with_external_kernel()
 
     def test_spawn_netinject_file(self):
-        FLAGS.xenapi_image_service = 'glance'
         db_fakes.stub_out_db_instance_api(self.stubs, injected=True)
 
         self._tee_executed = False
@@ -568,7 +534,6 @@ class XenAPIVMTestCase(test.TestCase):
             # Capture the sudo tee .../etc/network/interfaces command
             (r'(sudo\s+)?tee.*interfaces', _tee_handler),
         ])
-        FLAGS.xenapi_image_service = 'glance'
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK,
@@ -576,7 +541,6 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertTrue(self._tee_executed)
 
     def test_spawn_netinject_xenstore(self):
-        FLAGS.xenapi_image_service = 'glance'
         db_fakes.stub_out_db_instance_api(self.stubs, injected=True)
 
         self._tee_executed = False
@@ -621,7 +585,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.assertFalse(self._tee_executed)
 
     def test_spawn_vlanmanager(self):
-        self.flags(xenapi_image_service='glance',
+        self.flags(image_service='nova.image.glance.GlanceImageService',
                    network_manager='nova.network.manager.VlanManager',
                    vlan_interface='fake0')
 
@@ -915,7 +879,6 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
 
     def test_instance_disk(self):
         """If a kernel is specified, the image type is DISK (aka machine)."""
-        FLAGS.xenapi_image_service = 'objectstore'
         self.fake_instance.image_ref = glance_stubs.FakeGlance.IMAGE_MACHINE
         self.fake_instance.kernel_id = glance_stubs.FakeGlance.IMAGE_KERNEL
         self.assert_disk_type(vm_utils.ImageType.DISK)
@@ -925,7 +888,6 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         If the kernel isn't specified, and we're not using Glance, then
         DISK_RAW is assumed.
         """
-        FLAGS.xenapi_image_service = 'objectstore'
         self.fake_instance.image_ref = glance_stubs.FakeGlance.IMAGE_RAW
         self.fake_instance.kernel_id = None
         self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
@@ -935,7 +897,6 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         If we're using Glance, then defer to the image_type field, which in
         this case will be 'raw'.
         """
-        FLAGS.xenapi_image_service = 'glance'
         self.fake_instance.image_ref = glance_stubs.FakeGlance.IMAGE_RAW
         self.fake_instance.kernel_id = None
         self.assert_disk_type(vm_utils.ImageType.DISK_RAW)
@@ -945,7 +906,6 @@ class XenAPIDetermineDiskImageTestCase(test.TestCase):
         If we're using Glance, then defer to the image_type field, which in
         this case will be 'vhd'.
         """
-        FLAGS.xenapi_image_service = 'glance'
         self.fake_instance.image_ref = glance_stubs.FakeGlance.IMAGE_VHD
         self.fake_instance.kernel_id = None
         self.assert_disk_type(vm_utils.ImageType.DISK_VHD)
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index c9bcb801c..60ef0df43 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -369,30 +369,17 @@ class VMHelper(HelperBase):
     @classmethod
     def fetch_image(cls, session, instance_id, image, user_id, project_id,
                     image_type):
-        """
-        image_type is interpreted as an ImageType instance
-        Related flags:
-            xenapi_image_service = ['glance', 'objectstore']
-            glance_address = 'address for glance services'
-            glance_port = 'port for glance services'
+        """Fetch image from glance based on image type.
 
-        Returns: A single filename if image_type is KERNEL_RAMDISK
+        Returns: A single filename if image_type is KERNEL or RAMDISK
                  A list of dictionaries that describe VDIs, otherwise
         """
-
-        if FLAGS.xenapi_image_service == 'glance':
-            return cls._fetch_image_glance(session, instance_id,
-                                           image, image_type)
+        if image_type == ImageType.DISK_VHD:
+            return cls._fetch_image_glance_vhd(
+                session, instance_id, image, image_type)
         else:
-            # TODO(vish): this shouldn't be used anywhere anymore and
-            #             can probably be removed
-            from nova.auth.manager import AuthManager
-            manager = AuthManager()
-            access = manager.get_access_key(user_id, project_id)
-            secret = manager.get_user(user_id).secret
-            return cls._fetch_image_objectstore(session, instance_id, image,
-                                                access, secret,
-                                                image_type)
+            return cls._fetch_image_glance_disk(
+                session, instance_id, image, image_type)
 
     @classmethod
     def _fetch_image_glance_vhd(cls, session, instance_id, image,
@@ -566,135 +553,38 @@ class VMHelper(HelperBase):
             else:
                 return ImageType.DISK_RAW
 
-        # FIXME(sirp): can we unify the ImageService and xenapi_image_service
-        # abstractions?
-        if FLAGS.xenapi_image_service == 'glance':
-            image_type = determine_from_glance()
-        else:
-            image_type = determine_from_instance()
+        image_type = determine_from_glance()
 
         log_disk_format(image_type)
         return image_type
 
     @classmethod
-    def _fetch_image_glance(cls, session, instance_id, image, image_type):
-        """Fetch image from glance based on image type.
-
-        Returns: A single filename if image_type is KERNEL or RAMDISK
-                 A list of dictionaries that describe VDIs, otherwise
-        """
-        if image_type == ImageType.DISK_VHD:
-            return cls._fetch_image_glance_vhd(
-                session, instance_id, image, image_type)
-        else:
-            return cls._fetch_image_glance_disk(
-                session, instance_id, image, image_type)
-
-    @classmethod
-    def _fetch_image_objectstore(cls, session, instance_id, image, access,
-                                 secret, image_type):
-        """Fetch an image from objectstore.
-
-        Returns: A single filename if image_type is KERNEL or RAMDISK
-                 A list of dictionaries that describe VDIs, otherwise
-        """
-        url = "http://%s:%s/_images/%s/image" % (FLAGS.s3_host, FLAGS.s3_port,
-                                                 image)
-        LOG.debug(_("Asking xapi to fetch %(url)s as %(access)s") % locals())
-        if image_type in (ImageType.KERNEL, ImageType.RAMDISK):
-            fn = 'get_kernel'
-        else:
-            fn = 'get_vdi'
-        args = {}
-        args['src_url'] = url
-        args['username'] = access
-        args['password'] = secret
-        args['add_partition'] = 'false'
-        args['raw'] = 'false'
-        if not image_type in (ImageType.KERNEL, ImageType.RAMDISK):
-            args['add_partition'] = 'true'
-            if image_type == ImageType.DISK_RAW:
-                args['raw'] = 'true'
-        task = session.async_call_plugin('objectstore', fn, args)
-        vdi_uuid = None
-        filename = None
-        if image_type in (ImageType.KERNEL, ImageType.RAMDISK):
-            filename = session.wait_for_task(task, instance_id)
-        else:
-            vdi_uuid = session.wait_for_task(task, instance_id)
-        return [dict(vdi_type=ImageType.to_string(image_type),
-                     vdi_uuid=vdi_uuid,
-                     file=filename)]
-
-    @classmethod
     def determine_is_pv(cls, session, instance_id, vdi_ref, disk_image_type,
                         os_type):
         """
         Determine whether the VM will use a paravirtualized kernel or if it
         will use hardware virtualization.
 
-            1. Objectstore (any image type):
-               We use plugin to figure out whether the VDI uses PV
-
-            2. Glance (VHD): then we use `os_type`, raise if not set
-
-            3. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is
-               available
-
-            4. Glance (DISK): pv is assumed
-        """
-        if FLAGS.xenapi_image_service == 'glance':
-            # 2, 3, 4: Glance
-            return cls._determine_is_pv_glance(
-              session, vdi_ref, disk_image_type, os_type)
-        else:
-            # 1. Objecstore
-            return cls._determine_is_pv_objectstore(session, instance_id,
-                                                    vdi_ref)
-
-    @classmethod
-    def _determine_is_pv_objectstore(cls, session, instance_id, vdi_ref):
-        LOG.debug(_("Looking up vdi %s for PV kernel"), vdi_ref)
-        fn = "is_vdi_pv"
-        args = {}
-        args['vdi-ref'] = vdi_ref
-        task = session.async_call_plugin('objectstore', fn, args)
-        pv_str = session.wait_for_task(task, instance_id)
-        pv = None
-        if pv_str.lower() == 'true':
-            pv = True
-        elif pv_str.lower() == 'false':
-            pv = False
-        LOG.debug(_("PV Kernel in VDI:%s"), pv)
-        return pv
-
-    @classmethod
-    def _determine_is_pv_glance(cls, session, vdi_ref, disk_image_type,
-                                os_type):
-        """
-        For a Glance image, determine if we need paravirtualization.
-
-        The relevant scenarios are:
-            2. Glance (VHD): then we use `os_type`, raise if not set
+            1. Glance (VHD): then we use `os_type`, raise if not set
 
-            3. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is
+            2. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is
                available
 
-            4. Glance (DISK): pv is assumed
+            3. Glance (DISK): pv is assumed
         """
 
         LOG.debug(_("Looking up vdi %s for PV kernel"), vdi_ref)
         if disk_image_type == ImageType.DISK_VHD:
-            # 2. VHD
+            # 1. VHD
             if os_type == 'windows':
                 is_pv = False
             else:
                 is_pv = True
         elif disk_image_type == ImageType.DISK_RAW:
-            # 3. RAW
+            # 2. RAW
             is_pv = with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv)
         elif disk_image_type == ImageType.DISK:
-            # 4. Disk
+            # 3. Disk
             is_pv = True
         else:
             raise exception.Error(_("Unknown image format %(disk_image_type)s")
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index cc18ed83c..a3d0abf9f 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -101,9 +101,6 @@ flags.DEFINE_float('xenapi_task_poll_interval',
                    'The interval used for polling of remote tasks '
                    '(Async.VM.start, etc). Used only if '
                    'connection_type=xenapi.')
-flags.DEFINE_string('xenapi_image_service',
-                    'glance',
-                    'Where to get VM images: glance or objectstore.')
 flags.DEFINE_float('xenapi_vhd_coalesce_poll_interval',
                    5.0,
                    'The interval used for polling of coalescing vhds.'