nova分析（8）—— nova-compute

nova-compute是管理和配置虚拟机的入口，在所有compute机器上都需要该服务来创建和管理虚拟机。

nova-compute服务的入口在 nova.cmd.compute:main ，其启动过程与其他nova服务类似。

简单看下它是如何启动的， binary='nova-compute', topic='nova.compute.rpcapi' ,  manager=nova.compute.manager.ComputeManager ，manager类在初始化的时候会创建与其他服务交互的api实例：

class ComputeManager(manager.Manager):
    """Manages the running instances from creation to destruction."""

    target = messaging.Target(version='3.32')

    def __init__(self, compute_driver=None, *args, **kwargs):
        """Load configuration options and connect to the hypervisor."""
        self.virtapi = ComputeVirtAPI(self)
        self.network_api = network.API()
        self.volume_api = volume.API()
        self.image_api = image.API()
        self._last_host_check = 0
        self._last_bw_usage_poll = 0
        self._bw_usage_supported = True
        self._last_bw_usage_cell_update = 0
        self.compute_api = compute.API()
        self.compute_rpcapi = compute_rpcapi.ComputeAPI()
        self.conductor_api = conductor.API()
        self.compute_task_api = conductor.ComputeTaskAPI()
        self.is_neutron_security_groups = (
            openstack_driver.is_neutron_security_groups())
        self.consoleauth_rpcapi = consoleauth.rpcapi.ConsoleAuthAPI()
        self.cells_rpcapi = cells_rpcapi.CellsAPI()
        self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()
        self._resource_tracker_dict = {}
        self.instance_events = InstanceEvents()

        super(ComputeManager, self).__init__(service_name="compute",
                                             *args, **kwargs)

        # NOTE(russellb) Load the driver last.  It may call back into the
        # compute manager via the virtapi, so we want it to be fully
        # initialized before that happens.
        self.driver = driver.load_compute_driver(self.virtapi, compute_driver)   ＃libvirt.LibvirtDriver
        self.use_legacy_block_device_info = \
                            self.driver.need_legacy_block_device_info

在service.start()中会初始化主机上的虚拟机和安全组，并开启RPC服务

    def start(self):
        verstr = version.version_string_with_package()
        LOG.audit(_('Starting %(topic)s node (version %(version)s)'),
                  {'topic': self.topic, 'version': verstr})
        self.basic_config_check()
        # Initialization for a standalone compute service
        # init instances and iptables
        self.manager.init_host()
        self.model_disconnected = False
        ctxt = context.get_admin_context()
        try: # init conductor api
            self.service_ref = self.conductor_api.service_get_by_args(ctxt,
                    self.host, self.binary)
            self.service_id = self.service_ref['id']
        except exception.NotFound:
            try:
                self.service_ref = self._create_service_ref(ctxt)
            except (exception.ServiceTopicExists,
                    exception.ServiceBinaryExists):
                # NOTE(danms): If we race to create a record with a sibling
                # worker, don't fail here.
                self.service_ref = self.conductor_api.service_get_by_args(ctxt,
                    self.host, self.binary)

        """After the service is initialized, but before we fully bring
        the service up by listening on RPC queues, make sure to update
        our available resources (and indirectly our available nodes).
        """
        self.manager.pre_start_hook()

        if self.backdoor_port is not None:
            self.manager.backdoor_port = self.backdoor_port

        LOG.debug("Creating RPC server for service %s", self.topic)

        # start rpc api
        target = messaging.Target(topic=self.topic, server=self.host)

        endpoints = [
            self.manager,
            baserpc.BaseRPCAPI(self.manager.service_name, self.backdoor_port)
        ]
        endpoints.extend(self.manager.additional_endpoints)

        serializer = objects_base.NovaObjectSerializer()

        self.rpcserver = rpc.get_server(target, endpoints, serializer)
        self.rpcserver.start()

        self.manager.post_start_hook()

        LOG.debug("Join ServiceGroup membership for this service %s",
                  self.topic)
        # Add service to the ServiceGroup membership group.
        self.servicegroup_api.join(self.host, self.topic, self)

        if self.periodic_enable:
            if self.periodic_fuzzy_delay:
                initial_delay = random.randint(0, self.periodic_fuzzy_delay)
            else:
                initial_delay = None

            self.tg.add_dynamic_timer(self.periodic_tasks,
                                     initial_delay=initial_delay,
                                     periodic_interval_max=
                                        self.periodic_interval_max)

这样，nova-compute服务就起来了，而之后接收到的请求都会到 nova.compute.manager.ComputeManager 类来处理。

最常使用的KVM虚拟化需要配置driver为libvirt.LibvirtDriver（所有支持的driver有 libvirt.LibvirtDriver, xenapi.XenAPIDriver, fake.FakeDriver, baremetal.BareMetalDriver, vmwareapi.VMwareVCDriver, hyperv.HyperVDriver）.

下面来看看libvirt是如何创建虚拟机的：

   def spawn(self, context, instance, image_meta, injected_files,
              admin_password, network_info=None, block_device_info=None):
        disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,
                                            instance,
                                            block_device_info,
                                            image_meta)
        # 获取镜像信息
        self._create_image(context, instance,
                           disk_info['mapping'],
                           network_info=network_info,
                           block_device_info=block_device_info,
                           files=injected_files,
                           admin_pass=admin_password)
        # 生成libvirt配置文件格式的XML
        xml = self._get_guest_xml(context, instance, network_info,
                                  disk_info, image_meta,
                                  block_device_info=block_device_info,
                                  write_to_disk=True)
        # 创建卷、网络，并创建虚拟机
        self._create_domain_and_network(context, xml, instance, network_info,
                                        block_device_info)
        LOG.debug("Instance is running", instance=instance)

        def _wait_for_boot():
            """Called at an interval until the VM is running."""
            state = self.get_info(instance)['state']

            if state == power_state.RUNNING:
                LOG.info(_LI("Instance spawned successfully."),
                         instance=instance)
                raise loopingcall.LoopingCallDone()
        # 等待虚拟机状态变为RUNNING
        timer = loopingcall.FixedIntervalLoopingCall(_wait_for_boot)
        timer.start(interval=0.5).wait()

_create_domain_and_network为实际的创建设备和创建虚拟机函数

   def _create_domain_and_network(self, context, xml, instance, network_info,
                                   block_device_info=None, power_on=True,
                                   reboot=False, vifs_already_plugged=False):

        """Do required network setup and create domain."""
        # 查询卷的映射关系
        block_device_mapping = driver.block_device_info_get_mapping(
            block_device_info)
        # 挂载卷
        for vol in block_device_mapping:
            connection_info = vol['connection_info']
            disk_info = blockinfo.get_info_from_bdm(
                CONF.libvirt.virt_type, vol)
            # 根据volume类型，调用其connect_volume方法挂载卷
            # 支持的类型包括：
            #     [
            #       'iscsi=nova.virt.libvirt.volume.LibvirtISCSIVolumeDriver',
            #       'iser=nova.virt.libvirt.volume.LibvirtISERVolumeDriver',
            #       'local=nova.virt.libvirt.volume.LibvirtVolumeDriver',
            #       'fake=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver',
            #       'rbd=nova.virt.libvirt.volume.LibvirtNetVolumeDriver',
            #       'sheepdog=nova.virt.libvirt.volume.LibvirtNetVolumeDriver',
            #       'nfs=nova.virt.libvirt.volume.LibvirtNFSVolumeDriver',
            #       'aoe=nova.virt.libvirt.volume.LibvirtAOEVolumeDriver',
            #       'glusterfs='nova.virt.libvirt.volume.LibvirtGlusterfsVolumeDriver',
            #       'fibre_channel=nova.virt.libvirt.volume.LibvirtFibreChannelVolumeDriver',
            #       'scality=nova.virt.libvirt.volume.LibvirtScalityVolumeDriver',
            #     ]
            conf = self._connect_volume(connection_info, disk_info)

            # cache device_path in connection_info -- required by encryptors
            if 'data' in connection_info:
                connection_info['data']['device_path'] = conf.source_path
                vol['connection_info'] = connection_info
                vol.save(context)

            # 如果是加密卷，需要attach到encryptor
            if (not reboot and 'data' in connection_info and
                    'volume_id' in connection_info['data']):
                volume_id = connection_info['data']['volume_id']
                encryption = encryptors.get_encryption_metadata(
                    context, self._volume_api, volume_id, connection_info)

                if encryption:
                    encryptor = self._get_volume_encryptor(connection_info,
                                                           encryption)
                    encryptor.attach_volume(context, **encryption)

        timeout = CONF.vif_plugging_timeout
        if (self._conn_supports_start_paused and
            utils.is_neutron() and not
            vifs_already_plugged and power_on and timeout):
            events = self._get_neutron_events(network_info)
        else:
            events = []

        launch_flags = events and libvirt.VIR_DOMAIN_START_PAUSED or 0
        domain = None
        try:
            with self.virtapi.wait_for_instance_event(
                    instance, events, deadline=timeout,
                    error_callback=self._neutron_failed_callback):
                # Plug VIFs into networks using vif_driver
                self.plug_vifs(instance, network_info)
                # Init iptables using firewall_driver
                self.firewall_driver.setup_basic_filtering(instance,
                                                           network_info)
                self.firewall_driver.prepare_instance_filter(instance,
                                                             network_info)
                # 调用libvirt库提供的方法创建虚拟机
                # if xml:
                #     err = _LE('Error defining a domain with XML: %s') % xml
                #     domain = self._conn.defineXML(xml)

                # if power_on:
                #     err = _LE('Error launching a defined domain with XML: %s') \
                #               % domain.XMLDesc(0)
                #     domain.createWithFlags(launch_flags)
                domain = self._create_domain(
                    xml, instance=instance,
                    launch_flags=launch_flags,
                    power_on=power_on)

                self.firewall_driver.apply_instance_filter(instance,
                                                           network_info)
        except exception.VirtualInterfaceCreateException:
            # Neutron reported failure and we didn't swallow it, so
            # bail here
            with excutils.save_and_reraise_exception():
                if domain:
                    domain.destroy()
                self.cleanup(context, instance, network_info=network_info,
                             block_device_info=block_device_info)
        except eventlet.timeout.Timeout:
            # We never heard from Neutron
            LOG.warn(_LW('Timeout waiting for vif plugging callback for '
                         'instance %(uuid)s'), {'uuid': instance['uuid']})
            if CONF.vif_plugging_is_fatal:
                if domain:
                    domain.destroy()
                self.cleanup(context, instance, network_info=network_info,
                             block_device_info=block_device_info)
                raise exception.VirtualInterfaceCreateException()

        # Resume only if domain has been paused
        if launch_flags & libvirt.VIR_DOMAIN_START_PAUSED:
            domain.resume()
        return domain