def test_legacy_mapping_from_object_list(self):
     bdm1 = objects.BlockDeviceMapping()
     bdm1 = objects.BlockDeviceMapping._from_db_object(
         None, bdm1, fake_block_device.FakeDbBlockDeviceDict(
             self.new_mapping[0]))
     bdm2 = objects.BlockDeviceMapping()
     bdm2 = objects.BlockDeviceMapping._from_db_object(
         None, bdm2, fake_block_device.FakeDbBlockDeviceDict(
             self.new_mapping[1]))
     bdmlist = objects.BlockDeviceMappingList()
     bdmlist.objects = [bdm1, bdm2]
     block_device.legacy_mapping(bdmlist)

 def block_device_mapping_get_all_by_instance(self, context, instance,
                                              legacy=True):
     bdms = db.block_device_mapping_get_all_by_instance(context,
                                                        instance['uuid'])
     if legacy:
         bdms = block_device.legacy_mapping(bdms)
     return bdms

 def block_device_mapping_get_all_by_instance(self, context, instance,
                                              legacy):
     bdms = self.db.block_device_mapping_get_all_by_instance(
         context, instance['uuid'])
     if legacy:
         bdms = block_device.legacy_mapping(bdms)
     return jsonutils.to_primitive(bdms)

    def rebuild_instance(self, ctxt, instance, new_pass, injected_files,
            image_ref, orig_image_ref, orig_sys_metadata, bdms,
            recreate=False, on_shared_storage=False, host=None,
            preserve_ephemeral=False, kwargs=None):
        # NOTE(danms): kwargs is only here for cells compatibility, don't
        # actually send it to compute
        extra = {'preserve_ephemeral': preserve_ephemeral}
        if self.client.can_send_version('3.21'):
            version = '3.21'
        else:
            bdms = block_device.legacy_mapping(bdms)
            bdms = jsonutils.to_primitive(objects_base.obj_to_primitive(bdms))
            if self.client.can_send_version('3.5'):
                version = '3.5'
            elif self.client.can_send_version('3.4'):
                version = '3.4'
                extra = {}
            else:
                # NOTE(russellb) Havana compat
                version = self._get_compat_version('3.0', '2.22')
                instance = jsonutils.to_primitive(instance)
                extra = {}

        cctxt = self.client.prepare(server=_compute_host(host, instance),
                version=version)
        cctxt.cast(ctxt, 'rebuild_instance',
                   instance=instance, new_pass=new_pass,
                   injected_files=injected_files, image_ref=image_ref,
                   orig_image_ref=orig_image_ref,
                   orig_sys_metadata=orig_sys_metadata, bdms=bdms,
                   recreate=recreate, on_shared_storage=on_shared_storage,
                   **extra)

    def _handle_cell_delete(self, context, instance, method_name):
        if not instance.cell_name:
            delete_type = method_name == 'soft_delete' and 'soft' or 'hard'
            self.cells_rpcapi.instance_delete_everywhere(context,
                    instance, delete_type)
            bdms = block_device.legacy_mapping(
                self.db.block_device_mapping_get_all_by_instance(
                    context, instance.uuid))
            # NOTE(danms): If we try to delete an instance with no cell,
            # there isn't anything to salvage, so we can hard-delete here.
            try:
                super(ComputeCellsAPI, self)._local_delete(context, instance,
                                                           bdms, method_name,
                                                           self._do_delete)
            except exception.ObjectActionError:
                # NOTE(alaski): We very likely got here because the host
                # constraint in instance.destroy() failed.  This likely means
                # 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:
                    instance.refresh()
                    if instance.cell_name:
                        exc.reraise = False
                        self._handle_cell_delete(context, instance,
                                method_name)
            return

        method = getattr(super(ComputeCellsAPI, self), method_name)
        method(context, instance)

    def _handle_cell_delete(self, context, instance, method_name):
        if not instance.cell_name:
            delete_type = method_name == "soft_delete" and "soft" or "hard"
            self.cells_rpcapi.instance_delete_everywhere(context, instance, delete_type)
            bdms = block_device.legacy_mapping(self.db.block_device_mapping_get_all_by_instance(context, instance.uuid))
            # NOTE(danms): If we try to delete an instance with no cell,
            # there isn't anything to salvage, so we can hard-delete here.
            try:
                super(ComputeCellsAPI, self)._local_delete(context, instance, bdms, method_name, self._do_delete)
            except exception.ObjectActionError:
                # NOTE(alaski): We very likely got here because the host
                # constraint in instance.destroy() failed.  This likely means
                # 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.
                        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 a instance_destroy_at_top hits.
                pass
            return

        method = getattr(super(ComputeCellsAPI, self), method_name)
        method(context, instance)

 def terminate_instance(self, ctxt, instance, bdms, reservations=None):
     # NOTE(russellb) Havana compat
     if self.client.can_send_version("3.22"):
         version = "3.22"
     else:
         version = self._get_compat_version("3.0", "2.35")
         bdms = block_device.legacy_mapping(bdms)
         bdms = jsonutils.to_primitive(objects_base.obj_to_primitive(bdms))
     cctxt = self.client.prepare(server=_compute_host(None, instance), version=version)
     cctxt.cast(ctxt, "terminate_instance", instance=instance, bdms=bdms, reservations=reservations)

    def _handle_cell_delete(self, context, instance, method_name):
        if not instance["cell_name"]:
            delete_type = method_name == "soft_delete" and "soft" or "hard"
            self.cells_rpcapi.instance_delete_everywhere(context, instance, delete_type)
            bdms = block_device.legacy_mapping(
                self.db.block_device_mapping_get_all_by_instance(context, instance["uuid"])
            )
            # NOTE(danms): If we try to delete an instance with no cell,
            # there isn't anything to salvage, so we can hard-delete here.
            super(ComputeCellsAPI, self)._local_delete(context, instance, bdms, method_name, self._do_delete)
            return

        method = getattr(super(ComputeCellsAPI, self), method_name)
        method(context, instance)

    def test_legacy_mapping_source_image(self):
        got_legacy = block_device.legacy_mapping(self.new_mapping)

        for legacy, expected in zip(got_legacy, self.legacy_mapping):
            self.assertThat(expected, matchers.IsSubDictOf(legacy))