Merge "Remove 'get_keypair_at_top'"

Author: Zuul

nova/api/metadata/base.py

@@ -30,8 +30,6 @@
 from nova.api.metadata import vendordata_dynamic
 from nova.api.metadata import vendordata_json
 from nova import block_device
-from nova.cells import opts as cells_opts
-from nova.cells import rpcapi as cells_rpcapi
 import nova.conf
 from nova import context
 from nova import exception
@@ -327,23 +325,12 @@ def _metadata_as_json(self, version, path):
             metadata['network_config'] = self.network_config
 
         if self.instance.key_name:
-            if cells_opts.get_cell_type() == 'compute':
-                cells_api = cells_rpcapi.CellsAPI()
-                try:
-                    keypair = cells_api.get_keypair_at_top(
-                      context.get_admin_context(), self.instance.user_id,
-                      self.instance.key_name)
-                except exception.KeypairNotFound:
-                    # NOTE(lpigueir): If keypair was deleted, treat
-                    # it like it never had any
-                    keypair = None
-            else:
-                keypairs = self.instance.keypairs
-                # NOTE(mriedem): It's possible for the keypair to be deleted
-                # before it was migrated to the instance_extra table, in which
-                # case lazy-loading instance.keypairs will handle the 404 and
-                # just set an empty KeyPairList object on the instance.
-                keypair = keypairs[0] if keypairs else None
+            keypairs = self.instance.keypairs
+            # NOTE(mriedem): It's possible for the keypair to be deleted
+            # before it was migrated to the instance_extra table, in which
+            # case lazy-loading instance.keypairs will handle the 404 and
+            # just set an empty KeyPairList object on the instance.
+            keypair = keypairs[0] if keypairs else None
 
             if keypair:
                 metadata['public_keys'] = {

nova/cells/manager.py

@@ -550,19 +550,3 @@ def rebuild_instance(self, ctxt, instance, image_href, admin_password,
 
     def set_admin_password(self, ctxt, instance, new_pass):
         self.msg_runner.set_admin_password(ctxt, instance, new_pass)
-
-    def get_keypair_at_top(self, ctxt, user_id, name):
-        responses = self.msg_runner.get_keypair_at_top(ctxt, user_id, name)
-        keypairs = [resp.value for resp in responses if resp.value is not None]
-
-        if len(keypairs) == 0:
-            return None
-        elif len(keypairs) > 1:
-            cell_names = ', '.join([resp.cell_name for resp in responses
-                                    if resp.value is not None])
-            LOG.warning("The same keypair name '%(name)s' exists in the "
-                        "following cells: %(cell_names)s. The keypair "
-                        "value from the first cell is returned.",
-                        {'name': name, 'cell_names': cell_names})
-
-        return keypairs[0]

nova/cells/messaging.py

@@ -1146,18 +1146,6 @@ def consoleauth_delete_tokens(self, message, instance_uuid):
     def get_migrations(self, message, filters):
         return self.compute_api.get_migrations(message.ctxt, filters)
 
-    def get_keypair_at_top(self, message, user_id, name):
-        """Get keypair in API cells by name. Just return None if there is
-        no match keypair.
-        """
-        if not self._at_the_top():
-            return
-
-        try:
-            return objects.KeyPair.get_by_name(message.ctxt, user_id, name)
-        except exception.KeypairNotFound:
-            pass
-
 
 _CELL_MESSAGE_TYPE_TO_MESSAGE_CLS = {'targeted': _TargetedMessage,
                                      'broadcast': _BroadcastMessage,
@@ -1724,15 +1712,6 @@ def set_admin_password(self, ctxt, instance, new_pass):
         self._instance_action(ctxt, instance, 'set_admin_password',
                 extra_kwargs={'new_pass': new_pass})
 
-    def get_keypair_at_top(self, ctxt, user_id, name):
-        """Get Key Pair by name at top level cell."""
-        message = _BroadcastMessage(self, ctxt,
-                                    'get_keypair_at_top',
-                                    dict(user_id=user_id, name=name),
-                                    'up',
-                                    need_response=True, run_locally=False)
-        return message.process()
-
     @staticmethod
     def get_message_types():
         return _CELL_MESSAGE_TYPE_TO_MESSAGE_CLS.keys()

nova/cells/rpcapi.py

@@ -611,15 +611,3 @@ def set_admin_password(self, ctxt, instance, new_pass):
         cctxt = self.client.prepare(version='1.29')
         cctxt.cast(ctxt, 'set_admin_password', instance=instance,
                 new_pass=new_pass)
-
-    def get_keypair_at_top(self, ctxt, user_id, name):
-        if not CONF.cells.enable:
-            return
-
-        cctxt = self.client.prepare(version='1.37')
-        keypair = cctxt.call(ctxt, 'get_keypair_at_top', user_id=user_id,
-                             name=name)
-        if keypair is None:
-            raise exception.KeypairNotFound(user_id=user_id,
-                                            name=name)
-        return keypair

nova/tests/unit/cells/test_cells_manager.py

@@ -848,27 +848,3 @@ def test_set_admin_password(self):
                     instance='fake-instance', new_pass='fake-password')
             set_admin_password.assert_called_once_with(self.ctxt,
                     'fake-instance', 'fake-password')
-
-    def test_get_keypair_at_top(self):
-        keypairs = [self._get_fake_response('fake_keypair'),
-                    self._get_fake_response('fake_keypair2')]
-        with mock.patch.object(self.msg_runner,
-                               'get_keypair_at_top',
-                               return_value=keypairs) as fake_get_keypair:
-            response = self.cells_manager.get_keypair_at_top(self.ctxt,
-                                                             'fake_user_id',
-                                                             'fake_name')
-            fake_get_keypair.assert_called_once_with(self.ctxt, 'fake_user_id',
-                                                     'fake_name')
-            self.assertEqual('fake_keypair', response)
-
-    def test_get_keypair_at_top_with_empty_responses(self):
-        with mock.patch.object(self.msg_runner,
-                               'get_keypair_at_top',
-                               return_value=[]) as fake_get_keypair:
-            self.assertIsNone(
-                self.cells_manager.get_keypair_at_top(self.ctxt,
-                                                      'fake_user_id',
-                                                      'fake_name'))
-            fake_get_keypair.assert_called_once_with(self.ctxt, 'fake_user_id',
-                                                     'fake_name')

nova/tests/unit/cells/test_cells_messaging.py

@@ -1896,48 +1896,6 @@ def test_get_migrations(self):
             self.assertIn(response.value_or_raise(), [migrations_from_cell1,
                                                       migrations_from_cell2])
 
-    @mock.patch.object(objects.KeyPair, 'get_by_name',
-                       return_value='fake_keypair')
-    def test_get_keypair_at_top(self, fake_get_by_name):
-        user_id = 'fake_user_id'
-        name = 'fake_keypair_name'
-        responses = self.src_msg_runner.get_keypair_at_top(self.ctxt,
-                                                           user_id, name)
-        fake_get_by_name.assert_called_once_with(self.ctxt, user_id, name)
-
-        for response in responses:
-            if response.value is not None:
-                self.assertEqual('fake_keypair', response.value)
-
-    @mock.patch.object(objects.KeyPair, 'get_by_name')
-    def test_get_keypair_at_top_with_objects_exception(self, fake_get_by_name):
-        user_id = 'fake_user_id'
-        name = 'fake_keypair_name'
-        keypair_exception = exception.KeypairNotFound(user_id=user_id,
-                                                      name=name)
-        fake_get_by_name.side_effect = keypair_exception
-        responses = self.src_msg_runner.get_keypair_at_top(self.ctxt,
-                                                           user_id,
-                                                           name)
-        fake_get_by_name.assert_called_once_with(self.ctxt, user_id, name)
-
-        for response in responses:
-            self.assertIsNone(response.value)
-
-    @mock.patch.object(messaging._BroadcastMessage, 'process')
-    def test_get_keypair_at_top_with_process_response(self, fake_process):
-        user_id = 'fake_user_id'
-        name = 'fake_keypair_name'
-        response = messaging.Response(self.ctxt, 'cell', 'keypair', False)
-        other_response = messaging.Response(self.ctxt, 'cell',
-                                            'fake_other_keypair', False)
-        fake_process.return_value = [response, other_response]
-
-        responses = self.src_msg_runner.get_keypair_at_top(self.ctxt,
-                                                           user_id, name)
-        fake_process.assert_called_once_with()
-        self.assertEqual(fake_process.return_value, responses)
-
 
 class CellsPublicInterfacesTestCase(test.NoDBTestCase):
     """Test case for the public interfaces into cells messaging."""

nova/tests/unit/cells/test_cells_rpcapi.py

@@ -805,25 +805,3 @@ def test_set_admin_password(self):
                          'new_pass': 'fake-password'}
         self._check_result(call_info, 'set_admin_password',
                 expected_args, version='1.29')
-
-    def test_get_keypair_at_top(self):
-        call_info = self._stub_rpc_method('call', 'fake_response')
-        result = self.cells_rpcapi.get_keypair_at_top(self.fake_context,
-                                              'fake_user_id', 'fake_name')
-
-        expected_args = {'user_id': 'fake_user_id',
-                         'name': 'fake_name'}
-        self._check_result(call_info, 'get_keypair_at_top',
-                           expected_args, version='1.37')
-        self.assertEqual(result, 'fake_response')
-
-    def test_get_keypair_at_top_with_not_found(self):
-        call_info = self._stub_rpc_method('call', None)
-        self.assertRaises(exception.KeypairNotFound,
-                          self.cells_rpcapi.get_keypair_at_top,
-                          self.fake_context, 'fake_user_id', 'fake_name')
-
-        expected_args = {'user_id': 'fake_user_id',
-                         'name': 'fake_name'}
-        self._check_result(call_info, 'get_keypair_at_top',
-                           expected_args, version='1.37')

nova/tests/unit/test_metadata.py

@@ -558,15 +558,10 @@ def test_local_ipv4_from_address(self):
 
     @mock.patch('oslo_serialization.base64.encode_as_text',
                 return_value=FAKE_SEED)
-    @mock.patch('nova.cells.rpcapi.CellsAPI.get_keypair_at_top')
     @mock.patch.object(jsonutils, 'dump_as_bytes')
     def _test_as_json_with_options(self, mock_json_dump_as_bytes,
-                          mock_cells_keypair, mock_base64,
-                          is_cells=False, os_version=base.GRIZZLY):
-        if is_cells:
-            self.flags(enable=True, group='cells')
-            self.flags(cell_type='compute', group='cells')
-
+                          mock_base64,
+                          os_version=base.GRIZZLY):
         instance = self.instance
         keypair = self.keypair
         md = fake_InstanceMetadata(self, instance)
@@ -604,45 +599,14 @@ def _test_as_json_with_options(self, mock_json_dump_as_bytes,
             expose_trusted = md._check_os_version(base.ROCKY, os_version)
             expected_metadata['devices'] = fake_metadata_dicts(
                 True, expose_trusted)
-        mock_cells_keypair.return_value = keypair
         md._metadata_as_json(os_version, 'non useless path parameter')
-        if instance.key_name:
-            if is_cells:
-                mock_cells_keypair.assert_called_once_with(mock.ANY,
-                                                           instance.user_id,
-                                                           instance.key_name)
-                self.assertIsInstance(mock_cells_keypair.call_args[0][0],
-                                      context.RequestContext)
         self.assertEqual(md.md_mimetype, base.MIME_TYPE_APPLICATION_JSON)
         mock_json_dump_as_bytes.assert_called_once_with(expected_metadata)
 
     def test_as_json(self):
         for os_version in base.OPENSTACK_VERSIONS:
             self._test_as_json_with_options(os_version=os_version)
 
-    def test_as_json_with_cells_mode(self):
-        for os_version in base.OPENSTACK_VERSIONS:
-            self._test_as_json_with_options(is_cells=True,
-                                            os_version=os_version)
-
-    @mock.patch('nova.cells.rpcapi.CellsAPI.get_keypair_at_top',
-                side_effect=exception.KeypairNotFound(
-                name='key', user_id='fake_user'))
-    @mock.patch.object(objects.Instance, 'get_by_uuid')
-    def test_as_json_deleted_keypair_in_cells_mode(self,
-                                                   mock_get_keypair_at_top,
-                                                   mock_inst_get_by_uuid):
-        self.flags(enable=True, group='cells')
-        self.flags(cell_type='compute', group='cells')
-
-        instance = self.instance.obj_clone()
-        delattr(instance, 'keypairs')
-        md = fake_InstanceMetadata(self, instance)
-        meta = md._metadata_as_json(base.OPENSTACK_VERSIONS[-1], path=None)
-        meta = jsonutils.loads(meta)
-        self.assertNotIn('keys', meta)
-        self.assertNotIn('public_keys', meta)
-
     @mock.patch.object(objects.Instance, 'get_by_uuid')
     def test_metadata_as_json_deleted_keypair(self, mock_inst_get_by_uuid):
         """Tests that we handle missing instance keypairs.