上篇兩篇文章分析了Nova Scheduler服務，這篇文章我們繼續來分析建立虛擬機器的過程。先來回顧一下。

class FilterScheduler(driver.Scheduler):
    def scheduler_run_instance(self, context, request_spec,
                               admin_password, injected_files,
                               requested_networks, is_first_time,
                               filter_properties):
        #獲取排程所需引數
        payload = dict(request_spec=request_spec)
        #通知Nova API開始排程
        notifier.notify(context, notifier.publisher_id("scheduler"),
                        'scheduler.run_instance.start', notifier.INFO, notifier.INFO,
                        payload)
        ...
        #執行排程演算法，獲取加權主機列表
        weighted_hosts = self._schedule(context, "compute", request_spec,
                                        filter_properties, instance_uuids)
        ...
        #為每個虛擬機器分配計算節點
        for num, instance_uuid in enumerate(instance_uuids):
            ...
            try:
                try:
                    #選擇權值最高的計算節點
                    weighted_host = weighted_hosts.pop(0)
                except IndexError:
                    raise exception.NoValidHost(reason="")
                #在權值最高的計算節點上建立虛擬機器
                self._provision_resource(context, weighted_host,
                                         request_spec,
                                         filter_properties,
                                         requested_networks,
                                         injected_files, admin_password,
                                         is_first_time,
                                         instance_uuid=instance_uuid)
            except Exception as ex:
                ...
        #通知Nova API虛擬機器排程完畢
        notifier.notify(context, notifier.publisher_id("scheduler"),
                        'scheduler.run_instance.end', notifier.INFO, payload)
 

這個方法的前半部分（_scheduler方法）我們已經在“Nova Scheduler排程演算法”中分析過，我們繼續來看該方法的後半部分。

_provision_resource方法

class FilterScheduler(driver.Scheduler):
    def _provision_resource(self, context, weighed_host, ...):
        ...
        self.compute_rpcapi.run_instance(context, instance=updated_instance, ...)

該方法在權值最高的計算節點上建立虛擬機器，遠端呼叫了Nova Compute服務的run_instance方法，這個方法位於nova/nova/compute/rpcapi.py。

class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
    def run_instance(self, ctxt, instance, ...):
        ...
        self.cast(ctxt, self.make_msg('run_instance',intance=instance_p, ...),
                                      topic=_compute_topic(self.topic, ctxt, host ,None),
                                      ...)
 

可以看到，該方法會呼叫cast方法向Nova Compute服務傳送RPC請求。

和其它服務類似，在Nova Compute服務中，處理RPC請求的方法都定義在Nova Compute服務的manager類中，該類位於nova/nova/compute/manager.py。來看一下這個類下的run_instance方法。

class ComputeManager(manager.SchedulerDependentManager):
    def run_instance(self, context, instance, request_spec=None,
                     filter_properties=None, requested_networks=None,
                     injected_files=None, admin_password=None,
                     is_first_time=False, node=None):
        ...
        @lockutils.synchronized(instance['uuid'], 'nova-')
        def do_run_instance():
            self._run_instance(context, request_spec,
                    filter_properties, requested_networks, injected_files,
                    admin_password, is_first_time, node, instance)
        do_run_instance()

可以看到這個方法定義了一個內部方法do_run_instance，do_run_instance內部方法的主要作用是加了一個鎖，這個鎖的目的是保證同一個虛擬機器在同一時刻只能執行一個任務。在這個方法內部，呼叫了_run_instance方法來實現虛擬機器的建立。來看一下_run_instance方法

class ComputeManager(manager.SchedulerDependentManager):
    def _run_instance(self, context, request_spec,
                      filter_properties, requested_networks, injected_files,
                      admin_password, is_first_time, node, instance):
        ...
        try:
            #檢查虛擬機器是否存在
            self._check_instance_exists(context, instance)
            #更新資料庫中虛擬機器的狀態
            try:
                self._start_building(context, instance)
            except exception.InstanceNotFound:
                ...
            #檢查磁碟映象大小
            image_meta = self._check_image_size(context, instance)
            #選擇執行虛擬機器的節點
            if node is None:
                node = self.driver.get_available_nodes()[0]
            ...
            rt = self._get_resource_tracker(node)
            try:
                limits = filter_properties.get('limits', {})
                #為虛擬機器預留磁碟、記憶體、CPU等硬體資源
                with rt.instance_claim(context, instance, limits):
                    #獲取虛擬機器的MAC地址的約束
                    macs = self.driver.macs_for_instance(instance)
                    #為虛擬機器分配網路
                    network_info = self._allocate_network(context, instance,
                            requested_networks, macs, security_groups)
                    ...
                    #呼叫_spawn方法，進一步處理虛擬機器的建立請求
                    instance = self._spawn(context, instance, image_meta,
                                           network_info, block_device_info,
                                           injected_files, admin_password,
                                           set_access_ip=set_access_ip)
            except exception.InstanceNotFound:
                #虛擬機器在建立過程中被刪除
                with excutils.save_and_reraise_exception():
                    try:
                        #釋放分配的網路資源
                        self._deallocate_network(context, instance)
                    except Exception:
                        ...
            except exception.UnexpectedTaskStateError as e:
                ...
            except Exception:
                exc_info = sys.exc_info()
                #請求重新執行排程演算法
                self._reschedule_or_reraise(context, instance, exc_info, ...)
        expect Expection:
            ...

這個方法首先完成虛擬機器建立前的一些準備工作，然後呼叫_spawn方法做進一步的處理。

我們先來分析一下這所謂的建立前的一些準備工作，主要分下面四步進行

1. 檢查要建立的虛擬機器的uuid是否被佔用

2. 更新Nova資料庫中虛擬機器的狀態，主要是更新vm_state和task_state這兩個欄位的值

3. 檢查虛擬機器的映象檔案大小是否超出虛擬機器規格的限制

4. 選擇一個可用的計算節點作為執行虛擬機器的節點，併為虛擬機器預留硬體資源

_spawn方法涉及的內容較多，我們放在下篇文章來分析~~