nova-api
nova-api-ec2
nova-api-metadata
nova-api-os-compute 

    launcher = service.process_launcher()    for api in CONF.enabled_apis:        should_use_ssl = api in CONF.enabled_ssl_apis        if api == ‘ec2‘:            server = service.WSGIService(api, use_ssl=should_use_ssl,                                         max_url_len=16384)        else:            server = service.WSGIService(api, use_ssl=should_use_ssl)        launcher.launch_service(server, workers=server.workers or 1)    launcher.wait()

def _start_child(self, wrap):        if len(wrap.forktimes) > wrap.workers:            # Limit ourselves to one process a second (over the period of            # number of workers * 1 second). This will allow workers to            # start up quickly but ensure we don‘t fork off children that            # die instantly too quickly.            if time.time() - wrap.forktimes[0] < wrap.workers:                LOG.info(_LI(‘Forking too fast, sleeping‘))                time.sleep(1)            wrap.forktimes.pop(0)        wrap.forktimes.append(time.time())        pid = os.fork()        if pid == 0:            # create a green thread to run child            # 实际上最终调用的service的start/wait方法            launcher = self._child_process(wrap.service)            while True:                self._child_process_handle_signal()                status, signo = self._child_wait_for_exit_or_signal(launcher)                if not _is_sighup_and_daemon(signo):                    break                launcher.restart()            os._exit(status)        LOG.info(_LI(‘Started child %d‘), pid)        wrap.children.add(pid)        self.children[pid] = wrap        return pid    def launch_service(self, service, workers=1):        wrap = ServiceWrapper(service, workers)        LOG.info(_LI(‘Starting %d workers‘), wrap.workers)        while self.running and len(wrap.children) < wrap.workers:            self._start_child(wrap)

class WSGIService(object):    """Provides ability to launch API from a ‘paste‘ configuration."""    def __init__(self, name, loader=None, use_ssl=False, max_url_len=None):        """Initialize, but do not start the WSGI server.        :param name: The name of the WSGI server given to the loader.        :param loader: Loads the WSGI application using the given name.        :returns: None        """        self.name = name        # 根据self.name从配置文件中获取manager，若有则实例化对应的manager        self.manager = self._get_manager()        self.loader = loader or wsgi.Loader()        # 通过paste.deploy加载app，对应配置文件为api-paste.ini        self.app = self.loader.load_app(name)        self.host = getattr(CONF, ‘%s_listen‘ % name, "0.0.0.0")        self.port = getattr(CONF, ‘%s_listen_port‘ % name, 0)        self.workers = (getattr(CONF, ‘%s_workers‘ % name, None) or                        processutils.get_worker_count())        if self.workers and self.workers < 1:            worker_name = ‘%s_workers‘ % name            msg = (_("%(worker_name)s value of %(workers)s is invalid, "                     "must be greater than 0") %                   {‘worker_name‘: worker_name,                    ‘workers‘: str(self.workers)})            raise exception.InvalidInput(msg)        self.use_ssl = use_ssl        self.server = wsgi.Server(name,                                  self.app,                                  host=self.host,                                  port=self.port,                                  use_ssl=self.use_ssl,                                  max_url_len=max_url_len)        # Pull back actual port used        self.port = self.server.port        self.backdoor_port = None

# 这儿是整个api的入口，将不同版本转发到compiste处理[composite:osapi_compute]use = call:nova.api.openstack.urlmap:urlmap_factory/: oscomputeversions/v1.1: openstack_compute_api_v2/v2: openstack_compute_api_v2/v3: openstack_compute_api_v3# 比如v3版本api在这儿处理，在使用keystone配置时，要经过request_id faultwrap sizelimit authtoken keystonecontext这些filter的处理最后再交给osapi_compute_app_v3这个app来处理# 注意这些filter的顺序：先把前n-1个filter逆序，然后逐个应用到app上[composite:openstack_compute_api_v3]use = call:nova.api.auth:pipeline_factory_v3noauth = request_id faultwrap sizelimit noauth_v3 osapi_compute_app_v3keystone = request_id faultwrap sizelimit authtoken keystonecontext osapi_compute_app_v3# filter部分定义了这个filter由哪个类来处理[filter:request_id]paste.filter_factory = nova.openstack.common.middleware.request_id:RequestIdMiddleware.factory[filter:compute_req_id]paste.filter_factory = nova.api.compute_req_id:ComputeReqIdMiddleware.factory[filter:faultwrap]paste.filter_factory = nova.api.openstack:FaultWrapper.factory[filter:noauth]paste.filter_factory = nova.api.openstack.auth:NoAuthMiddleware.factory[filter:noauth_v3]paste.filter_factory = nova.api.openstack.auth:NoAuthMiddlewareV3.factory[filter:ratelimit]paste.filter_factory = nova.api.openstack.compute.limits:RateLimitingMiddleware.factory[filter:sizelimit]paste.filter_factory = nova.api.sizelimit:RequestBodySizeLimiter.factory# 这儿是v3的处理app，即APIRouterV3.factory[app:osapi_compute_app_v3]paste.app_factory = nova.api.openstack.compute:APIRouterV3.factory

        # 初始化api_extension_manager并加载所有的API_EXTENSION_NAMESPACE对应的extensions。        # 这儿加载的就是setup.cfg中配置的nova.api.v3.extensions部分，比如：        #   nova.api.v3.extensions =        #       access_ips = nova.api.openstack.compute.plugins.v3.access_ips:AccessIPs        #       admin_actions = nova.api.openstack.compute.plugins.v3.admin_actions:AdminActions        #       admin_password = nova.api.openstack.compute.plugins.v3.admin_password:AdminPassword        #       agents = nova.api.openstack.compute.plugins.v3.agents:Agents        #       ...        # 当然如果有第三方的应用也声明了此namespace的extension，这里也会一并load进来。        # 其中的check_func为check_load_extension,其所作的工作主要包括：        #   a) 检测是否为相V3APIExtensionBase类型        #   b) extension的黑白名单过滤和验证        self.api_extension_manager = stevedore.enabled.EnabledExtensionManager(            namespace=self.API_EXTENSION_NAMESPACE, # ‘nova.api.v3.extensions‘            check_func=_check_load_extension,            invoke_on_load=True,            invoke_kwds={"extension_info": self.loaded_extension_info})        mapper = PlainMapper()        self.resources = {}        # NOTE(cyeoh) Core API support is rewritten as extensions        # but conceptually still have core        if list(self.api_extension_manager):            # NOTE(cyeoh): Stevedore raises an exception if there are            # no plugins detected. I wonder if this is a bug.            # Extensions define what resources they want to add through a get_resources function            self.api_extension_manager.map(self._register_resources,                                           mapper=mapper)            # Extensions define what resources they want to add through            # a get_controller_extensions function            self.api_extension_manager.map(self._register_controllers)        # 检测core extensions是否全部加载成功        missing_core_extensions = self.get_missing_core_extensions(            self.loaded_extension_info.get_extensions().keys())        if not self.init_only and missing_core_extensions:            LOG.critical(_("Missing core API extensions: %s"),                         missing_core_extensions)            raise exception.CoreAPIMissing(                missing_apis=missing_core_extensions)

class Servers(extensions.V3APIExtensionBase):    """Servers."""    name = "Servers"    alias = "servers"    version = 1    def get_resources(self):        member_actions = {‘action‘: ‘POST‘}        collection_actions = {‘detail‘: ‘GET‘}        resources = [            extensions.ResourceExtension(                ‘servers‘,                ServersController(extension_info=self.extension_info),                member_name=‘server‘, collection_actions=collection_actions,                member_actions=member_actions)]        return resources    def get_controller_extensions(self):        return []

class Disk_config(extensions.ExtensionDescriptor):    """Disk Management Extension."""    name = "DiskConfig"    alias = ALIAS    namespace = XMLNS_DCF    updated = "2011-09-27T00:00:00Z"    def get_controller_extensions(self):        servers_extension = extensions.ControllerExtension(                self, ‘servers‘, ServerDiskConfigController())        images_extension = extensions.ControllerExtension(                self, ‘images‘, ImageDiskConfigController())        return [servers_extension, images_extension]

# Look for implementation of extension point of server creation        self.create_extension_manager =           stevedore.enabled.EnabledExtensionManager(              namespace=self.EXTENSION_CREATE_NAMESPACE, #nova.api.v3.extensions.server.create              check_func=_check_load_extension(‘server_create‘),              invoke_on_load=True,              invoke_kwds={"extension_info": self.extension_info},              propagate_map_exceptions=True)        if not list(self.create_extension_manager):            LOG.debug("Did not find any server create extensions")

        # Query extensions which want to manipulate the keyword        # arguments.        # NOTE(cyeoh): This is the hook that extensions use        # to replace the extension specific code below.        # When the extensions are ported this will also result        # in some convenience function from this class being        # moved to the extension        if list(self.create_extension_manager):            self.create_extension_manager.map(self._create_extension_point,                                              server_dict, create_kwargs)    def _create_extension_point(self, ext, server_dict, create_kwargs):        handler = ext.obj        LOG.debug("Running _create_extension_point for %s", ext.obj)        handler.server_create(server_dict, create_kwargs)

    def server_create(self, server_dict, create_kwargs):        create_kwargs[‘config_drive‘] = server_dict.get(ATTRIBUTE_NAME)

            (instances, resv_id) = self.compute_api.create(context,                            inst_type,                            image_uuid,                            display_name=name,                            display_description=name,                            metadata=server_dict.get(‘metadata‘, {}),                            admin_password=password,                            requested_networks=requested_networks,                            **create_kwargs)

    def create(self, context, instance_type,               image_href, kernel_id=None, ramdisk_id=None,               min_count=None, max_count=None,               display_name=None, display_description=None,               key_name=None, key_data=http://www.mamicode.com/None, security_group=None,               availability_zone=None, user_data=http://www.mamicode.com/None, metadata=None,               injected_files=None, admin_password=None,               block_device_mapping=None, access_ip_v4=None,               access_ip_v6=None, requested_networks=None, config_drive=None,               auto_disk_config=None, scheduler_hints=None, legacy_bdm=True):        """Provision instances, sending instance information to the        scheduler.  The scheduler will determine where the instance(s)        go and will handle creating the DB entries.        Returns a tuple of (instances, reservation_id)        """