基础概念
首先要了解 WSGI 规范的概念，WSGI(Web Server Gateway Interface)规范描述了web server(Gunicorn,uWSGI等)如何与web application(flask, django等)交互、web application如何处理请求，定义在 pep 3333。正是有了 WSGI 规范，我们才能在任意 web server 上跑各种 web 应用。WSGI API 定义看起来很简单:
def application(environ, start_response)
-
application 就是 WSGI app，一个可调用对象
-
参数:
- environ: 一个包含 WSGI 环境信息的字典，由 WSGI 服务器提供，常见的 key 有 PATH_INFO，QUERY_STRING 等
- start_response: 生成 WSGI 响应的回调函数，接收两个参数，status 和 headers
-
函数返回值为响应体的迭代器 ###简单举例 下面举个简单的例子，比如一个返回 hello world 的应用：
def application(environ, start_response): status = '200 OK' headers = [('Content-Type', 'text/html; charset=utf8')] start_response(status, headers) return [b"Hello, World!
"]
werkzeug相关
werkzeug是Python实现的WSGI规范的使用函数库。 正如werkzeug官网Werkzeug上所说，werkzeug使用起来非常简单，但是却非常强大。关于使用简单的这个特性，官网给了一段示例代码。
from werkzeug.wrappers import Request, Response @Request.application def application(request): return Response('Hello World!') if __name__ == '__main__': from werkzeug.serving import run_simple run_simple('localhost', 4000, application)
###简单小结 关于上面的代码我做一下总结: application--可调用对象,wsig模块中加括号括号执行 application的返回值--Response对象,wsgi中会对该对象加括号执行其__call__方法 一次成功的访问,由以下几步完成
- 浏览器（client）发送一个请求（request
- 服务器（server）接收到请求
- 服务器处理请求
- 返回处理的结果（response
- 浏览器处理返回的结果，显示出来。
Detail
具体来说:
- wigi相关模块通过建立socket拿到客户端发送的数据,然后进行解析,然后封装到environ中
- web框架比如flask,他拿到environ,执行其内部各种调用函数,视图函数,然后返回Response对象
- wigi相关模块拿到相应的Response对象,执行其__call__方法拿到app_iter对象,进行for循环进行socket.sendall(data)方法进行数据发送 ###源码 现在我们开始看一下源码:
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): def log_startup(sock): display_hostname = hostname not in ('', '*') and hostname or 'localhost' if ':' in display_hostname: display_hostname = '[%s]' % display_hostname quit_msg = '(Press CTRL+C to quit)' port = sock.getsockname()[1] _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None and 'http' or 'https', display_hostname, port, quit_msg) def inner(): try: fd = int(os.environ['WERKZEUG_SERVER_FD']) except (LookupError, ValueError): fd = None srv = make_server(hostname, port, application, threaded, processes, request_handler, passthrough_errors, ssl_context, fd=fd) if fd is None: log_startup(srv.socket) srv.serve_forever() inner()
执行inner方法 然后执行make_server方法拿到其返回值并赋值给srv
def make_server(host=None, port=None, app=None, threaded=False, processes=1, request_handler=None, passthrough_errors=False, ssl_context=None, fd=None): """Create a new server instance that is either threaded, or forks or just processes one request after another. """ if threaded and processes > 1: raise ValueError("cannot have a multithreaded and " "multi process server.") elif threaded: return ThreadedWSGIServer(host, port, app, request_handler, passthrough_errors, ssl_context, fd=fd) elif processes > 1: return ForkingWSGIServer(host, port, app, processes, request_handler, passthrough_errors, ssl_context, fd=fd) else: return BaseWSGIServer(host, port, app, request_handler, passthrough_errors, ssl_context, fd=fd)
以BaseWSGIServer类为例,将其实例化就是执行其__init__方法 因为类的各种继承,我就不一一细说了: 总的来说:
就是创建socket和定义处理request的类RequestHandleClass
其为:WSGIRequestHandler
然后执行srv.server_forver srv为BaseWSGIServer的实例,根据类的继承,去查找各种方法. 记住一点就是查找方法优先从自己的类定义中找,如果没有就去父类中找.时刻谨记self是谁
#BaseWSGIServer中定义 def serve_forever(self): self.shutdown_signal = False try: HTTPServer.serve_forever(self) except KeyboardInterrupt: pass finally: self.server_close()
###BaseServer def serve_forever(self, poll_interval=0.5): """Handle one request at a time until shutdown. Polls for shutdown every poll_interval seconds. Ignores self.timeout. If you need to do periodic tasks, do them in another thread. """ self.__is_shut_down.clear() try: # XXX: Consider using another file descriptor or connecting to the # socket to wake this up instead of polling. Polling reduces our # responsiveness to a shutdown request and wastes cpu at all other # times. with _ServerSelector() as selector: selector.register(self, selectors.EVENT_READ) while not self.__shutdown_request: ready = selector.select(poll_interval) if ready: self._handle_request_noblock() self.service_actions() finally: self.__shutdown_request = False self.__is_shut_down.set()
# BaseServer def _handle_request_noblock(self): """Handle one request, without blocking. I assume that selector.select() has returned that the socket is readable before this function was called, so there should be no risk of blocking in get_request(). """ try: request, client_address = self.get_request() except OSError: return if self.verify_request(request, client_address): try: self.process_request(request, client_address) except Exception: self.handle_error(request, client_address) self.shutdown_request(request) except: self.shutdown_request(request) raise else: self.shutdown_request(request)
执行process_request方法
def process_request(self, request, client_address): """Call finish_request. Overridden by ForkingMixIn and ThreadingMixIn. """ self.finish_request(request, client_address) self.shutdown_request(request)
Next
def finish_request(self, request, client_address): """Finish one request by instantiating RequestHandlerClass.""" self.RequestHandlerClass(request, client_address, self)
执行RequestHandlerClass类的实例化
执行BaseHTTPRequestHandler的handle方法 WSGIRequestHandler.handle_one_request
def handle_one_request(self): """Handle a single HTTP request.""" self.raw_requestline = self.rfile.readline() if not self.raw_requestline: self.close_connection = 1 elif self.parse_request(): return self.run_wsgi()
def run_wsgi(self): if self.headers.get('Expect', '').lower().strip() == '100-continue': self.wfile.write(b'HTTP/1.1 100 Continue\r\n\r\n') self.environ = environ = self.make_environ() headers_set = [] headers_sent = [] def write(data): assert headers_set, 'write() before start_response' if not headers_sent: status, response_headers = headers_sent[:] = headers_set try: code, msg = status.split(None, 1) except ValueError: code, msg = status, "" code = int(code) self.send_response(code, msg) header_keys = set() for key, value in response_headers: self.send_header(key, value) key = key.lower() header_keys.add(key) if not ('content-length' in header_keys or environ['REQUEST_METHOD'] == 'HEAD' or code < 200 or code in (204, 304)): self.close_connection = True self.send_header('Connection', 'close') if 'server' not in header_keys: self.send_header('Server', self.version_string()) if 'date' not in header_keys: self.send_header('Date', self.date_time_string()) self.end_headers() assert isinstance(data, bytes), 'applications must write bytes' self.wfile.write(data) self.wfile.flush() def start_response(status, response_headers, exc_info=None): if exc_info: try: if headers_sent: reraise(*exc_info) finally: exc_info = None elif headers_set: raise AssertionError('Headers already set') headers_set[:] = [status, response_headers] return write def execute(app): # app_iter对象 包含了需要返回的各项数据 application_iter = app(environ, start_response) # Flask实例的call方法返回的的response对象的__call__方法返回的东西 try: for data in application_iter: write(data) if not headers_sent: write(b'') finally: if hasattr(application_iter, 'close'): application_iter.close() application_iter = None try: execute(self.server.app) except (socket.error, socket.timeout) as e: self.connection_dropped(e, environ) except Exception: if self.server.passthrough_errors: raise from werkzeug.debug.tbtools import get_current_traceback traceback = get_current_traceback(ignore_system_exceptions=True) try: # if we haven't yet sent the headers but they are set # we roll back to be able to set them again. if not headers_sent: del headers_set[:] execute(InternalServerError()) except Exception: pass self.server.log('error', 'Error on request:\n%s', traceback.plaintext)
通过这个代码,我们拿到了app执行后拿到的可迭代对象 application_iter = app(environ, start_response) # Flask实例的call方法返回的的response对象的__call__方法返回的可迭代对象
END
最终for循环这个对象发送了数据
for data in application_iter: write(data)
转载https://juejin.im/post/5c66be3f6fb9a049dd80d2f2