openstack-nova源码分析(九）冷迁移

╰半橙微兮° 2021-11-16 14:34 365阅读 0赞

##### 冷迁移 cold migration： #####

不保存虚拟机在线状态的，将主机迁移到其他宿主机， 迁移过程中会有关机的操作

备注： 为了方便梳理流程， 展示关键的流程步骤，过程中展示的源码部分会被删减

冷迁移

##### 一. 入口API: #####

##### nova/api/openstack/compute/migrate\_server.py #####

class MigrateServerController(wsgi.Controller):
        def __init__(self, *args, **kwargs):
        ....
    
        @wsgi.action('migrate')
        def _migrate(self, req, id, body):
            """Permit admins to migrate a server to a new host."""
            context = req.environ['nova.context']
            context.can(ms_policies.POLICY_ROOT % 'migrate')
    
            instance = common.get_instance(self.compute_api, context, id)
            try:
                self.compute_api.resize(req.environ['nova.context'], instance)
            except (exception.TooManyInstances, exception.QuotaError) as e:
                raise exc.HTTPForbidden(explanation=e.format_message())

instance = common.get\_instance(self.compute\_api, context, id) 依据instance id 获取instance id 并对instance的存在性做了校验

实际调用函数`self.compute_api.resize(req.environ['nova.context'], instance)`

--------------------

##### 二. resize #####

##### compute\_api.resize定义在 nova/compute/api.py #####

定义在API类中

@profiler.trace_cls("compute_api")
    class API(base.Base):
        """API for interacting with the compute manager."""

@check_instance_lock       // 校验虚拟机的状态， 一个虚拟机上同时不进行多个任务
        @check_instance_cell
        @check_instance_state(vm_state=[vm_states.ACTIVE, vm_states.STOPPED])
        
        // 校验虚拟机状态，active 和stopped状态允许迁移
        
        def resize(self, context, instance, flavor_id=None, clean_shutdown=True,
                   **extra_instance_updates):
            """Resize (ie, migrate) a running instance.
    
            If flavor_id is None, the process is considered a migration, keeping
            the original flavor_id. If flavor_id is not None, the instance should
            be migrated to a new host and resized to the new flavor_id.
            """
            
            // 校验磁盘信息
            self._check_auto_disk_config(instance, **extra_instance_updates)
            
            // 获取当前flavor 并校验flavor
    
            current_instance_type = instance.get_flavor()
    
            # If flavor_id is not provided, only migrate the instance.
            if not flavor_id:
                LOG.debug("flavor_id is None. Assuming migration.",
                          instance=instance)
                new_instance_type = current_instance_type
            else:
    					....
    
            if not new_instance_type:
                raise exception.FlavorNotFound(flavor_id=flavor_id)
    
    
            same_instance_type = (current_instance_type['id'] == new_instance_type['id'])
    
    
    				//获取配额信息
            if flavor_id:
    						....
            else:
                quotas = objects.Quotas(context=context)
    
    				// 更新虚拟机状态为RESIZE_PREP, 虚拟机设置为该状态开始，将会锁定，不允许进行其他任务
    				
            instance.task_state = task_states.RESIZE_PREP
            instance.progress = 0
            instance.update(extra_instance_updates)
            instance.save(expected_task_state=[None])
    
    				//  依据参数 创建调度过滤参数
    				
            filter_properties = {'ignore_hosts': []}
    
    				// 是否允许迁移到同一台主机， 默认为False
    				
            if not CONF.allow_resize_to_same_host:
                filter_properties['ignore_hosts'].append(instance.host)
    
    
    				// 发送迁移状态
            if not flavor_id:
                self._record_action_start(context, instance,
                                          instance_actions.MIGRATE)
            else:
                .....
    				
    				
    					// 获取request_spec，该参数为新的调度参数,将ignore  host加入调度
            try:
                request_spec = objects.RequestSpec.get_by_instance_uuid(
                    context, instance.uuid)
                request_spec.ignore_hosts = filter_properties['ignore_hosts']
            except exception.RequestSpecNotFound:
                # Some old instances can still have no RequestSpec object attached
                # to them, we need to support the old way
                request_spec = None
    
            scheduler_hint = {'filter_properties': filter_properties}
            
            //resize_instance  任务迁移
            self.compute_task_api.resize_instance(context, instance,
                    extra_instance_updates, scheduler_hint=scheduler_hint,
                    flavor=new_instance_type,
                    reservations=quotas.reservations or [],
                    clean_shutdown=clean_shutdown,
                    request_spec=request_spec)

该步骤主要是进行参数校验，并获取request\_spec 调度参数。 调用resize\_instance

##### resize\_instance 定义 #####

def resize_instance(self, context, instance, extra_instance_updates,
                            scheduler_hint, flavor, reservations,
                            clean_shutdown=True, request_spec=None):
            # NOTE(comstud): 'extra_instance_updates' is not used here but is
            # needed for compatibility with the cells_rpcapi version of this
            # method.
            self.conductor_compute_rpcapi.migrate_server(
                context, instance, scheduler_hint, live=False, rebuild=False,
                flavor=flavor, block_migration=None, disk_over_commit=None,
                reservations=reservations, clean_shutdown=clean_shutdown,
                request_spec=request_spec)

##### 三. migrate\_server #####

调用的conductor 层的 migrate\_server, 通过rpc远程调用方式进行

定义在nova/conductor/rpcapi.py

def migrate_server(self, context, instance, scheduler_hint, live, rebuild,
                      flavor, block_migration, disk_over_commit,
                      reservations=None, clean_shutdown=True, request_spec=None):
                      
                      ....
                      
            cctxt = self.client.prepare(version=version)
            return cctxt.call(context, 'migrate_server', **kw)

--------------------

##### 四. conductor migrate\_server #####

实际调用的conductor的migrate\_server  
该过程实际通过Manager进行处理

nova/conductor/manager.py  
定义：

@profiler.trace_cls("rpc")
    class ComputeTaskManager(base.Base):
        """Namespace for compute methods.

@wrap_instance_event(prefix='conductor')
        def migrate_server(self, context, instance, scheduler_hint, live, rebuild,
                flavor, block_migration, disk_over_commit, reservations=None,
                clean_shutdown=True, request_spec=None):
            if instance and not isinstance(instance, nova_object.NovaObject):
                # NOTE(danms): Until v2 of the RPC API, we need to tolerate
                # old-world instance objects here
                attrs = ['metadata', 'system_metadata', 'info_cache',
                         'security_groups']
                instance = objects.Instance._from_db_object(
                    context, objects.Instance(), instance,
                    expected_attrs=attrs)
            # NOTE: Remove this when we drop support for v1 of the RPC API
            if flavor and not isinstance(flavor, objects.Flavor):
                # Code downstream may expect extra_specs to be populated since it
                # is receiving an object, so lookup the flavor to ensure this.
                flavor = objects.Flavor.get_by_id(context, flavor['id'])
            if live and not rebuild and not flavor:
                self._live_migrate(context, instance, scheduler_hint,
                                   block_migration, disk_over_commit, request_spec)
            elif not live and not rebuild and flavor:
                instance_uuid = instance.uuid
                with compute_utils.EventReporter(context, 'cold_migrate',
                                                 instance_uuid):
                    self._cold_migrate(context, instance, flavor,
                                       scheduler_hint['filter_properties'],
                                       reservations, clean_shutdown, request_spec)
            else:
                raise NotImplementedError()

migrate\_server 是一个公用的函数， 冷迁移， resiez， 以及热迁移都经过该函数

这里冷迁移实际使用`_cold_migrate` 进行处理

\_cold\_migrate 定义：

def _cold_migrate(self, context, instance, flavor, filter_properties,
                          reservations, clean_shutdown, request_spec):
            image = utils.get_image_from_system_metadata(
                instance.system_metadata)
    
    				
    				// 更新request_spec  
            if not request_spec:
                # Make sure we hydrate a new RequestSpec object with the new flavor
                # and not the nested one from the instance
                request_spec = objects.RequestSpec.from_components(
                    context, instance.uuid, image,
                    flavor, instance.numa_topology, instance.pci_requests,
                    filter_properties, None, instance.availability_zone,
                    project_id=instance.project_id)
            else:
                # NOTE(sbauza): Resizes means new flavor, so we need to update the
                # original RequestSpec object for make sure the scheduler verifies
                # the right one and not the original flavor
                request_spec.flavor = flavor
                
                
    				// 创建冷迁移任务 并执行
            task = self._build_cold_migrate_task(context, instance, flavor,
                                                 request_spec,
                                                 reservations, clean_shutdown)
            # TODO(sbauza): Provide directly the RequestSpec object once
            # _set_vm_state_and_notify() accepts it
            legacy_spec = request_spec.to_legacy_request_spec_dict()
            try:
                task.execute()
            except exception.NoValidHost as ex:
               ....
               
    				
    				// 保存request_spec 调度参数
    				
            if request_spec.obj_what_changed():
                request_spec.save()

该过程实际就是做异常处理，并保存请求参数

task.execute() 实际处理由`_execute进行`

定义在nova/conductor/tasks/migrate.py

def _execute(self):
            image = self.request_spec.image
            self.quotas = objects.Quotas.from_reservations(self.context,
                                                           self.reservations,
                                                           instance=self.instance)
    
    
            legacy_spec = self.request_spec.to_legacy_request_spec_dict()
            legacy_props = self.request_spec.to_legacy_filter_properties_dict()
            scheduler_utils.setup_instance_group(self.context, legacy_spec,
                                                 legacy_props)
            scheduler_utils.populate_retry(legacy_props,
                                           self.instance.uuid)
    
    
    				// 重新调度生成request_spec
            self.request_spec = objects.RequestSpec.from_components(
                self.context, self.instance.uuid, image,
                self.flavor, self.instance.numa_topology,
                self.instance.pci_requests, legacy_props, None,
                self.instance.availability_zone)
    
    				//将forced host 重置掉，以免影响调度
            self.request_spec.reset_forced_destinations()
            
            
            // 调度， 获取可用宿主机，并选用一台
            hosts = self.scheduler_client.select_destinations(
                self.context, self.request_spec)
            host_state = hosts[0]
    
            scheduler_utils.populate_filter_properties(legacy_props,
                                                       host_state)
            # context is not serializable
            legacy_props.pop('context', None)
    
            (host, node) = (host_state['host'], host_state['nodename'])
    
    
            legacy_spec = jsonutils.loads(jsonutils.dumps(legacy_spec))
    
    				// rpc 调用目的节点prep_resize
            self.compute_rpcapi.prep_resize(
                self.context, self.instance, legacy_spec['image'],
                self.flavor, host, self.reservations,
                request_spec=legacy_spec, filter_properties=legacy_props,
                node=node, clean_shutdown=self.clean_shutdown)

该步骤主要进行调度， 选取目标宿主机， 发送任务， 进行迁移

--------------------

##### 五. prep\_resize #####

prep\_resize 定义在nova/compute/manager.py

定义如下：

@wrap_exception()
        @reverts_task_state
        @wrap_instance_event(prefix='compute')
        @wrap_instance_fault
        def prep_resize(self, context, image, instance, instance_type,
                        reservations, request_spec, filter_properties, node,
                        clean_shutdown):
    
    				// 校验参数
            if node is None:
                node = self.driver.get_available_nodes(refresh=True)[0]
                LOG.debug("No node specified, defaulting to %s", node,
                          instance=instance)
    
            # NOTE(melwitt): Remove this in version 5.0 of the RPC API
            # Code downstream may expect extra_specs to be populated since it
            # is receiving an object, so lookup the flavor to ensure this.
            if not isinstance(instance_type, objects.Flavor):
                instance_type = objects.Flavor.get_by_id(context,
                                                         instance_type['id'])
                                                         
                                                         
    				// 配额 quotas
            quotas = objects.Quotas.from_reservations(context,
                                                      reservations,
                                                      instance=instance)
            with self._error_out_instance_on_exception(context, instance,
                                                       quotas=quotas):
                compute_utils.notify_usage_exists(self.notifier, context, instance,
                                                  current_period=True)
                //  通知状态                                 
                self._notify_about_instance_usage(
                        context, instance, "resize.prep.start")
                try:
                    self._prep_resize(context, image, instance,
                                      instance_type, quotas,
                                      request_spec, filter_properties,
                                      node, clean_shutdown)
    
                except exception.MigrationPreCheckError:
                    raise
                except Exception:
                    # try to re-schedule the resize elsewhere:
                    exc_info = sys.exc_info()
                    self._reschedule_resize_or_reraise(context, image, instance,
                            exc_info, instance_type, quotas, request_spec,
                            filter_properties)
                finally:
                    extra_usage_info = dict(
                            new_instance_type=instance_type.name,
                            new_instance_type_id=instance_type.id)
    
                    self._notify_about_instance_usage(
                        context, instance, "resize.prep.end",
                        extra_usage_info=extra_usage_info)

由\_prep\_resize 进行处理

def _prep_resize(self, context, image, instance, instance_type,
                quotas, request_spec, filter_properties, node,
                clean_shutdown=True):
    
            if not filter_properties:
                filter_properties = {}
    
            if not instance.host:
                self._set_instance_obj_error_state(context, instance)
                msg = _('Instance has no source host')
                raise exception.MigrationError(reason=msg)
    
    				// 判断是否为同一台主机， 
    				并检查 supports_migrate_to_same_host 是否支持迁移到同一台主机上
    				
            same_host = instance.host == self.host
            # if the flavor IDs match, it's migrate; otherwise resize
            if same_host and instance_type.id == instance['instance_type_id']:
                # check driver whether support migrate to same host
                if not self.driver.capabilities['supports_migrate_to_same_host']:
                    raise exception.UnableToMigrateToSelf(
                        instance_id=instance.uuid, host=self.host)
    
    
    				更新instance  信息 并保存
            instance.new_flavor = instance_type
            # NOTE(mriedem): Stash the old vm_state so we can set the
            # resized/reverted instance back to the same state later.
            vm_state = instance.vm_state
            LOG.debug('Stashing vm_state: %s', vm_state, instance=instance)
            instance.system_metadata['old_vm_state'] = vm_state
            instance.save()
    
            limits = filter_properties.get('limits', {})
            rt = self._get_resource_tracker()
            
            // 开始迁移
            with rt.resize_claim(context, instance, instance_type, node,
                                 image_meta=image, limits=limits) as claim:
                LOG.info(_LI('Migrating'), instance=instance)
                self.compute_rpcapi.resize_instance(
                        context, instance, claim.migration, image,
                        instance_type, quotas.reservations,
                        clean_shutdown)

另外：

def resize_instance(self, ctxt, instance, migration, image, instance_type,
                            reservations=None, clean_shutdown=True):
            msg_args = {'instance': instance, 'migration': migration,
                        'image': image, 'reservations': reservations,
                        'instance_type': instance_type,
                        'clean_shutdown': clean_shutdown,
            }
            version = '4.1'
            client = self.router.by_instance(ctxt, instance)
            if not client.can_send_version(version):
                msg_args['instance_type'] = objects_base.obj_to_primitive(
                                                instance_type)
                version = '4.0'
            cctxt = client.prepare(server=_compute_host(None, instance),
                    version=version)
            cctxt.cast(ctxt, 'resize_instance', **msg_args)

通过源码分析，得到 compute\_rpcapi.resize\_instance 其实是调用instance原来主机上的过程，  
进行正式的迁移

--------------------

##### 六. 原宿主机 resize\_instance #####

resize\_instance 定义在 nova/compute/manager.py中：

@wrap_instance_event(prefix='compute')
        @errors_out_migration
        @wrap_instance_fault
        def resize_instance(self, context, instance, image,
                            reservations, migration, instance_type,
                            clean_shutdown):
                            
                            
             // 备注写得非常清晰， 将一个instance迁移到另外一个主机上               
            """Starts the migration of a running instance to another host."""
    
            quotas = objects.Quotas.from_reservations(context,
                                                      reservations,
                                                      instance=instance)
            with self._error_out_instance_on_exception(context, instance,
                                                       quotas=quotas):
                # TODO(chaochin) Remove this until v5 RPC API
                # Code downstream may expect extra_specs to be populated since it
                # is receiving an object, so lookup the flavor to ensure this.
                if (not instance_type or
                    not isinstance(instance_type, objects.Flavor)):
                    instance_type = objects.Flavor.get_by_id(
                        context, migration['new_instance_type_id'])
    
    						//  获取instance 网络信息 该部分现在由NEUTRON 处理
                network_info = self.network_api.get_instance_nw_info(context,
                                                                     instance)
    
    						//  更新状态
                migration.status = 'migrating'
                with migration.obj_as_admin():
                    migration.save()
    
                instance.task_state = task_states.RESIZE_MIGRATING
                instance.save(expected_task_state=task_states.RESIZE_PREP)
    
    						//  通知instance状态
                self._notify_about_instance_usage(
                    context, instance, "resize.start", network_info=network_info)
    
                compute_utils.notify_about_instance_action(context, instance,
                       self.host, action=fields.NotificationAction.RESIZE,
                       phase=fields.NotificationPhase.START)
                       
                       
                //  获取虚拟机的块设备信息
    
                bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(
                        context, instance.uuid)
                block_device_info = self._get_instance_block_device_info(
                                    context, instance, bdms=bdms)
    
    					
                timeout, retry_interval = self._get_power_off_values(context,
                                                instance, clean_shutdown)
                
                
                // 关闭并进行C盘迁移
                disk_info = self.driver.migrate_disk_and_power_off(
                        context, instance, migration.dest_host,
                        instance_type, network_info,
                        block_device_info,
                        timeout, retry_interval)
    
    						// 中断磁盘映射关系
                self._terminate_volume_connections(context, instance, bdms)
    
                migration_p = obj_base.obj_to_primitive(migration)
                //  迁移虚拟机网络
                self.network_api.migrate_instance_start(context,
                                                        instance,
                                                        migration_p)
    
    						//  保存虚拟机状态
                migration.status = 'post-migrating'
                with migration.obj_as_admin():
                    migration.save()
    
    						// 迁移完成
                instance.host = migration.dest_compute
                instance.node = migration.dest_node
                instance.task_state = task_states.RESIZE_MIGRATED
                instance.save(expected_task_state=task_states.RESIZE_MIGRATING)
                
    						//  完成迁移， 完成迁移的收尾工作， 实例创建， 启动等
                self.compute_rpcapi.finish_resize(context, instance,
                        migration, image, disk_info,
                        migration.dest_compute, reservations=quotas.reservations)
    
                self._notify_about_instance_usage(context, instance, "resize.end",
                                                  network_info=network_info)
    
                compute_utils.notify_about_instance_action(context, instance,
                       self.host, action=fields.NotificationAction.RESIZE,
                       phase=fields.NotificationPhase.END)
                self.instance_events.clear_events_for_instance(instance)

关键步骤：

1.  关闭并进行磁盘迁移
2.  网络迁移
3.  迁移收尾工作， 创建实例， 启动实例等

--------------------

核心步骤：

##### 七. 磁盘迁移： #####

disk_info = self.driver.migrate_disk_and_power_off(
             context, instance, migration.dest_host,
             instance_type, network_info,
             block_device_info,
             timeout, retry_interval)

migrate\_disk\_and\_power\_off该过程定义在：

nova/virt/libvirt/driver.py

def migrate_disk_and_power_off(self, context, instance, dest,
                                       flavor, network_info,
                                       block_device_info=None,
                                       timeout=0, retry_interval=0):
            LOG.debug("Starting migrate_disk_and_power_off",
                       instance=instance)
    
            ephemerals = driver.block_device_info_get_ephemerals(block_device_info)
    
            # get_bdm_ephemeral_disk_size() will return 0 if the new
            # instance's requested block device mapping contain no
            # ephemeral devices. However, we still want to check if
            # the original instance's ephemeral_gb property was set and
            # ensure that the new requested flavor ephemeral size is greater
            eph_size = (block_device.get_bdm_ephemeral_disk_size(ephemerals) or
                        instance.flavor.ephemeral_gb)
    
    				// 磁盘参数校验
    				
            # Checks if the migration needs a disk resize down.
            root_down = flavor.root_gb < instance.flavor.root_gb
            ephemeral_down = flavor.ephemeral_gb < eph_size
            booted_from_volume = self._is_booted_from_volume(block_device_info)
    
            if (root_down and not booted_from_volume) or ephemeral_down:
                reason = _("Unable to resize disk down.")
                raise exception.InstanceFaultRollback(
                    exception.ResizeError(reason=reason))
    
            # NOTE(dgenin): Migration is not implemented for LVM backed instances.
            if CONF.libvirt.images_type == 'lvm' and not booted_from_volume:
                reason = _("Migration is not supported for LVM backed instances")
                raise exception.InstanceFaultRollback(
                    exception.MigrationPreCheckError(reason=reason))
    
            # copy disks to destination
            # rename instance dir to +_resize at first for using
            # shared storage for instance dir (eg. NFS).
            inst_base = libvirt_utils.get_instance_path(instance)
            inst_base_resize = inst_base + "_resize"
            shared_storage = self._is_storage_shared_with(dest, inst_base)
    
            # try to create the directory on the remote compute node
            # if this fails we pass the exception up the stack so we can catch
            # failures here earlier
            
            // 是否为共享存储， 如果不是则在目标宿主机上创建对应的目录
            if not shared_storage:
                try:
                    self._remotefs.create_dir(dest, inst_base)
                except processutils.ProcessExecutionError as e:
                    reason = _("not able to execute ssh command: %s") % e
                    raise exception.InstanceFaultRollback(
                        exception.ResizeError(reason=reason))
    
    				// 关闭虚拟机
            self.power_off(instance, timeout, retry_interval)
            
            
    				//  获取磁盘映射关系
            block_device_mapping = driver.block_device_info_get_mapping(
                block_device_info)
            for vol in block_device_mapping:
                connection_info = vol['connection_info']
                disk_dev = vol['mount_device'].rpartition("/")[2]
                self._disconnect_volume(connection_info, disk_dev)
    
            disk_info_text = self.get_instance_disk_info(
                instance, block_device_info=block_device_info)
            disk_info = jsonutils.loads(disk_info_text)
    
    
    				// 进行目录操作， 磁盘设置等
            try:
                utils.execute('mv', inst_base, inst_base_resize)
                # if we are migrating the instance with shared storage then
                # create the directory.  If it is a remote node the directory
                # has already been created
                if shared_storage:
                    dest = None
                    utils.execute('mkdir', '-p', inst_base)
    
                on_execute = lambda process: \
                    self.job_tracker.add_job(instance, process.pid)
                on_completion = lambda process: \
                    self.job_tracker.remove_job(instance, process.pid)
    
                for info in disk_info:
                    # assume inst_base == dirname(info['path'])
                    img_path = info['path']
                    fname = os.path.basename(img_path)
                    from_path = os.path.join(inst_base_resize, fname)
    
                    # We will not copy over the swap disk here, and rely on
                    # finish_migration to re-create it for us. This is ok because
                    # the OS is shut down, and as recreating a swap disk is very
                    # cheap it is more efficient than copying either locally or
                    # over the network. This also means we don't have to resize it.
                    if fname == 'disk.swap':
                        continue
    								
    								//  将磁盘复制到目标节点
                    compression = info['type'] not in NO_COMPRESSION_TYPES
                    libvirt_utils.copy_image(from_path, img_path, host=dest,
                                             on_execute=on_execute,
                                             on_completion=on_completion,
                                             compression=compression)
                                             
    						迁移disk.info 磁盘信息， 例如注入信息等
                # Ensure disk.info is written to the new path to avoid disks being
                # reinspected and potentially changing format.
                src_disk_info_path = os.path.join(inst_base_resize, 'disk.info')
                if os.path.exists(src_disk_info_path):
                    dst_disk_info_path = os.path.join(inst_base, 'disk.info')
                    libvirt_utils.copy_image(src_disk_info_path,
                                             dst_disk_info_path,
                                             host=dest, on_execute=on_execute,
                                             on_completion=on_completion)
            except Exception:
                with excutils.save_and_reraise_exception():
                    self._cleanup_remote_migration(dest, inst_base,
                                                   inst_base_resize,
                                                   shared_storage)
    
            return disk_info_text

磁盘迁移完成后， 进行网络迁移

网络迁移目前已经独立， 这里不做分析

网络迁移完成后，finish\_resize

##### 八. finish\_resize #####

finish\_resize 定义如下： nova/compute/manager.py

@wrap_instance_event(prefix='compute')
        @errors_out_migration
        @wrap_instance_fault
        def finish_resize(self, context, disk_info, image, instance,
                          reservations, migration):
            """Completes the migration process.
    
            Sets up the newly transferred disk and turns on the instance at its
            new host machine.
    
            """
            quotas = objects.Quotas.from_reservations(context,
                                                      reservations,
                                                      instance=instance)
                                                      
           //  完成迁移， 并更新 quotas 配额信息                                        
            try:
                image_meta = objects.ImageMeta.from_dict(image)
                self._finish_resize(context, instance, migration,
                                    disk_info, image_meta)
                quotas.commit()
            except Exception:
    						....

\_finish\_resize 定义

def _finish_resize(self, context, instance, migration, disk_info,
                           image_meta):
            resize_instance = False
            old_instance_type_id = migration['old_instance_type_id']
            new_instance_type_id = migration['new_instance_type_id']
            old_instance_type = instance.get_flavor()
            # NOTE(mriedem): Get the old_vm_state so we know if we should
            # power on the instance. If old_vm_state is not set we need to default
            # to ACTIVE for backwards compatibility
            old_vm_state = instance.system_metadata.get('old_vm_state',
                                                        vm_states.ACTIVE)
            instance.old_flavor = old_instance_type
    
            if old_instance_type_id != new_instance_type_id:
                instance_type = instance.get_flavor('new')
                self._set_instance_info(instance, instance_type)
                for key in ('root_gb', 'swap', 'ephemeral_gb'):
                    if old_instance_type[key] != instance_type[key]:
                        resize_instance = True
                        break
            instance.apply_migration_context()
    
    
    				// 创建设置网络， 并完成网络迁移
            # NOTE(tr3buchet): setup networks on destination host
            self.network_api.setup_networks_on_host(context, instance,
                                                    migration['dest_compute'])
    
            migration_p = obj_base.obj_to_primitive(migration)
            self.network_api.migrate_instance_finish(context,
                                                     instance,
                                                     migration_p)
    
            network_info = self.network_api.get_instance_nw_info(context, instance)
    
            instance.task_state = task_states.RESIZE_FINISH
            instance.save(expected_task_state=task_states.RESIZE_MIGRATED)
    
            self._notify_about_instance_usage(
                context, instance, "finish_resize.start",
                network_info=network_info)
            compute_utils.notify_about_instance_action(context, instance,
                   self.host, action=fields.NotificationAction.RESIZE_FINISH,
                   phase=fields.NotificationPhase.START)
                   
            // 获取磁盘信息
    
            block_device_info = self._get_instance_block_device_info(
                                context, instance, refresh_conn_info=True)
    
            # NOTE(mriedem): If the original vm_state was STOPPED, we don't
            # automatically power on the instance after it's migrated
            power_on = old_vm_state != vm_states.STOPPED
    
            try:
            // 完成迁移
                self.driver.finish_migration(context, migration, instance,
                                             disk_info,
                                             network_info,
                                             image_meta, resize_instance,
                                             block_device_info, power_on)
            except Exception:
                with excutils.save_and_reraise_exception():
                    if old_instance_type_id != new_instance_type_id:
                        self._set_instance_info(instance,
                                                old_instance_type)
    
            migration.status = 'finished'
            with migration.obj_as_admin():
                migration.save()
    
    				// 更新状态
            instance.vm_state = vm_states.RESIZED
            instance.task_state = None
            instance.launched_at = timeutils.utcnow()
            instance.save(expected_task_state=task_states.RESIZE_FINISH)
    
            self._update_scheduler_instance_info(context, instance)
            self._notify_about_instance_usage(
                context, instance, "finish_resize.end",
                network_info=network_info)
            compute_utils.notify_about_instance_action(context, instance,
                   self.host, action=fields.NotificationAction.RESIZE_FINISH,
                   phase=fields.NotificationPhase.END)

##### 九. finish\_migration #####

finish\_migration 定义在 virt/libvirt/driver.py

def finish_migration(self, context, migration, instance, disk_info,
                             network_info, image_meta, resize_instance,
                             block_device_info=None, power_on=True):
            LOG.debug("Starting finish_migration", instance=instance)
    
    
    				//  获取磁盘信息，并创建磁盘镜像
            block_disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,
                                                      instance,
                                                      image_meta,
                                                      block_device_info)
            # assume _create_image does nothing if a target file exists.
            # NOTE: This has the intended side-effect of fetching a missing
            # backing file.
            self._create_image(context, instance, block_disk_info['mapping'],
                               network_info=network_info,
                               block_device_info=block_device_info,
                               inject_files=False, ignore_bdi_for_swap=True,
                               fallback_from_host=migration.source_compute)
    
            # Required by Quobyte CI
            self._ensure_console_log_for_instance(instance)
    
            gen_confdrive = functools.partial(self._create_configdrive,
                                              context, instance,
                                              network_info=network_info)
    
            # Resize root disk and a single ephemeral disk called disk.local
            # Also convert raw disks to qcow2 if migrating to host which uses
            # qcow2 from host which uses raw.
            # TODO(mbooth): Handle resize of multiple ephemeral disks, and
            #               ephemeral disks not called disk.local.
            disk_info = jsonutils.loads(disk_info)
            for info in disk_info:
                path = info['path']
                disk_name = os.path.basename(path)
    
                size = self._disk_size_from_instance(instance, disk_name)
                if resize_instance:
                    image = imgmodel.LocalFileImage(path, info['type'])
                    self._disk_resize(image, size)
    
    
                if (disk_name != 'disk.config' and
                            info['type'] == 'raw' and CONF.use_cow_images):
                    self._disk_raw_to_qcow2(info['path'])
    
    				
    				// 依据instance 信息生成 xml 文件
            xml = self._get_guest_xml(context, instance, network_info,
                                      block_disk_info, image_meta,
                                      block_device_info=block_device_info)
    
    				// 创建虚拟机
            guest = self._create_domain_and_network(context, xml, instance,
                                            network_info,
                                            block_disk_info,
                                            block_device_info=block_device_info,
                                            power_on=power_on,
                                            vifs_already_plugged=True,
                                            post_xml_callback=gen_confdrive)
            if power_on:
                timer = loopingcall.FixedIntervalLoopingCall(
                                                        self._wait_for_running,
                                                        instance)
                timer.start(interval=0.5).wait()
    
                # Sync guest time after migration.
                guest.sync_guest_time()
    
            LOG.debug("finish_migration finished successfully.", instance=instance)

##### 十. \_create\_domain\_and\_network 创建虚拟机 #####

`_create_domain_and_network` 在目标宿主机创建虚拟机， 如果原始状态为active则启动  
该步骤在虚拟机创建中分析， 可以参考虚拟机创建流程