Merge "Remove 'instance_update_at_top', 'instance_destroy_at_top'"

Author: Zuul

nova/cells/manager.py

@@ -175,10 +175,7 @@ def _sync_instance(self, ctxt, instance):
         """Broadcast an instance_update or instance_destroy message up to
         parent cells.
         """
-        if instance.deleted:
-            self.instance_destroy_at_top(ctxt, instance)
-        else:
-            self.instance_update_at_top(ctxt, instance)
+        pass
 
     def build_instances(self, ctxt, build_inst_kwargs):
         """Pick a cell (possibly ourselves) to build new instance(s) and
@@ -217,14 +214,6 @@ def run_compute_api_method(self, ctxt, cell_name, method_info, call):
         if call:
             return response.value_or_raise()
 
-    def instance_update_at_top(self, ctxt, instance):
-        """Update an instance at the top level cell."""
-        self.msg_runner.instance_update_at_top(ctxt, instance)
-
-    def instance_destroy_at_top(self, ctxt, instance):
-        """Destroy an instance at the top level cell."""
-        self.msg_runner.instance_destroy_at_top(ctxt, instance)
-
     def instance_delete_everywhere(self, ctxt, instance, delete_type):
         """This is used by API cell when it didn't know what cell
         an instance was in, but the instance was requested to be

nova/cells/messaging.py

@@ -34,7 +34,6 @@
 from oslo_log import log as logging
 import oslo_messaging as messaging
 from oslo_serialization import jsonutils
-from oslo_utils import excutils
 from oslo_utils import importutils
 from oslo_utils import timeutils
 from oslo_utils import uuidutils
@@ -57,7 +56,6 @@
 from nova import objects
 from nova.objects import base as objects_base
 from nova import rpc
-from nova import utils
 
 CONF = nova.conf.CONF
 
@@ -661,19 +659,10 @@ def run_compute_api_method(self, message, method_info):
         expected_attrs = ['metadata', 'system_metadata', 'security_groups',
                           'info_cache']
 
-        try:
-            instance = objects.Instance.get_by_uuid(message.ctxt,
-                    instance_uuid, expected_attrs=expected_attrs)
-            args[0] = instance
-        except exception.InstanceNotFound:
-            with excutils.save_and_reraise_exception():
-                # Must be a race condition.  Let's try to resolve it by
-                # telling the top level cells that this instance doesn't
-                # exist.
-                instance = objects.Instance(context=message.ctxt,
-                                            uuid=instance_uuid)
-                self.msg_runner.instance_destroy_at_top(message.ctxt,
-                                                        instance)
+        instance = objects.Instance.get_by_uuid(message.ctxt,
+                instance_uuid, expected_attrs=expected_attrs)
+        args[0] = instance
+
         return fn(message.ctxt, *args, **method_info['method_kwargs'])
 
     def update_capabilities(self, message, cell_name, capabilities):
@@ -771,18 +760,8 @@ def validate_console_port(self, message, instance_uuid, console_port,
         """Validate console port with child cell compute node."""
         # 1st arg is instance_uuid that we need to turn into the
         # instance object.
-        try:
-            instance = objects.Instance.get_by_uuid(message.ctxt,
-                                                    instance_uuid)
-        except exception.InstanceNotFound:
-            with excutils.save_and_reraise_exception():
-                # Must be a race condition.  Let's try to resolve it by
-                # telling the top level cells that this instance doesn't
-                # exist.
-                instance = objects.Instance(context=message.ctxt,
-                                            uuid=instance_uuid)
-                self.msg_runner.instance_destroy_at_top(message.ctxt,
-                                                        instance)
+        instance = objects.Instance.get_by_uuid(message.ctxt,
+                                                instance_uuid)
         return self.compute_rpcapi.validate_console_port(message.ctxt,
                 instance, console_port, console_type)
 
@@ -812,15 +791,6 @@ def _call_compute_api_with_obj(self, ctxt, instance, method, *args,
             # NOTE(comstud): We need to refresh the instance from this
             # cell's view in the DB.
             instance.refresh()
-        except exception.InstanceNotFound:
-            with excutils.save_and_reraise_exception():
-                # Must be a race condition.  Let's try to resolve it by
-                # telling the top level cells that this instance doesn't
-                # exist.
-                instance = objects.Instance(context=ctxt,
-                                            uuid=instance.uuid)
-                self.msg_runner.instance_destroy_at_top(ctxt,
-                                                        instance)
         except exception.InstanceInfoCacheNotFound:
             if method not in ('delete', 'force_delete'):
                 raise
@@ -1006,70 +976,6 @@ def _get_expected_task_state(self, instance):
         if instance.obj_attr_is_set('task_state'):
             return expected_task_state_map.get(instance.task_state)
 
-    def instance_update_at_top(self, message, instance, **kwargs):
-        """Update an instance in the DB if we're a top level cell."""
-        if not self._at_the_top():
-            return
-
-        # Remove things that we can't update in the top level cells.
-        # 'metadata' is only updated in the API cell, so don't overwrite
-        # it based on what child cells say.  Make sure to update
-        # 'cell_name' based on the routing path.
-        items_to_remove = ['id', 'security_groups', 'volumes', 'cell_name',
-                           'name', 'metadata']
-        instance.obj_reset_changes(items_to_remove)
-        instance.cell_name = _reverse_path(message.routing_path)
-
-        # instance.display_name could be unicode
-        instance_repr = utils.get_obj_repr_unicode(instance)
-        LOG.debug("Got update for instance: %(instance)s",
-                  {'instance': instance_repr}, instance_uuid=instance.uuid)
-
-        expected_vm_state = self._get_expected_vm_state(instance)
-        expected_task_state = self._get_expected_task_state(instance)
-
-        # It's possible due to some weird condition that the instance
-        # was already set as deleted... so we'll attempt to update
-        # it with permissions that allows us to read deleted.
-        with utils.temporary_mutation(message.ctxt, read_deleted="yes"):
-            try:
-                with instance.skip_cells_sync():
-                    instance.save(expected_vm_state=expected_vm_state,
-                                  expected_task_state=expected_task_state)
-            except exception.InstanceNotFound:
-                # FIXME(comstud): Strange.  Need to handle quotas here,
-                # if we actually want this code to remain..
-                instance.create()
-            except exception.NotFound:
-                # Can happen if we try to update a deleted instance's
-                # network information, for example.
-                pass
-
-    def instance_destroy_at_top(self, message, instance, **kwargs):
-        """Destroy an instance from the DB if we're a top level cell."""
-        if not self._at_the_top():
-            return
-        LOG.debug("Got update to delete instance",
-                  instance_uuid=instance.uuid)
-        try:
-            instance.destroy()
-        except exception.InstanceNotFound:
-            pass
-        except exception.ObjectActionError:
-            # NOTE(alaski): instance_destroy_at_top will sometimes be called
-            # when an instance does not exist in a cell but does in the parent.
-            # In that case instance.id is not set which causes instance.destroy
-            # to fail thinking that the object has already been destroyed.
-            # That's the right assumption for it to make because without cells
-            # that would be true.  But for cells we'll try to pull the actual
-            # instance and try to delete it again.
-            try:
-                instance = objects.Instance.get_by_uuid(message.ctxt,
-                        instance.uuid)
-                instance.destroy()
-            except exception.InstanceNotFound:
-                pass
-
     def instance_delete_everywhere(self, message, instance, delete_type,
                                    **kwargs):
         """Call compute API delete() or soft_delete() in every cell.
@@ -1091,10 +997,7 @@ def bw_usage_update_at_top(self, message, bw_update_info, **kwargs):
         self.db.bw_usage_update(message.ctxt, **bw_update_info)
 
     def _sync_instance(self, ctxt, instance):
-        if instance.deleted:
-            self.msg_runner.instance_destroy_at_top(ctxt, instance)
-        else:
-            self.msg_runner.instance_update_at_top(ctxt, instance)
+        pass
 
     def sync_instances(self, message, project_id, updated_since, deleted,
                        **kwargs):
@@ -1356,20 +1259,6 @@ def run_compute_api_method(self, ctxt, cell_name, method_info, call):
                                    cell_name, need_response=call)
         return message.process()
 
-    def instance_update_at_top(self, ctxt, instance):
-        """Update an instance at the top level cell."""
-        message = _BroadcastMessage(self, ctxt, 'instance_update_at_top',
-                                    dict(instance=instance), 'up',
-                                    run_locally=False)
-        message.process()
-
-    def instance_destroy_at_top(self, ctxt, instance):
-        """Destroy an instance at the top level cell."""
-        message = _BroadcastMessage(self, ctxt, 'instance_destroy_at_top',
-                                    dict(instance=instance), 'up',
-                                    run_locally=False)
-        message.process()
-
     def instance_delete_everywhere(self, ctxt, instance, delete_type):
         """This is used by API cell when it didn't know what cell
         an instance was in, but the instance was requested to be

nova/cells/rpcapi.py

@@ -201,24 +201,6 @@ def build_instances(self, ctxt, **kwargs):
         cctxt.cast(ctxt, 'build_instances',
                    build_inst_kwargs=build_inst_kwargs)
 
-    def instance_update_at_top(self, ctxt, instance):
-        """Update instance at API level."""
-        version = '1.35'
-        if not self.client.can_send_version('1.35'):
-            instance = objects_base.obj_to_primitive(instance)
-            version = '1.34'
-        cctxt = self.client.prepare(version=version)
-        cctxt.cast(ctxt, 'instance_update_at_top', instance=instance)
-
-    def instance_destroy_at_top(self, ctxt, instance):
-        """Destroy instance at API level."""
-        version = '1.35'
-        if not self.client.can_send_version('1.35'):
-            instance = objects_base.obj_to_primitive(instance)
-            version = '1.34'
-        cctxt = self.client.prepare(version=version)
-        cctxt.cast(ctxt, 'instance_destroy_at_top', instance=instance)
-
     def instance_delete_everywhere(self, ctxt, instance, delete_type):
         """Delete instance everywhere.  delete_type may be 'soft'
         or 'hard'.  This is generally only used to resolve races

nova/cells/scheduler.py

@@ -112,7 +112,6 @@ def _create_instances_here(self, ctxt, instance_uuids, instance_properties,
             self.compute_api._create_block_device_mapping(block_device_mapping)
 
             instances.append(instance)
-            self.msg_runner.instance_update_at_top(ctxt, instance)
         return instances
 
     def _create_action_here(self, ctxt, instance_uuids):
@@ -238,7 +237,6 @@ def _schedule_build_to_cells(self, message, instance_uuids,
             for instance_uuid in instance_uuids:
                 instance = objects.Instance(context=ctxt, uuid=instance_uuid,
                                             vm_state=vm_states.ERROR)
-                self.msg_runner.instance_update_at_top(ctxt, instance)
                 try:
                     instance.vm_state = vm_states.ERROR
                     instance.save()

nova/compute/cells_api.py

@@ -271,22 +271,11 @@ def _handle_cell_delete(self, context, instance, method_name):
                 # that an update came up from a child cell and cell_name is
                 # set now.  If so try the delete again.
                 with excutils.save_and_reraise_exception() as exc:
-                    try:
-                        instance.refresh()
-                    except exception.InstanceNotFound:
-                        # NOTE(melwitt): If the instance has already been
-                        # deleted by instance_destroy_at_top from a cell,
-                        # instance.refresh() will raise InstanceNotFound.
+                    instance.refresh()
+                    if instance.cell_name:
                         exc.reraise = False
-                    else:
-                        if instance.cell_name:
-                            exc.reraise = False
-                            self._handle_cell_delete(context, instance,
-                                    method_name)
-            except exception.InstanceNotFound:
-                # NOTE(melwitt): We can get here if anything tries to
-                # lookup the instance after an instance_destroy_at_top hits.
-                pass
+                        self._handle_cell_delete(context, instance,
+                                method_name)
             return
 
         method = getattr(super(ComputeCellsAPI, self), method_name)

nova/objects/instance.py

@@ -622,10 +622,6 @@ def destroy(self, hard_delete=False):
         else:
             constraint = None
 
-        cell_type = cells_opts.get_cell_type()
-        if cell_type is not None:
-            stale_instance = self.obj_clone()
-
         try:
             db_inst = db.instance_destroy(self._context, self.uuid,
                                           constraint=constraint,
@@ -634,9 +630,6 @@ def destroy(self, hard_delete=False):
         except exception.ConstraintNotMet:
             raise exception.ObjectActionError(action='destroy',
                                               reason='host changed')
-        if cell_type == 'compute':
-            cells_api = cells_rpcapi.CellsAPI()
-            cells_api.instance_destroy_at_top(self._context, stale_instance)
         delattr(self, base.get_attrname('id'))
 
     def _save_info_cache(self, context):
@@ -848,10 +841,6 @@ def _handle_cell_update_from_api():
 
         if cells_update_from_api:
             _handle_cell_update_from_api()
-        elif cell_type == 'compute':
-            if self._sync_cells:
-                cells_api = cells_rpcapi.CellsAPI()
-                cells_api.instance_update_at_top(context, stale_instance)
 
         def _notify():
             # NOTE(danms): We have to be super careful here not to trigger

nova/tests/unit/cells/test_cells_manager.py

@@ -162,20 +162,6 @@ def test_run_compute_api_method(self):
                 call=True)
         self.assertEqual('fake-response', response)
 
-    def test_instance_update_at_top(self):
-        self.mox.StubOutWithMock(self.msg_runner, 'instance_update_at_top')
-        self.msg_runner.instance_update_at_top(self.ctxt, 'fake-instance')
-        self.mox.ReplayAll()
-        self.cells_manager.instance_update_at_top(self.ctxt,
-                                                  instance='fake-instance')
-
-    def test_instance_destroy_at_top(self):
-        self.mox.StubOutWithMock(self.msg_runner, 'instance_destroy_at_top')
-        self.msg_runner.instance_destroy_at_top(self.ctxt, 'fake-instance')
-        self.mox.ReplayAll()
-        self.cells_manager.instance_destroy_at_top(self.ctxt,
-                                                  instance='fake-instance')
-
     def test_instance_delete_everywhere(self):
         self.mox.StubOutWithMock(self.msg_runner,
                                  'instance_delete_everywhere')