如何搭建Web服务器（二）

在第一部分中，我提出了一个问题：“如何在你刚刚搭建起来的 Web 服务器上适配 Django, Flask 或 Pyramid 应用，而不用单独对 Web 服务器做做出改动以适应各种不同的 Web 框架呢?”我们可以从这一篇中找到答案。

曾几何时，你所选择的 Python Web 框架会限制你所可选择的 Web 服务器，反之亦然。如果某个框架及服务器设计用来协同工作的，那么一切正常：

但你可能正面对着(或者曾经面对过)尝试将一对无法适配的框架和服务器搭配在一起的问题：

基本上，你需要选择那些能够一起工作的框架和服务器，而不能选择你想用的那些。

所以，你该如何确保在不对 Web 服务器或框架的代码做任何更改的情况下，让你的 Web 服务器和多个不同的 Web
框架一同工作呢?这个问题的答案，就是 Python Web 服务器网关接口(Web Server Gateway Interface
)(缩写为 WSGI，念做“wizgy”)。

WSGI 允许开发者互不干扰地选择 Web 框架及 Web 服务器的类型。现在，你可以真正将 Web
服务器及框架任意搭配，然后选出你最中意的那对组合。比如，你可以使用 Django，Flask 或者 Pyramid，与
Gunicorn，Nginx/uWSGI 或 Waitress 进行结合。感谢 WSGI
同时对服务器与框架的支持，我们可以真正随意选择它们的搭配了。

所以，WSGI 就是我在第一部分中提出，又在本文开头重复了一遍的那个问题的答案。你的 Web 服务器必须实现 WSGI
接口的服务器部分，而现代的 Python Web 框架均已实现了 WSGI 接口的框架部分，这使得你可以直接在 Web
服务器中使用任意框架，而不需要更改任何服务器代码，以对特定的 Web 框架实现兼容。

现在，你已经知道 Web 服务器及 Web 框架对 WSGI
的支持使得你可以选择最合适的一对来使用，而且它也有利于服务器和框架的开发者，这样他们只需专注于其擅长的部分来进行开发，而不需要触及另一部分的代码。其它语言也拥有类似的接口，比如：Java
拥有 Servlet API，而 Ruby 拥有 Rack。

这些理论都不错，但是我打赌你在说：“Show me the code!” 那好，我们来看看下面这个很小的 WSGI 服务器实现：

1. ### 使用 Python 2.7.9，在 Linux 及 Mac OS X 下测试通过 
2. import socket 
3. import StringIO 
4. import sys 
5. class WSGIServer(object): 
6.     address_family = socket.AF_INET 
7.     socket_type = socket.SOCK_STREAM 
8.     request_queue_size = 1 
9.     def __init__(self, server_address): 
10.         ### 创建一个监听的套接字 
11.         self.listen_socket = listen_socket = socket.socket( 
12.             self.address_family, 
13.             self.socket_type 
14.         ) 
15.         ### 允许复用同一地址 
16.         listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
17.         ### 绑定地址 
18.         listen_socket.bind(server_address) 
19.         ### 激活套接字 
20.         listen_socket.listen(self.request_queue_size) 
21.         ### 获取主机的名称及端口 
22.         host, port = self.listen_socket.getsockname()[:2] 
23.         self.server_name = socket.getfqdn(host) 
24.         self.server_port = port 
25.         ### 返回由 Web 框架/应用设定的响应头部字段 
26.         self.headers_set = [] 
27.     def set_app(self, application): 
28.         self.application = application 
29.     def serve_forever(self): 
30.         listen_socket = self.listen_socket 
31.         while True: 
32.             ### 获取新的客户端连接 
33.             self.client_connection, client_address = listen_socket.accept() 
34.             ### 处理一条请求后关闭连接，然后循环等待另一个连接建立 
35.             self.handle_one_request() 
36.     def handle_one_request(self): 
37.         self.request_data = request_data = self.client_connection.recv(1024) 
38.         ### 以 'curl -v' 的风格输出格式化请求数据 
39.         print(''.join( 
40.             '< {line}\n'.format(line=line) 
41.             for line in request_data.splitlines() 
42.         )) 
43.         self.parse_request(request_data) 
44.         ### 根据请求数据构建环境变量字典 
45.         env = self.get_environ() 
46.         ### 此时需要调用 Web 应用来获取结果， 
47.         ### 取回的结果将成为 HTTP 响应体 
48.         result = self.application(env, self.start_response) 
49.         ### 构造一个响应，回送至客户端 
50.         self.finish_response(result) 
51.     def parse_request(self, text): 
52.         request_line = text.splitlines()[0] 
53.         request_line = request_line.rstrip('\r\n') 
54.         ### 将请求行分成几个部分 
55.         (self.request_method,  # GET 
56.          self.path,            # /hello 
57.          self.request_version  # HTTP/1.1 
58.          ) = request_line.split() 
59.     def get_environ(self): 
60.         env = {} 
61.         ### 以下代码段没有遵循 PEP8 规则，但这样排版，是为了通过强调 
62.         ### 所需变量及它们的值，来达到其展示目的。 
63.         ### 
64.         ### WSGI 必需变量 
65.         env['wsgi.version']      = (1, 0) 
66.         env['wsgi.url_scheme']   = 'http' 
67.         env['wsgi.input']        = StringIO.StringIO(self.request_data) 
68.         env['wsgi.errors']       = sys.stderr 
69.         env['wsgi.multithread']  = False 
70.         env['wsgi.multiprocess'] = False 
71.         env['wsgi.run_once']     = False 
72.         ### CGI 必需变量 
73.         env['REQUEST_METHOD']    = self.request_method    # GET 
74.         env['PATH_INFO']         = self.path              # /hello 
75.         env['SERVER_NAME']       = self.server_name       # localhost 
76.         env['SERVER_PORT']       = str(self.server_port)  # 8888 
77.         return env 
78.     def start_response(self, status, response_headers, exc_info=None): 
79.         ### 添加必要的服务器头部字段 
80.         server_headers = [ 
81.             ('Date', 'Tue, 31 Mar 2015 12:54:48 GMT'), 
82.             ('Server', 'WSGIServer 0.2'), 
83.         ] 
84.         self.headers_set = [status, response_headers + server_headers] 
85.         ### 为了遵循 WSGI 协议，start_response 函数必须返回一个 'write' 
86.         ### 可调用对象（返回值.write 可以作为函数调用）。为了简便，我们 
87.         ### 在这里无视这个细节。 
88.         ### return self.finish_response 
89.     def finish_response(self, result): 
90.         try: 
91.             status, response_headers = self.headers_set 
92.             response = 'HTTP/1.1 {status}\r\n'.format(status=status) 
93.             for header in response_headers: 
94.                 response += '{0}: {1}\r\n'.format(*header) 
95.             response += '\r\n' 
96.             for data in result: 
97.                 response += data 
98.             ### 以 'curl -v' 的风格输出格式化请求数据 
99.             print(''.join( 
100.                 '> {line}\n'.format(line=line) 
101.                 for line in response.splitlines() 
102.             )) 
103.             self.client_connection.sendall(response) 
104.         finally: 
105.             self.client_connection.close() 
106. SERVER_ADDRESS = (HOST, PORT) = '', 8888 
107. def make_server(server_address, application): 
108.     server = WSGIServer(server_address) 
109.     server.set_app(application) 
110.     return server 
111. if __name__ == '__main__': 
112.     if len(sys.argv) < 2: 
113.         sys.exit('Provide a WSGI application object as module:callable') 
114.     app_path = sys.argv[1] 
115.     module, application = app_path.split(':') 
116.     module = __import__(module) 
117.     application = getattr(module, application) 
118.     httpd = make_server(SERVER_ADDRESS, application) 
119.     print('WSGIServer: Serving HTTP on port {port} ...\n'.format(port=PORT)) 
120.     httpd.serve_forever() 

当然，这段代码要比第一部分的服务器代码长不少，但它仍然很短(只有不到 150
行)，你可以轻松理解它，而不需要深究细节。上面的服务器代码还可以做更多——它可以用来运行一些你喜欢的框架写出的 Web 应用，可以是
Pyramid，Flask，Django 或其它 Python WSGI 框架。

不相信吗?自己来试试看吧。把以上的代码保存为 webserver2.py，或直接从 Github 上下载它。如果你打算不加任何参数而直接运行它，它会抱怨一句，然后退出。

1. $ python webserver2.py 
2. Provide a WSGI application object as module:callable 

它想做的其实是为你的 Web 应用服务，而这才是重头戏。为了运行这个服务器，你唯一需要的就是安装好 Python。不过，如果你希望运行
Pyramid，Flask 或 Django 应用，你还需要先安装那些框架。那我们把这三个都装上吧。我推荐的安装方式是通过 virtualenv
安装。按照以下几步来做，你就可以创建并激活一个虚拟环境，并在其中安装以上三个 Web 框架。

1. $ [sudo] pip install virtualenv 
2. $ mkdir ~/envs 
3. $ virtualenv ~/envs/lsbaws/ 
4. $ cd ~/envs/lsbaws/ 
5. $ ls 
6. bin  include  lib 
7. $ source bin/activate 
8. (lsbaws) $ pip install pyramid 
9. (lsbaws) $ pip install flask 
10. (lsbaws) $ pip install django 

现在，你需要创建一个 Web 应用。我们先从 Pyramid 开始吧。把以下代码保存为 pyramidapp.py，并与刚刚的 webserver2.py 放置在同一目录，或直接从 Github 下载该文件：

1. from pyramid.config import Configurator 
2. from pyramid.response import Response 
3. def hello_world(request): 
4.     return Response( 
5.         'Hello world from Pyramid!\n', 
6.         content_type='text/plain', 
7.     ) 
8. config = Configurator() 
9. config.add_route('hello', '/hello') 
10. config.add_view(hello_world, route_name='hello') 
11. app = config.make_wsgi_app() 

现在，你可以用你自己的 Web 服务器来运行你的 Pyramid 应用了：

1. (lsbaws) $ python webserver2.py pyramidapp:app 
2. WSGIServer: Serving HTTP on port 8888 ... 

你刚刚让你的服务器去加载 Python 模块 pyramidapp 中的可执行对象 app。现在你的服务器可以接收请求，并将它们转发到你的
Pyramid 应用中了。在浏览器中输入 http://localhost:8888/hello ，敲一下回车，然后看看结果：

你也可以使用命令行工具 curl 来测试服务器：

1. $ curl -v http://localhost:8888/hello 
2. ... 

看看服务器和 curl 向标准输出流打印的内容吧。

现在来试试 Flask。运行步骤跟上面的一样

1. from flask import Flask 
2. from flask import Response 
3. flask_app = Flask('flaskapp') 
4. @flask_app.route('/hello') 
5. def hello_world(): 
6.     return Response( 
7.         'Hello world from Flask!\n', 
8.         mimetype='text/plain' 
9.     ) 
10. app = flask_app.wsgi_app 

将以上代码保存为 flaskapp.py，或者直接从 Github 下载，然后输入以下命令运行服务器：

1. (lsbaws) $ python webserver2.py flaskapp:app 
2. WSGIServer: Serving HTTP on port 8888 ... 

现在在浏览器中输入 http://localhost:8888/hello ，敲一下回车：

同样，尝试一下 curl，然后你会看到服务器返回了一条 Flask 应用生成的信息：

1. $ curl -v http://localhost:8888/hello 
2. ... 

这个服务器能处理 Django 应用吗?试试看吧!不过这个任务可能有点复杂，所以我建议你将整个仓库克隆下来，然后使用 Github
仓库中的 djangoapp.py 来完成这个实验。这里的源代码主要是将 Django 的 helloworld 工程(已使用 Django 的
django-admin.py startproject 命令创建完毕)添加到了当前的 Python 路径中，然后导入了这个工程的 WSGI
应用。(LCTT 译注：除了这里展示的代码，还需要一个配合的 helloworld 工程才能工作，代码可以参见 Github 仓库。)

1. import sys 
2. sys.path.insert(0, './helloworld') 
3. from helloworld import wsgi 
4. app = wsgi.application 

将以上代码保存为 djangoapp.py，然后用你的 Web 服务器运行这个 Django 应用：

1. (lsbaws) $ python webserver2.py djangoapp:app 
2. WSGIServer: Serving HTTP on port 8888 ... 

输入以下链接，敲回车：

你这次也可以在命令行中测试——你之前应该已经做过两次了——来确认 Django 应用处理了你的请求：

1. $ curl -v http://localhost:8888/hello 
2. ... 

你试过了吗?你确定这个服务器可以与那三个框架搭配工作吗?如果没试，请去试一下。阅读固然重要，但这个系列的内容是重新搭建，这意味着你需要亲自动手干点活。去试一下吧。别担心，我等着你呢。不开玩笑，你真的需要试一下，亲自尝试每一步，并确保它像预期的那样工作。

好，你已经体验到了 WSGI 的威力：它可以使 Web 服务器及 Web 框架随意搭配。WSGI 在 Python Web
服务器及框架之间提供了一个微型接口。它非常简单，而且在服务器和框架端均可以轻易实现。下面的代码片段展示了 WSGI 接口的服务器及框架端实现：

1. def run_application(application): 
2.     """服务器端代码。""" 
3.     ### Web 应用/框架在这里存储 HTTP 状态码以及 HTTP 响应头部， 
4.     ### 服务器会将这些信息传递给客户端 
5.     headers_set = [] 
6.     ### 用于存储 WSGI/CGI 环境变量的字典 
7.     environ = {} 
8.     def start_response(status, response_headers, exc_info=None): 
9.         headers_set[:] = [status, response_headers] 
10.     ### 服务器唤醒可执行变量“application”，获得响应头部 
11.     result = application(environ, start_response) 
12.     ### 服务器组装一个 HTTP 响应，将其传送至客户端 
13.     … 
14. def app(environ, start_response): 
15.     """一个空的 WSGI 应用""" 
16.     start_response('200 OK', [('Content-Type', 'text/plain')]) 
17.     return ['Hello world!'] 
18. run_application(app) 

这是它的工作原理：

1. Web 框架提供一个可调用对象 application (WSGI 规范没有规定它的实现方式)。
2. Web 服务器每次收到来自客户端的 HTTP 请求后，会唤醒可调用对象 applition。它会向该对象传递一个包含 WSGI/CGI 变量的环境变量字典 environ，以及一个可调用对象 start_response。
3. Web 框架或应用生成 HTTP 状态码和 HTTP 响应头部，然后将它传给 start_response 函数，服务器会将其存储起来。同时，Web 框架或应用也会返回 HTTP 响应正文。
4. 服务器将状态码、响应头部及响应正文组装成一个 HTTP 响应，然后将其传送至客户端(这一步并不在 WSGI 规范中，但从逻辑上讲，这一步应该包含在工作流程之中。所以为了明确这个过程，我把它写了出来)

这是这个接口规范的图形化表达：

到现在为止，你已经看过了用 Pyramid、Flask 和 Django 写出的 Web 应用的代码，你也看到了一个 Web
服务器如何用代码来实现另一半(服务器端的) WSGI 规范。你甚至还看到了我们如何在不使用任何框架的情况下，使用一段代码来实现一个最简单的
WSGI Web 应用。

其实，当你使用上面的框架编写一个 Web 应用时，你只是在较高的层面工作，而不需要直接与 WSGI 打交道。但是我知道你一定也对 WSGI
接口的框架部分感兴趣，因为你在看这篇文章呀。所以，我们不用 Pyramid、Flask 或 Django，而是自己动手来创造一个最朴素的
WSGI Web 应用(或 Web 框架)，然后将它和你的服务器一起运行：

1. def app(environ, start_response): 
2.     """一个最简单的 WSGI 应用。 
3.     这是你自己的 Web 框架的起点 ^_^ 
4.     """ 
5.     status = '200 OK' 
6.     response_headers = [('Content-Type', 'text/plain')] 
7.     start_response(status, response_headers) 
8.     return ['Hello world from a simple WSGI application!\n'] 

同样，将上面的代码保存为 wsgiapp.py 或直接从 Github 上下载该文件，然后在 Web 服务器上运行这个应用，像这样：

1. (lsbaws) $ python webserver2.py wsgiapp:app 
2. WSGIServer: Serving HTTP on port 8888 ... 

在浏览器中输入下面的地址，然后按下回车。这是你应该看到的结果：

你刚刚在学习如何创建一个 Web 服务器的过程中自己编写了一个最朴素的 WSGI Web 框架!棒极了!

现在，我们再回来看看服务器传给客户端的那些东西。这是在使用 HTTP 客户端调用你的 Pyramid 应用时，服务器生成的 HTTP 响应内容：

这个响应和你在本系列第一部分中看到的 HTTP 响应有一部分共同点，但它还多出来了一些内容。比如说，它拥有四个你曾经没见过的 HTTP
头部：Content-Type, Content-Length, Date 以及 Server。这些头部内容基本上在每个 Web
服务器返回的响应中都会出现。不过，它们都不是被严格要求出现的。这些 HTTP 请求/响应头部字段的目的在于它可以向你传递一些关于 HTTP
请求/响应的额外信息。

既然你对 WSGI 接口了解的更深了一些，那我再来展示一下上面那个 HTTP 响应中的各个部分的信息来源：

我现在还没有对上面那个 environ 字典做任何解释，不过基本上这个字典必须包含那些被 WSGI 规范事先定义好的 WSGI 及 CGI 变量值。服务器在解析 HTTP 请求时，会从请求中获取这些变量的值。这是 environ 字典应该有的样子：

Web 框架会利用以上字典中包含的信息，通过字典中的请求路径、请求动作等等来决定使用哪个视图来处理响应、在哪里读取请求正文、在哪里输出错误信息(如果有的话)。

现在，你已经创造了属于你自己的 WSGI Web 服务器，你也使用不同 Web 框架做了几个 Web
应用。而且，你在这个过程中也自己创造出了一个朴素的 Web 应用及框架。这个过程真是累人。现在我们来回顾一下，你的 WSGI Web
服务器在服务请求时，需要针对 WSGI 应用做些什么：

• 首先，服务器开始工作，然后会加载一个可调用对象 application，这个对象由你的 Web 框架或应用提供
• 然后，服务器读取一个请求
• 然后，服务器会解析这个请求
• 然后，服务器会使用请求数据来构建一个 environ 字典
• 然后，它会用 environ 字典及一个可调用对象 start_response 作为参数，来调用 application，并获取响应体内容。
• 然后，服务器会使用 application 返回的响应体，和 start_response 函数设置的状态码及响应头部内容，来构建一个 HTTP 响应。
• 最终，服务器将 HTTP 响应回送给客户端。

这基本上是服务器要做的全部内容了。你现在有了一个可以正常工作的 WSGI 服务器，它可以为使用任何遵循 WSGI 规范的 Web 框架(如
Django、Flask、Pyramid，还有你刚刚自己写的那个框架)构建出的 Web
应用服务。最棒的部分在于，它可以在不用更改任何服务器代码的情况下，与多个不同的 Web 框架一起工作。真不错。

在结束之前，你可以想想这个问题：“你该如何让你的服务器在同一时间处理多个请求呢?”

敬请期待，我会在第三部分向你展示一种解决这个问题的方法。干杯!

顺便，我在撰写一本名为《搭个 Web 服务器：从头开始》的书。这本书讲解了如何从头开始编写一个基本的 Web 服务器，里面包含本文中没有的更多细节。订阅邮件列表，你就可以获取到这本书的最新进展，以及发布日期。

作者：Ruslan

来源：51CTO