您的位置: 首页  >  文章  >  python wsgi 简介

python wsgi 简介

分类: 文章 • 2023-10-09 13:46:32

http://python.jobbole.com/87361/


基础知识

Python 知识

  • iterator 和 generator
  • 函数的高级用法：嵌套函数，作为参数传递等等
  • 了解 decorator 会对理解 wsgi 有很大的帮助
  • python 的 callable 概念
  • classmethod 和 staticmethod 的概念
  • web 编程的基础

HTTP 基础

python wsgi 简介

对于 web 应用程序来说，最基本的概念就是客户端发送请求（request），收到服务器端的响应（response）。

下面是简单的 HTTP 请求：

1
2
3
4
5
GET /Index.html HTTP/1.1\r\n
Connection: Keep-Alive\r\n
Accept: */*\r\n
User-Agent: Sample Application\r\n
Host: www.microsoft.com\r\n\r\n

内容包括了 method、 url、 protocol version 以及头部的信息。而 HTTP 响应（不包括数据）可能是如下的内容：

1
2
3
4
5
6
7
8
HTTP/1.1 200 OK
Server: Microsoft-IIS/5.0\r\n
Content-Location: http://www.microsoft.com/default.htm\r\n
Date: Tue, 25 Jun 2002 19:33:18 GMT\r\n
Content-Type: text/html\r\n
Accept-Ranges: bytes\r\n
Last-Modified: Mon, 24 Jun 2002 20:27:23 GMT\r\n
Content-Length: 26812\r\n

实际生产中，python 程序是放在服务器的 http server（比如 apache， nginx 等）上的。现在的问题是 服务器程序怎么把接受到的请求传递给 python 呢，怎么在网络的数据流和 python 的结构体之间转换呢？这就是 wsgi 做的事情：一套关于程序端和服务器端的规范，或者说统一的接口。

python wsgi 简介

WSGI

我们先看一下面向 http 的 python 程序需要关心哪些内容：

  • 请求
    • 请求的方法 method
    • 请求的地址 url
    • 请求的内容
    • 请求的头部 header
    • 请求的环境信息
  • 响应
    • 状态码 status_code
    • 响应的数据
    • 响应的头部

WSGI（Web Server Gateway Interface） 的任务就是把上面的数据在 http server 和 python 程序之间简单友好地传递。它是一个标准，被定义在PEP 333。需要 http server 和 python 程序都要遵守一定的规范，实现这个标准的约定内容，才能正常工作。

python wsgi 简介

应用程序端

WSGI 规定每个 python 程序（Application）必须是一个可调用的对象（实现了__call__函数的方法或者类），接受两个参数 environ（WSGI 的环境信息） 和 start_response（开始响应请求的函数），并且返回 iterable。几点说明：

  1. environ 和 start_response 由 http server 提供并实现
  2. environ 变量是包含了环境信息的字典
  3. Application 内部在返回前调用 start_response
  4. start_response也是一个 callable，接受两个必须的参数，status（HTTP状态）和 response_headers（响应消息的头）
  5. 可调用对象要返回一个值，这个值是可迭代的。

说了这么多的概念，再来看看代码的实现：

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 1. 可调用对象是一个函数
def application(environ, start_response):
 
   response_body = 'The request method was %s' % environ['REQUEST_METHOD']
 
   # HTTP response code and message
   status = '200 OK'
 
   # 应答的头部是一个列表，每对键值都必须是一个 tuple。
   response_headers = [('Content-Type', 'text/plain'),
                       ('Content-Length', str(len(response_body)))]
 
   # 调用服务器程序提供的 start_response，填入两个参数
   start_response(status, response_headers)
 
   # 返回必须是 iterable
   return [response_body]
  
# 2. 可调用对象是一个类
class AppClass:
"""这里的可调用对象就是 AppClass 这个类，调用它就能生成可以迭代的结果。
使用方法类似于：
for result in AppClass(env, start_response):
     do_somthing(result)
"""
 
    def __init__(self, environ, start_response):
        self.environ = environ
        self.start = start_response
 
    def __iter__(self):
        status = '200 OK'
        response_headers = [('Content-type', 'text/plain')]
        self.start(status, response_headers)
        yield "Hello world!\n"
 
# 3. 可调用对象是一个实例
class AppClass:
"""这里的可调用对象就是 AppClass 的实例，使用方法类似于：
app = AppClass()
for result in app(environ, start_response):
     do_somthing(result)
"""
 
    def __init__(self):
        pass
 
    def __call__(self, environ, start_response):
        status = '200 OK'
        response_headers = [('Content-type', 'text/plain')]
        self.start(status, response_headers)
        yield "Hello world!\n"

服务器程序端

上面已经说过，标准要能够确切地实行，必须要求程序端和服务器端共同遵守。上面提到， envrion 和 start_response 都是服务器端提供的。下面就看看，服务器端要履行的义务。

  • 准备 environ 参数
  • 定义 start_response 函数
  • 调用程序端的可调用对象

PEP 333 里给出了一个 wsgi server 的简单实现，我又简化了一下——去除一些异常处理和判断，添加了一点注释：

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import os, sys
 
def run_with_cgi(application):    # application 是程序端的可调用对象
# 准备 environ 参数，这是一个字典，里面的内容是一次 HTTP 请求的环境变量
    environ = dict(os.environ.items())
    environ['wsgi.input']        = sys.stdin
    environ['wsgi.errors']       = sys.stderr
    environ['wsgi.version']      = (1, 0)
    environ['wsgi.multithread']  = False
    environ['wsgi.multiprocess'] = True
    environ['wsgi.run_once']     = True         
    environ['wsgi.url_scheme'] = 'http'
 
    headers_set = []
    headers_sent = []
 
# 把应答的结果输出到终端
    def write(data):
        sys.stdout.write(data)
        sys.stdout.flush()
 
# 实现 start_response 函数，根据程序端传过来的 status 和 response_headers 参数，
# 设置状态和头部
    def start_response(status, response_headers, exc_info=None):
        headers_set[:] = [status, response_headers]
       return write
 
# 调用客户端的可调用对象，把准备好的参数传递过去
    result = application(environ, start_response)
    
    # 处理得到的结果，这里简单地把结果输出到标准输出。
    try:
        for data in result:
            if data:    # don't send headers until body appears
                write(data)
    finally:
        if hasattr(result, 'close'):
            result.close()

中间层 middleware

有些程序可能处于服务器端和程序端两者之间：对于服务器程序，它就是应用程序；而对于应用程序，它就是服务器程序。这就是中间层 middleware。middleware 对服务器程序和应用是透明的，它像一个代理/管道一样，把接收到的请求进行一些处理，然后往后传递，一直传递到客户端程序，最后把程序的客户端处理的结果再返回。如下图所示：

python wsgi 简介

middleware 做了两件事情：

  1. 被服务器程序（有可能是其他 middleware）调用，返回结果回去
  2. 调用应用程序（有可能是其他 middleware），把参数传递过去

PEP 333 上面给出了 middleware 的可能使用场景：

  • 根据 url 把请求给到不同的客户端程序（url routing）
  • 允许多个客户端程序/web 框架同时运行，就是把接到的同一个请求传递给多个程序。
  • 负载均衡和远程处理：把请求在网络上传输
  • 应答的过滤处理

那么简单地 middleware 实现是怎么样的呢？下面的代码实现的是一个简单地 url routing 的 middleware：

Python
1
2
3
4
5
6
7
8
9
10
11
12
class Router(object):
    def __init__(self):
        self.path_info = {}
    def route(self, environ, start_response):
        application = self.path_info[environ['PATH_INFO']]
        return application(environ, start_response)
    def __call__(self, path):
        def wrapper(application):
            self.path_info[path] = application
        return wrapper
 
router = Router()

怎么在程序里面使用呢？

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#here is the application
@router('/hello') #调用 route 实例，把函数注册到 paht_info 字典
def hello(environ, start_response):
    status = '200 OK'
    output = 'Hello'
    response_headers = [('Content-type', 'text/plain'),
                        ('Content-Length', str(len(output)))]
    write = start_response(status, response_headers)
    return [output]
 
@router('/world')
def world(environ, start_response):
    status = '200 OK'
    output = 'World!'
    response_headers = [('Content-type', 'text/plain'),
                        ('Content-Length', str(len(output)))]
    write = start_response(status, response_headers)
    return [output]
 
#here run the application
result = router.route(environ, start_response)
for value in result:
    write(value)

相关推荐