D:\tran_code\nova_v1\nova\api\openstack\compute\evacuate.py
    @extensions.expected_errors((400, 404, 409))
    @wsgi.action(‘evacuate‘)
    @validation.schema(evacuate.evacuate, "2.0", "2.13")
    @validation.schema(evacuate.evacuate_v214, "2.14", "2.28")
    @validation.schema(evacuate.evacuate_v2_29, "2.29")
    def _evacuate(self, req, id, body):
        """Permit admins to evacuate a server from a failed host
        to a new one.
        """
        context = req.environ["nova.context"]
        instance = common.get_instance(self.compute_api, context, id)
        context.can(evac_policies.BASE_POLICY_NAME,
                    target={‘user_id‘: instance.user_id,
                            ‘project_id‘: instance.project_id})

        evacuate_body = body["evacuate"]
        host = evacuate_body.get("host")
        force = None

        on_shared_storage = self._get_on_shared_storage(req, evacuate_body)

        if api_version_request.is_supported(req, min_version=‘2.29‘):
            force = body["evacuate"].get("force", False)
            force = strutils.bool_from_string(force, strict=True)
            if force is True and not host:
                message = _("Can‘t force to a non-provided destination")
                raise exc.HTTPBadRequest(explanation=message)
        if api_version_request.is_supported(req, min_version=‘2.14‘):
            password = self._get_password_v214(req, evacuate_body)
        else:
            password = self._get_password(req, evacuate_body,
                                          on_shared_storage)

        if host is not None:
            try:
                self.host_api.service_get_by_compute_host(context, host)
            except (exception.ComputeHostNotFound,
                    exception.HostMappingNotFound):
                msg = _("Compute host %s not found.") % host
                raise exc.HTTPNotFound(explanation=msg)

        if instance.host == host:
            msg = _("The target host can‘t be the same one.")
            raise exc.HTTPBadRequest(explanation=msg)

        try:
            self.compute_api.evacuate(context, instance, host,
                                      on_shared_storage, password, force)
        except exception.InstanceUnknownCell as e:
            raise exc.HTTPNotFound(explanation=e.format_message())
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    ‘evacuate‘, id)
        except exception.ComputeServiceInUse as e:
            raise exc.HTTPBadRequest(explanation=e.format_message())

        if (not api_version_request.is_supported(req, min_version=‘2.14‘) and
                CONF.api.enable_instance_password):
            return {‘adminPass‘: password}
        else:
            return None

D:\tran_code\nova_v1\nova\compute\api.py
    def evacuate(self, context, instance, host, on_shared_storage,
                 admin_password=None, force=None):
		参数介绍
		进行宕机疏散的虚拟机
		目标节点，没有设置的话，则为空
		虚机是不是共享存储标识
		新建创建虚机的登录密码
		强制宕机疏导到指定目标节点上标识
        """Running evacuate to target host.

        Checking vm compute host state, if the host not in expected_state,
        raising an exception.

        :param instance: The instance to evacuate
        :param host: Target host. if not set, the scheduler will pick up one
        :param on_shared_storage: True if instance files on shared storage
        :param admin_password: password to set on rebuilt instance
        :param force: Force the evacuation to the specific host target

        """
        LOG.debug(‘vm evacuation scheduled‘, instance=instance)
        inst_host = instance.host-----获取虚机的所在host节点
        service = objects.Service.get_by_compute_host(context, inst_host)----根据虚机的host来获取其nova-compute service信息
        if self.servicegroup_api.service_is_up(service):------对虚机所在的nova-compute节点状态进行判断，宕机疏散是在虚机所在的nova-compute节点为down的情况下，疏散的，因此如果
            LOG.error(‘Instance compute service state on %s ‘-----虚机所在的nova-compute服务为up会抛出异常
                      ‘expected to be down, but it was up.‘, inst_host)
            raise exception.ComputeServiceInUse(host=inst_host)

        instance.task_state = task_states.REBUILDING----设置虚机的任务状态为rebuiding，重建状态
        instance.save(expected_task_state=[None])------把这个任务保存一下
        self._record_action_start(context, instance, instance_actions.EVACUATE)----记录该虚机的动作

        # NOTE(danms): Create this as a tombstone for the source compute
        # to find and cleanup. No need to pass it anywhere else.
        migration = objects.Migration(context,------创建这个migration记录，是为源计算节点创建一个醒目标志，为了找到它及以后清理，这个参数不会通过参数的形式，下发下去
                                      source_compute=instance.host,
                                      source_node=instance.node,
                                      instance_uuid=instance.uuid,
                                      status=‘accepted‘,
                                      migration_type=‘evacuation‘)-----迁移的类型为宕机疏散
        if host:----如果指定了目标主机，那么把目标主机记录到Migration表里面
            migration.dest_compute = host
        migration.create()

        compute_utils.notify_about_instance_usage(
            self.notifier, context, instance, "evacuate")

        try:
            request_spec = objects.RequestSpec.get_by_instance_uuid(-----根据虚机的uuid，来获取虚机的request_spec信息，如果没有找到的话，那么就设置为空
                context, instance.uuid)
        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

        # NOTE(sbauza): Force is a boolean by the new related API version
        if force is False and host:------如果不强制进行宕机疏散并且还强制指定了特定的host主机，那么就走这段逻辑，其他情况是，不走，
            nodes = objects.ComputeNodeList.get_all_by_host(context, host)------根据目标主机，获取所有的node服务节点信息
            # NOTE(sbauza): Unset the host to make sure we call the scheduler
            host = None-----虽然形参赋值了，但是在这里把host赋值为空，让它走nova-scheduler调度
            # FIXME(sbauza): Since only Ironic driver uses more than one
            # compute per service but doesn‘t support evacuations,
            # let‘s provide the first one.
            target = nodes[0]-------选择返回Node 列表中的第一个node节点信息
            if request_spec:
                # TODO(sbauza): Hydrate a fake spec for old instances not yet
                # having a request spec attached to them (particularly true for
                # cells v1). For the moment, let‘s keep the same behaviour for
                # all the instances but provide the destination only if a spec
                # is found.
                destination = objects.Destination(
                    host=target.host,
                    node=target.hypervisor_hostname
                )
                request_spec.requested_destination = destination

        return self.compute_task_api.rebuild_instance(context,
                       instance=instance,
                       new_pass=admin_password,
                       injected_files=None,
                       image_ref=None,
                       orig_image_ref=None,
                       orig_sys_metadata=None,
                       bdms=None,
                       recreate=True,
                       on_shared_storage=on_shared_storage,
                       host=host,
                       request_spec=request_spec,
                       )

D:\tran_code\nova_v1\nova\conductor\api.py-----nova rebuild和nova evacuate在compute.api.py文件中开始走这个相同的函数
    def rebuild_instance(self, context, instance, orig_image_ref, image_ref,
                         injected_files, new_pass, orig_sys_metadata,
                         bdms, recreate=False, on_shared_storage=False,
                         preserve_ephemeral=False, host=None,
                         request_spec=None, kwargs=None):
        # kwargs unused but required for cell compatibility
        self.conductor_compute_rpcapi.rebuild_instance(context,
                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,
                preserve_ephemeral=preserve_ephemeral,
                host=host,
                request_spec=request_spec)

D:\tran_code\nova_v1\nova\conductor\manager.py
    @targets_cell
    def rebuild_instance(self, context, instance, orig_image_ref, image_ref,
                         injected_files, new_pass, orig_sys_metadata,
                         bdms, recreate, on_shared_storage,
                         preserve_ephemeral=False, host=None,
                         request_spec=None):

        with compute_utils.EventReporter(context, ‘rebuild_server‘, instance.uuid):--------报告虚机的rebuild事件
            node = limits = None

            try:
                migration = objects.Migration.get_by_instance_and_status(------根据虚机的Uuid,来获取到虚机的migration表信息，如果没有找到，那么抛异常
                    context, instance.uuid, ‘accepted‘)
            except exception.MigrationNotFoundByStatus:
                LOG.debug("No migration record for the rebuild/evacuate "
                          "request.", instance=instance)
                migration = None

            # The host variable is passed in two cases:-------有两种情况，host变量是被传递的，
            # 1. rebuild - the instance.host is passed to rebuild on the----第一种是虚机的host被传递过去，要在虚机所在的主机上进行重建，这个会跳过调度器
            #       same host and bypass the scheduler *unless* a new image-----虚机重建有两种情况，一种是虚机使用原始的镜像，另一种是虚机使用非原始镜像
            #       was specified-----host主机变量下发被使用的话，并且使用原始的镜像重建，
            # 2. evacuate with specified host and force=True - the specified-----第二种情况，在指定特定的目标主机，并且强制疏散的情况下，既然是强制了，那么就会不通过调度器
            #       host is passed and is meant to bypass the scheduler.-----剩下的情况指定主机，但是不强制宕机疏散，那么host也不会被传递
            # NOTE(mriedem): This could be a lot more straight-forward if we
            # had separate methods for rebuild and evacuate...
            if host:-------指定目标主机的情况下，rebuild时，如果没有指定新的镜像，那么host会被赋予instance.host值
                # We only create a new allocation on the specified host if
                # we‘re doing an evacuate since that is a move operation.
                if host != instance.host:---------指定的目的主机与虚机的host不一样的情况下，是要进行资源申请的，如果指定的主机，与instance.host相同，那么不需要进行资源申请，
                    # If a destination host is forced for evacuate, create ---这种情景下，同一节点上进行重建，如果指定的虚机的host，宕机疏散走不到这
                    # allocations against it in Placement.
                    self._allocate_for_evacuate_dest_host(-------这个函数可用要改造
                        context, instance, host, request_spec)
            else:
                # At this point, the user is either:---此时，用户要么是
                #
                # 1. Doing a rebuild on the same host (not evacuate) and-----在相同的主机上使用新的镜像进行重建
                #    specified a new image.
                # 2. Evacuating and specified a host but are not forcing it.----指定特定的主机，进行宕机疏散，但是不强制
                #
                # In either case, the API passes host=None but sets up the----在这两种情况下，API传递host=None，但是在RequestSpec.requested_destination字段设置了特定的host
                # RequestSpec.requested_destination field for the specified
                # host.
                if not request_spec:-----没有指定request_spec的情况下，根据虚机的镜像信息，来构造image元数据，并且来构造request_spec信息
                    # NOTE(sbauza): We were unable to find an original
                    # RequestSpec object - probably because the instance is old
                    # We need to mock that the old way
                    # TODO(sbauza): Provide directly the RequestSpec object
                    # when _set_vm_state_and_notify() accepts it
                    filter_properties = {‘ignore_hosts‘: [instance.host]}-----没有指定主机的情况下，走调度，那么是需要过滤掉虚机的host的
                    # build_request_spec expects a primitive image dict
                    image_meta = nova_object.obj_to_primitive(
                        instance.image_meta)
                    request_spec = scheduler_utils.build_request_spec(
                            context, image_meta, [instance])
                    request_spec = objects.RequestSpec.from_primitives(
                        context, request_spec, filter_properties)
                elif recreate:------宕机疏散是要走这个的
                    # NOTE(sbauza): Augment the RequestSpec object by excluding----通过在RequestSpec中增加source host来排除调度器调度到它
                    # the source host for avoiding the scheduler to pick it
                    request_spec.ignore_hosts = [instance.host]--------排除掉虚机的host
                    # NOTE(sbauza): Force_hosts/nodes needs to be reset
                    # if we want to make sure that the next destination
                    # is not forced to be the original host
                    request_spec.reset_forced_destinations()
                try:
                    request_spec.ensure_project_id(instance)
                    hosts = self._schedule_instances(context, request_spec,------根据request_spec来调度选择一个虚机
                                                     [instance.uuid])
                    host_dict = hosts.pop(0)
                    host, node, limits = (host_dict[‘host‘],----已经选择好了目标主机
                                          host_dict[‘nodename‘],
                                          host_dict[‘limits‘])
                except exception.NoValidHost as ex:
                    if migration:
                        migration.status = ‘error‘
                        migration.save()
                    # Rollback the image_ref if a new one was provided (this
                    # only happens in the rebuild case, not evacuate).
                    if orig_image_ref and orig_image_ref != image_ref:
                        instance.image_ref = orig_image_ref
                        instance.save()
                    request_spec = request_spec.to_legacy_request_spec_dict()
                    with excutils.save_and_reraise_exception():
                        self._set_vm_state_and_notify(context, instance.uuid,
                                ‘rebuild_server‘,
                                {‘vm_state‘: vm_states.ERROR,
                                 ‘task_state‘: None}, ex, request_spec)
                        LOG.warning("No valid host found for rebuild",
                                    instance=instance)
                        compute_utils.add_instance_fault_from_exc(context,
                            instance, ex, sys.exc_info())
                except exception.UnsupportedPolicyException as ex:
                    if migration:
                        migration.status = ‘error‘
                        migration.save()
                    # Rollback the image_ref if a new one was provided (this
                    # only happens in the rebuild case, not evacuate).
                    if orig_image_ref and orig_image_ref != image_ref:
                        instance.image_ref = orig_image_ref
                        instance.save()
                    request_spec = request_spec.to_legacy_request_spec_dict()
                    with excutils.save_and_reraise_exception():
                        self._set_vm_state_and_notify(context, instance.uuid,
                                ‘rebuild_server‘,
                                {‘vm_state‘: vm_states.ERROR,
                                 ‘task_state‘: None}, ex, request_spec)
                        LOG.warning("Server with unsupported policy "
                                    "cannot be rebuilt", instance=instance)
                        compute_utils.add_instance_fault_from_exc(context,
                            instance, ex, sys.exc_info())

            compute_utils.notify_about_instance_usage(
                self.notifier, context, instance, "rebuild.scheduled")

            instance.availability_zone = (
                availability_zones.get_host_availability_zone(
                    context, host))

            self.compute_rpcapi.rebuild_instance(context,------这一部分开始进行虚机的重建操作
                    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,
                    preserve_ephemeral=preserve_ephemeral,
                    migration=migration,------此时传递了migration这个结构体
                    host=host, node=node, limits=limits)

D:\tran_code\nova_v1\nova\compute\rpcapi.py
    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, node=None,
            preserve_ephemeral=False, migration=None, limits=None,
            kwargs=None):
        # NOTE(danms): kwargs is only here for cells compatibility, don‘t
        # actually send it to compute
        extra = {‘preserve_ephemeral‘: preserve_ephemeral,
                 ‘migration‘: migration,
                 ‘scheduled_node‘: node,
                 ‘limits‘: limits}
        version = ‘4.5‘
        client = self.router.client(ctxt)
        if not client.can_send_version(version):
            version = ‘4.0‘
            extra.pop(‘migration‘)
            extra.pop(‘scheduled_node‘)
            extra.pop(‘limits‘)
        cctxt = client.prepare(server=_compute_host(host, instance),------把消息的目标地址更改一下，host 主机的参数在这里使用了,没有下发到后续的函数中，作为形参
                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)

D:\tran_code\nova_v1\nova\compute\manager.py
    def rebuild_instance(self, context, instance, orig_image_ref, image_ref,
                         injected_files, new_pass, orig_sys_metadata,
                         bdms, recreate, on_shared_storage=None,
                         preserve_ephemeral=False, migration=None,
                         scheduled_node=None, limits=None):
        """Destroy and re-make this instance.-----销毁这台虚机并且重新制作这台虚机

        A ‘rebuild‘ effectively purges all existing data from the system and-----重建操作有效的清除来自系统的所有数据，使用给定的metadata和个性信息来重建虚机
        remakes the VM with given ‘metadata‘ and ‘personalities‘.

        :param context: `nova.RequestContext` object
        :param instance: Instance object
        :param orig_image_ref: Original image_ref before rebuild----重建之前的原始镜像引用
        :param image_ref: New image_ref for rebuild-----用于重建的新镜像
        :param injected_files: Files to inject-----注入的文件
        :param new_pass: password to set on rebuilt instance
        :param orig_sys_metadata: instance system metadata from pre-rebuild-----用于重建之前的原始系统数据
        :param bdms: block-device-mappings to use for rebuild----用于重建的块设备映射
        :param recreate: True if the instance is being recreated (e.g. the
            hypervisor it was on failed) - cleanup of old state will be
            skipped.
        :param on_shared_storage: True if instance files on shared storage.
                                  If not provided then information from the
                                  driver will be used to decide if the instance
                                  files are available or not on the target host
        :param preserve_ephemeral: True if the default ephemeral storage
                                   partition must be preserved on rebuild
        :param migration: a Migration object if one was created for this
                          rebuild operation (if it‘s a part of evacuate)
        :param scheduled_node: A node of the host chosen by the scheduler. If a-------调度器选择的node,这个node是Hyperversor node;如果一个主机被用户指定了，那么这个node设置为空
                               host was specified by the user, this will be
                               None
        :param limits: Overcommit limits set by the scheduler. If a host was------被scheduler设置的超额提交限制。如果用户指定了一个特定的主机，那么这个值为空
                       specified by the user, this will be None
        """
        context = context.elevated()

        LOG.info("Rebuilding instance", instance=instance)

        if recreate:-----这是一个宕机疏散到新的host上，因此我们需要执行一个资源链
            # This is an evacuation to a new host, so we need to perform a
            # resource claim.
            rt = self._get_resource_tracker()-----对目标主机进行资源追踪
            rebuild_claim = rt.rebuild_claim
        else:-----在相同主机上的重建操作，因此不需要在已有的主机上执行claim资源跟踪
            # This is a rebuild to the same host, so we don‘t need to make
            # a claim since the instance is already on this host.
            rebuild_claim = claims.NopClaim

        image_meta = {}
        if image_ref:
            image_meta = self.image_api.get(context, image_ref)

        # NOTE(mriedem): On a recreate (evacuate), we need to update------在重建（宕机疏散），我们需要更新虚机的host和node，来反映它要重新创建的目标节点
        # the instance‘s host and node properties to reflect it‘s
        # destination node for the recreate.
        if not scheduled_node:------如果Node为空的话，这两种情景，使用相同的镜像在vm.host上重建或者指定固定节点并且强制宕机疏散
            if recreate:
                try:
                    compute_node = self._get_compute_info(context, self.host)-------这个地方需要改造，在指定节点并且强制宕机疏散的情况下
                    scheduled_node = compute_node.hypervisor_hostname
                except exception.ComputeHostNotFound:
                    LOG.exception(‘Failed to get compute_info for %s‘,
                                  self.host)
            else:
                scheduled_node = instance.node----对重建的话，直接把它的node赋值给scheduled_node

        with self._error_out_instance_on_exception(context, instance):
            try:
                claim_ctxt = rebuild_claim(
                    context, instance, scheduled_node,
                    limits=limits, image_meta=image_meta,
                    migration=migration)
                self._do_rebuild_instance_with_claim(--------对这个步骤斤进行重点看s1
                    claim_ctxt, context, instance, orig_image_ref,
                    image_ref, injected_files, new_pass, orig_sys_metadata,
                    bdms, recreate, on_shared_storage, preserve_ephemeral,
                    migration)
            except exception.ComputeResourcesUnavailable as e:
                LOG.debug("Could not rebuild instance on this host, not "
                          "enough resources available.", instance=instance)

                # NOTE(ndipanov): We just abort the build for now and leave a
                # migration record for potential cleanup later
                self._set_migration_status(migration, ‘failed‘)
                # Since the claim failed, we need to remove the allocation
                # created against the destination node. Note that we can only
                # get here when evacuating to a destination node. Rebuilding
                # on the same host (not evacuate) uses the NopClaim which will
                # not raise ComputeResourcesUnavailable.
                rt.delete_allocation_for_evacuated_instance(
                    instance, scheduled_node, node_type=‘destination‘)
                self._notify_instance_rebuild_error(context, instance, e)

                raise exception.BuildAbortException(
                    instance_uuid=instance.uuid, reason=e.format_message())
            except (exception.InstanceNotFound,
                    exception.UnexpectedDeletingTaskStateError) as e:
                LOG.debug(‘Instance was deleted while rebuilding‘,
                          instance=instance)
                self._set_migration_status(migration, ‘failed‘)
                self._notify_instance_rebuild_error(context, instance, e)
            except Exception as e:
                self._set_migration_status(migration, ‘failed‘)
                self._notify_instance_rebuild_error(context, instance, e)
                raise
            else:-----else存在的意义是，执行只有在try代码块没有异常发生时才需要执行的代码，而如果在执行try代码块时捕获了异常就不执行这个else代码块了
                instance.apply_migration_context()
                # NOTE (ndipanov): This save will now update the host and node
                # attributes making sure that next RT pass is consistent since
                # it will be based on the instance and not the migration DB
                # entry.
                instance.host = self.host------主要是更新一些数据库表的字段信息
                instance.node = scheduled_node
                instance.save()
                instance.drop_migration_context()

                # NOTE (ndipanov): Mark the migration as done only after we
                # mark the instance as belonging to this host.
                self._set_migration_status(migration, ‘done‘)----主要是更新migration表里面的信息

    def _do_rebuild_instance_with_claim(self, claim_context, *args, **kwargs):
        """Helper to avoid deep nesting in the top-level method."""

        with claim_context:
            self._do_rebuild_instance(*args, **kwargs)


    def _do_rebuild_instance(self, context, instance, orig_image_ref,
                             image_ref, injected_files, new_pass,
                             orig_sys_metadata, bdms, recreate,
                             on_shared_storage, preserve_ephemeral,
                             migration):
        orig_vm_state = instance.vm_state

        if recreate:------这个是宕机疏散逻辑
            if not self.driver.capabilities["supports_recreate"]:----这个功能属性是要增加的
                raise exception.InstanceRecreateNotSupported

            self._check_instance_exists(context, instance)----检查虚机是不是在对应的driver上已经不存在，如果存在的话，抛出异常，没有存在，则往下执行

            if on_shared_storage is None:----如果 on_shared_storage 设置为空，那么通过驱动取判断虚机是否为共享存储
                LOG.debug(‘on_shared_storage is not provided, using driver‘
                            ‘information to decide if the instance needs to‘
                            ‘be recreated‘)
                on_shared_storage = self.driver.instance_on_disk(instance)

            elif (on_shared_storage !=-----为了解决管理员希望实例文件在共享存储上，但不能访问的情况，反之亦然，
                    self.driver.instance_on_disk(instance)):
                # To cover case when admin expects that instance files are
                # on shared storage, but not accessible and vice versa
                raise exception.InvalidSharedStorage(
                        _("Invalid state of instance files on shared"
                            " storage"))

            if on_shared_storage:-----共享存储的话，那么使用存在的盘，这里的共享存储，包括使用共享卷或者共享的目录
                LOG.info(‘disk on shared storage, recreating using‘
                         ‘ existing disk‘)
            else:-----非共享存储，获取虚机的镜像信息引用
                image_ref = orig_image_ref = instance.image_ref
                LOG.info("disk not on shared storage, rebuilding from:"
                         " ‘%s‘", str(image_ref))

        if image_ref:-------如果能从虚机的数据里面获取到镜像信息引用的话，那么就从glance中获取该新镜像的元数据
            image_meta = objects.ImageMeta.from_image_ref(
                context, self.image_api, image_ref)
        else:
            image_meta = instance.image_meta----没有从虚机的数据里面获取到镜像信息引用的话，那么表示使用原始的镜像，

        # This instance.exists message should contain the original
        # image_ref, not the new one.  Since the DB has been updated
        # to point to the new one... we have to override it.
        # TODO(jaypipes): Move generate_image_url() into the nova.image.api
        orig_image_ref_url = glance.generate_image_url(orig_image_ref)-------instance中存在的信息应该包含的是原始的镜像引用，而不是新的镜像引用。
        extra_usage_info = {‘image_ref_url‘: orig_image_ref_url}-----所以数据库中应该更新指到新的镜像引用。我们不得不覆盖它
        compute_utils.notify_usage_exists(----通知信息，不重要，忽略
                self.notifier, context, instance,
                current_period=True, system_metadata=orig_sys_metadata,
                extra_usage_info=extra_usage_info)

        # This message should contain the new image_ref
        extra_usage_info = {‘image_name‘: self._get_image_name(image_meta)}
        self._notify_about_instance_usage(context, instance,
                "rebuild.start", extra_usage_info=extra_usage_info)
        # NOTE: image_name is not included in the versioned notification
        # because we already provide the image_uuid in the notification
        # payload and the image details can be looked up via the uuid.
        compute_utils.notify_about_instance_action(
            context, instance, self.host,
            action=fields.NotificationAction.REBUILD,
            phase=fields.NotificationPhase.START)

        instance.power_state = self._get_power_state(context, instance)
        instance.task_state = task_states.REBUILDING
        instance.save(expected_task_state=[task_states.REBUILDING])

        if recreate:------宕机疏散的逻辑，设置虚机的网络状态，这是在不同的主机上执行的
            self.network_api.setup_networks_on_host(
                    context, instance, self.host)
            # For nova-network this is needed to move floating IPs
            # For neutron this updates the host in the port binding
            # TODO(cfriesen): this network_api call and the one above
            # are so similar, we should really try to unify them.
            self.network_api.setup_instance_network_on_host(
                    context, instance, self.host, migration)
            # TODO(mriedem): Consider decorating setup_instance_network_on_host
            # with @base_api.refresh_cache and then we wouldn‘t need this
            # explicit call to get_instance_nw_info.
            network_info = self.network_api.get_instance_nw_info(context,
                                                                 instance)
        else:
            network_info = instance.get_network_info()----因为rebuild是在相同的主机上rebuild,所以直接获取虚机表里的内容即可

        if bdms is None:----如果bdms参数为空，则从数据库中，获取虚机的块设备bdm信息
            bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(
                    context, instance.uuid)

        block_device_info = \----根据块设备的bdm信息，获取虚机块设备信息
            self._get_instance_block_device_info(
                    context, instance, bdms=bdms)

        def detach_block_devices(context, bdms):-----如果虚机的bdm是卷的话，那么需要进行解挂
            for bdm in bdms:
                if bdm.is_volume:
                    self._detach_volume(context, bdm, instance,
                                        destroy_bdm=False)

        files = self._decode_files(injected_files)----对注入的文件进行解码

        kwargs = dict(
            context=context,
            instance=instance,
            image_meta=image_meta,
            injected_files=files,
            admin_password=new_pass,
            bdms=bdms,
            detach_block_devices=detach_block_devices,
            attach_block_devices=self._prep_block_device,
            block_device_info=block_device_info,
            network_info=network_info,
            preserve_ephemeral=preserve_ephemeral,
            recreate=recreate)
        try:
            with instance.mutated_migration_context():
                self.driver.rebuild(**kwargs)------各个驱动函数都没有实现这个函数，都是执行了下面的
        except NotImplementedError:
            # NOTE(rpodolyaka): driver doesn‘t provide specialized version
            # of rebuild, fall back to the default implementation
            self._rebuild_default_impl(**kwargs)-----各种类型的驱动都使用了这个函数
        self._update_instance_after_spawn(context, instance)-----更新数据库表的一些信息
        instance.save(expected_task_state=[task_states.REBUILD_SPAWNING])

        if orig_vm_state == vm_states.STOPPED:
            LOG.info("bringing vm to original state: ‘%s‘",
                     orig_vm_state, instance=instance)
            instance.vm_state = vm_states.ACTIVE
            instance.task_state = task_states.POWERING_OFF
            instance.progress = 0
            instance.save()
            self.stop_instance(context, instance, False)
        self._update_scheduler_instance_info(context, instance)----更新相关数据表的信息
        self._notify_about_instance_usage(
                context, instance, "rebuild.end",
                network_info=network_info,
                extra_usage_info=extra_usage_info)
        compute_utils.notify_about_instance_action(
            context, instance, self.host,
            action=fields.NotificationAction.REBUILD,
            phase=fields.NotificationPhase.END)


    def _rebuild_default_impl(self, context, instance, image_meta,
                              injected_files, admin_password, bdms,
                              detach_block_devices, attach_block_devices,
                              network_info=None,
                              recreate=False, block_device_info=None,
                              preserve_ephemeral=False):
        if preserve_ephemeral:
            # The default code path does not support preserving ephemeral
            # partitions.
            raise exception.PreserveEphemeralNotSupported()

        if recreate:------要是宕机疏散的话，那么需要把块设备进行卸载，recreate的话，那么指定是非vm的host的值，所以不用销毁，直接生成新的虚机即可
            detach_block_devices(context, bdms)
        else:
            self._power_off_instance(context, instance, clean_shutdown=True)----在相同的节点上重建的话
            detach_block_devices(context, bdms)----先卸载虚机的块设备，然后把虚机的销毁
            self.driver.destroy(context, instance,
                                network_info=network_info,
                                block_device_info=block_device_info)

        instance.task_state = task_states.REBUILD_BLOCK_DEVICE_MAPPING
        instance.save(expected_task_state=[task_states.REBUILDING])

        new_block_device_info = attach_block_devices(context, instance, bdms)----把虚机的块设备挂载新的主机上

        instance.task_state = task_states.REBUILD_SPAWNING
        instance.save(
            expected_task_state=[task_states.REBUILD_BLOCK_DEVICE_MAPPING])

        with instance.mutated_migration_context():
            self.driver.spawn(context, instance, image_meta, injected_files,-----然后创建新的虚机
                              admin_password, network_info=network_info,
                              block_device_info=new_block_device_info)