Python - Django - 000 - WSGI协议

时间 2019-11-15

标签 python django wsgi 协议栏目 Python 繁體版

原文原文链接

Web开发的本质

简答描述Web应用程序的本质，就是咱们经过浏览器访问互联网上指定的网页文件展现到浏览器上。
流程以下图： html

从更深层次一点的技术角度来看，由一下几个步骤：（1）浏览器，将要请求的内容按照HTTP协议发送服务端
（2）服务端，根据请求内容找到指定的HTML页面
（3）浏览器，解析请求到的HTML内容展现出来

web开发的历程

静态开发：

直接将写好的html页面放在服务器上，而后经过浏览器访问指定服务器的文件。python

动态开发：

随着需求变化静态开发没法知足需求，当页面只有部份内容发生变化时，开发相同的页面。
一是开发上是一种重复工做
二是数据量变化巨大时，速度慢且数据变化也不是定时更新
为了应对这种问题，动态网页技术诞生。早期的动态网页开发技术是CGI
CGI全程：Common Gateway Interface，通用网关接口，它是一段程序，运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。
CGI程序能够是Python脚本，PERL脚本，SHELL脚本，C或C++程序等等。web

CGI流程

WSGI流程

1.WSGI协议定义

WSGI（Web Server Gateway Interface），WSGI既不是服务器，也不是python模块、框架、API或者任何软件，他只是一种规范，一种描述web server如何与web application 通讯的规范。要实现WSGI协议，必须同时实现web server和web application，当前运行在WSGI协议之上的web框架有Bottle，Flask，Django。django

uwsgi：与WSGI同样是一种通讯协议，是uWSGI服务器的独占协议，用于定义和传输信息的类型（type of information），每个uwsgi packet前4byte为传输信息类型的描述，与WSGI协议是两种东西。浏览器

uWSGI：是一个web服务器，实现了WSGI协议、uwsgi协议、http协议等。服务器

WSGI协议主要包括server和application两部分：cookie

WSGI server负责从客户端接收请求，将request转发给application，将application返回的response返回给客户端。
WSGI application接收由server转发的request，处理请求，并将处理结果返回给server。application中能够包括多个栈式的中间件（middlewares），这些中间件须要同时实现server与application，所以能够在WSGI服务器与WSGI应用之间起调节做用；对服务器来讲，中间件扮演应用程序，对应用程序来讲，中间件扮演服务器。

WSGI协议实际上是定义了一种server与application解耦的规范，便可以有多个实现WSGI server的服务器，也能够有多个实现WSGI application的框架，那么就能够选择任意的server和application组合实现本身的web应用。例如uWSGI和Gunicorn都是实现了WSGI server协议的服务器，Flask是实现了WSGI application协议的web框架，能够根据项目实际状况搭配使用。网络

2.WSGI实现

由于实现WSGI协议必需要有 WSGI server和application，所以须要实现这两部份内容。app

组件Application

应用程序，是一个可重复调用的可调用对象，在Python中能够是一个函数，也能够是一个类，若是是类的话要实现__call__方法，要求这个可调用对象接收2个参数，返回一个内容结果。
接收的2个参数分别是environ和start_response.
（1）environ是web服务器解析HTTP协议的一些信息，例如请求方法，请求URL等信息构成一个Dict对象。
（2）start_response是一个函数，接收2个参数，一个是HTTP状态码，一个HTTP消息中的响应头。框架

官网使用WSGI的wsgiref模块实现的小demo

def simple_app(environ, start_response):
    """Simple possible application object"""
    status = '200 OK'
    response_headers = [('Content-type', 'text/plain; charset=utf-8')]
    start_response(status, response_headers)
    
    return_body = []
    
    for key, value in environ.items():
        return_body.append("{}:{}".format(key, value))
        
    return_body.append("\nHello WSGI!")
    # 返回结果必须是bytes
    return ["\n".join(return_body).encode("utf-8")]
复制代码

组件Server

Web服务器，主要是实现相应的信息转换，将网络请求中的信息，按照HTTP协议将内容拿出，同时按照WSGI协议组装成新的数据，同时将提供的start_response传递给Application。最后接收Application返回的内容，按照WSGI协议解析出。最终按照HTTP协议组织好内容返回就完成了一次请求。
Server操做的步骤以下：
（1）根据HTTP协议内容构建environ
（2）提供一个start_response函数，接收HTTP STATU和HTTP HEADER
（3）将environ和start_response做为参数调用Application
（4）接收Application返回的结果
（5）按照HTTP协议，顺序写入HTTP响应头（start_response接收），HTTP响应体（Application返回结果）
一个实现的server

def make_server(host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler):
    """Create a new WSGI server listening on host and port for app"""
    server = server_class((host, port), handler_class)
    server, set_app(app)
    return server
复制代码

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）可调用对象要返回一个值，这个值是可迭代的。

# 可调用对象是一个类
class AppClass:
    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"
复制代码

服务器程序端

标准要可以确切的实行，必需要求程序端和服务器端共同遵照。
（1）准备environ函数
（2）定义start_response函数
（3）调用程序端的可调用对象

import os
import 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()
复制代码

3.由Django框架分析WSGI

Django WSGI application

WSGI application应该实现为一个可调用iter对象，例如函数、方法、类（包含__call__方法）。须要接受两个参数：

一个字典，该字典能够包含了客户端请求的信息以及其余信息，能够认为是请求上下文，通常叫作environment（编码中多简写为environ、env）。
一个用于发送HTTP响应状态（HTTP status）、响应头（HTTP headers）的回调函数，也就是start_response()。经过回调函数将响应状态和响应头返回给server，同时返回响应正文（response body），响应正文是可迭代的、而且包含了多个字符串。
下面是Django中application的具体实现部分：

class WSGIHandler(base.BaseHandler):
    initLock = Lock()
    request_class = WSGIRequest

    def __call__(self, environ, start_response):
        # 加载中间件
        if self._request_middleware is None:
            with self.initLock:
                try:  # Check that middleware is still uninitialized.
                    if self._request_middleware is None:
                        self.load_middleware()
                except:  # Unload whatever middleware we got
                    self._request_middleware = None
                    raise
            set_script_prefix(get_script_name(environ))  # 请求处理以前发送信号
            signals.request_started.send(sender=self.__class__, environ=environ)
            try:
                request = self.request_class(environ)
            except UnicodeDecodeError:
                logger.warning('Bad Request (UnicodeDecodeError)', exc_info=sys.exc_info(), extra={'status_code': 400, }
                response = http.HttpResponseBadRequest()
        else:
        response = self.get_response(request)
        response._handler_class = self.__class__
        status = '%s %s' % (response.status_code, response.reason_phrase)
        response_headers = [(str(k), str(v)) for k, v in response.items()]
        for c in response.cookies.values(): 
            response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
        # server提供的回调方法，将响应的header和status返回给server
        start_response(force_str(status), response_headers)
        if getattr(response, 'file_to_stream', None) is not None and environ.get('wsgi.file_wrapper'):
            response = environ['wsgi.file_wrapper'](response.file_to_stream)
    return response
复制代码

能够看出application的流程包括：加载全部的中间件,以及执行框架相关的操做，设置当前线程脚本前缀，发送请求开始信息；处理请求，调用get_response()方法处理当前请求，该方法的主要逻辑是经过urlconf找到对应的view和callback，按顺序执行各类middleware和callback。调用由server传入的start_response()方法将响应header与status返回给server。返回响应正文。

Django WSGI server

负责获取http请求，将请求传递给WSGI application，由application处理请求后返回response。以Django内建立server为例看一下具体实现。经过runserver运行Django项目，在启动时都会调用下面的run方法，建立一个WSGIServer实例，以后再调用其server_forever()方法启动服务。

def run(addr, port, wsgi_handler, ipv6=False, threading=False):
    server_address = (addr, port)
    if threading:
        httpd_cls = type(str('WSGIServer'), (socketserver.ThreadingMixIn, WSGIServer), {})
    else:
        httpd_cls = WSGIServer  # 这里的wsgi_handler就是WSGIApplication
    httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6)
    if threading:
        httpd.daemon_threads = True
        httpd.set_app(wsgi_handler)
    httpd.serve_forever()
复制代码

下面表示WSGI server服务器处理流程中关键的类和方法：

WSGIServer

run()方法会建立WSGIServer实例，主要做用是接收客户端请求，将请求传递给application，而后将application返回的response返回给客户端。

建立实例时会指定HTTP请求的handler：WSGIRequestHandler类
经过set_app和get_app方法设置和获取WSGIApplication实例wsgi_handler
处理http请求时，调用handler_request方法，会建立WSGIRequestHandler实例处理http请求
WSGIServer中get_request方法经过socket接收请求数据

WSGIRequestHandler

由WSGIServer在调用handler_request时建立实例，传入request、cient_address、WSGIServer三个参数，__init__方法在实例化同时还会调用自身的handler方法
handler方法会建立ServerHandler实例，而后调用其run方法处理请求

ServerHandler

WSGIRequestHandler在其handler方法中调用run()方法，传入self.server.get_app()参数，获取WSGIApplication，而后调用实例（call），获取response，其中会传入start_response回调，用以处理返回的headler和status。
经过application获取response之后，经过finish_response返回response

WSGIHandler

WSGI协议中的application，接收两个参数，environ字典包含了客户端请求的信息以及其余信息，能够认为是请求的上下文，start_response用于发送返回status和header的回调函数
虽然上面弄一个WSGI server设计到多个类实现以及相互引用，但其实原理仍是调用WSGIHandler，传入请求参数以及回调方法start_response()，并将响应返回给客户端。

Django simple_server

django的simple_server.py模块实现了一个简单的HTTP服务器，并给出了一个简单的demo，能够直接运行，运行结果会将请求中涉及到的环境变量在浏览器中展现出来。
其中包括上述描述的整个http请求的全部组件:
ServerHandler, WSGIServer, WSGIRequestHandler，以及demo_app表示的简易版的WSGIApplication。

if __name__ == '__main__':
    # 经过make_server方法建立WSGIServer实例
    # 传入建议application，demo_app
    httpd = make_server('', 8000, demo_app)
    sa = httpd.socket.getsockname()
    print("Serving HTTP on", sa[0], "port", sa[1], "...")
    import webbrowser
    webbrowser.open('http://localhost:8000/xyz?abc')
    # 调用WSGIServer的handle_request方法处理http请求
    httpd.handle_request()  # serve one request, then exit
    httpd.server_close()


def make_server(host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler):
    """Create a new WSGI server listening on `host` and `port` for `app`"""
    server = server_class((host, port), handler_class)
    server.set_app(app)
    return server


# demo_app可调用对象，接受请求输出结果
def demo_app(environ, start_response):
    from io import StringIO
    stdout = StringIO()
    print("Hello world!", file=stdout)
    print(file=stdout)
    h = sorted(environ.items())
    for k, v in h:
        print(k, '=', repr(v), file=stdout)
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    return [stdout.getvalue().encode("utf-8")]
复制代码

demo_app()表示一个简单的WSGI application实现，经过make_server()方法建立一个WSGIServer实例，调用其handle_request()方法，该方法会调用demo_app()处理请求，并最终返回响应。

uWSGI

uWSGI旨在为部署分布式集群的网络应用开发一套完整的解决方案。主要面向web及其标准服务。因为其可扩展性，可以被无限制的扩展用来支持更多平台和语言。uWSGI是一个web服务器，实现了WSGI协议，uwsgi协议，http协议等。
uWSGI的主要特色是：

超快的性能
低内存占用
多app管理
详尽的日志功能（能够用来分析app的性能和瓶颈）
高度可定制（内存大小限制，服务必定次数后重启等） uWSGI服务器本身实现了基于uwsgi协议的server部分，咱们只须要在uwsgi的配置文件中指定application的地址，uWSGI就能直接和应用框架中的WSGI application通讯。