# 通过绿色线程启动两个进程的过程大致如下,count不配置的话直接用cpu的数量
def create_servers():
    admin_worker_count = _get_workers('admin_workers')
    public_worker_count = _get_workers('public_workers')

    servers = []
    servers.append(create_server(paste_config,
                                 'admin',
                                 CONF.eventlet_server.admin_bind_host,
                                 CONF.eventlet_server.admin_port,
                                 admin_worker_count))
    servers.append(create_server(paste_config,
                                 'main',
                                 CONF.eventlet_server.public_bind_host,
                                 CONF.eventlet_server.public_port,
                                 public_worker_count))
    return servers

def create_server(conf, name, host, port, workers):
    app = keystone_service.loadapp('config:%s' % conf, name)

def loadapp(conf, name):
    # NOTE(blk-u): Save the application being loaded in the controllers module.
    # This is similar to how public_app_factory() and v3_app_factory()
    # register the version with the controllers module.
    controllers.latest_app = deploy.loadapp(conf, name=name)
    return controllers.latest_app

    self.launcher = self._child_process(wrap.service)

def loadapp(uri, name=None, **kw):
    return loadobj(APP, uri, name=name, **kw)

def loadobj(object_type, uri, name=None, relative_to=None,
            global_conf=None):
    context = loadcontext(
        object_type, uri, name=name, relative_to=relative_to,
        global_conf=global_conf)
    return context.create()

def _loadconfig(object_type, uri, path, name, relative_to,
                global_conf):

def _loadegg(object_type, uri, spec, name, relative_to,
             global_conf):

    entry_point, protocol, ep_name = self.find_egg_entry_point(object_type, name=name)

def create(self):
    return self.object_type.invoke(self)

def invoke(self, context):
    # invoke反射
    if context.protocol in ('paste.composit_factory',
                            'paste.composite_factory'):
        # fix_call看下面
        return fix_call(context.object,
                        context.loader, context.global_conf,
                        **context.local_conf)
    elif context.protocol == 'paste.app_factory':
        return fix_call(context.object, context.global_conf, **context.local_conf)
    else:
        assert 0, "Protocol %r unknown" % context.protocol


def fix_call(callable, *args, **kw):
    """
    Call ``callable(*args, **kw)`` fixing any type errors that come out.
    """
    try:
        val = callable(*args, **kw)
    except TypeError:
        exc_info = fix_type_error(None, callable, args, kw)
        reraise(*exc_info)
    return val

def urlmap_factory(loader, global_conf, **local_conf):
    if 'not_found_app' in local_conf:
        not_found_app = local_conf.pop('not_found_app')
    else:
        not_found_app = global_conf.get('not_found_app')
    if not_found_app:
        not_found_app = loader.get_app(not_found_app, global_conf=global_conf)
    urlmap = URLMap(not_found_app=not_found_app)
    for path, app_name in local_conf.items():
        path = parse_path_expression(path)
        app = loader.get_app(app_name, global_conf=global_conf)
        urlmap[path] = app
    return urlmap

# URLMap类大致代码
class URLMap(paste.urlmap.URLMap):
    ...
    # urlmap类是callable的
    def __call__(self, environ, start_response):
        host = environ.get('HTTP_HOST', environ.get('SERVER_NAME')).lower()
        if ':' in host:
            host, port = host.split(':', 1)
        else:
            if environ['wsgi.url_scheme'] == 'http':
                port = '80'
            else:
                port = '443'
        # 从environ中获取到path信息
        path_info = environ['PATH_INFO']
        path_info = self.normalize_url(path_info, False)[1]
        # path映射到openstack的具体app line
        mime_type, app, app_url = self._path_strategy(host, port, path_info)

# tcp server,  处理socket来的数据
class Server(BaseHTTPServer.HTTPServer):

    def process_request(self, sock_params):
        sock, address = sock_params
        # self.protocol 就是HttpProtocol
        # 这里用了点技巧
        # 先用用HttpProtocol.__new__生成类实例
        # 修改部分属性后再调用init
        proto = new(self.protocol)
        if self.minimum_chunk_size is not None:
            proto.minimum_chunk_size = self.minimum_chunk_size
        proto.capitalize_response_headers = self.capitalize_response_headers
        try:
            # 把自己传到proto中
            # BaseHTTPRequestHandler的第一个个参数request就是sock
            proto.__init__(sock, address, self)
        except socket.timeout:
            # Expected exceptions are not exceptional
            sock.close()
            # similar to logging "accepted" in server()
            self.log.debug('(%s) timed out %r' % (self.pid, address))


# http协议包处理,就是上面的proto.__init__(sock, address, self)
class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler):

    def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        # setup把socket的数据传入管道文件rfile
        # 具体代码在BaseHTTPRequestHandler类中
        self.setup()
        try:
            self.handle()
        finally:
            self.finish()

    def setup(self):
        # self.request就是socket对象
        # 一般来说是eventlet替换过的绿色socket对象
        conn = self.connection = self.request
        if getattr(socket, 'TCP_QUICKACK', None):
            try:
                conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, True)
            except socket.error:
                pass

        try:
            # 如果socket对象支持生成文件
            self.rfile = conn.makefile('rb', self.rbufsize)
            self.wfile = conn.makefile('wb', self.wbufsize)
        except (AttributeError, NotImplementedError):
            if hasattr(conn, 'send') and hasattr(conn, 'recv'):
                # it's an SSL.Connection
                # ssl socket对象没有makefile功能
                # 调用soket原生的_fileobject方法
                self.rfile = socket._fileobject(conn, "rb", self.rbufsize)
                self.wfile = socket._fileobject(conn, "wb", self.wbufsize)
            else:
                # conn对象错误
                raise NotImplementedError("wsgi.py doesn't support sockets "
                                          "of type %s" % type(conn))


    def handle(self):
        self.close_connection = 1
        self.handle_one_request()
        # 循环接收数据
        while not self.close_connection:
            self.handle_one_request()

    def handle_one_request(self):
        # 从读管道rfile里读, 读取的第一行是url
        self.raw_requestline = self.rfile.readline(self.server.url_length_limit)
        # 这里是读出socket里的内容,生成environ
        if not self.parse_request():
            # 数据包不完整直接返回
            return
        ...
        # 前面已经从socket里读好数据并存放到当前实例的属性中
        # 现在取出来
        self.environ = self.get_environ()
        # server.app,也就是self.application是一个URLMap类
        # 也就是load_app所返回的所有对应openstack的app line组成的字典
        self.application = self.server.app
        try:
            self.server.outstanding_requests += 1
            try:
                self.handle_one_response()
            except socket.error as e:
                # Broken pipe, connection reset by peer
                if support.get_errno(e) not in BROKEN_SOCK:
                    raise
        finally:
            self.server.outstanding_requests -= 1

    def handle_one_response(self):
        ...
        # 这里是的application就是一个前面的URLMap类实例
        # start_response用于回发数据
        result = self.application(self.environ, start_response)

    _context_from_explicit