middleware

The Middleware is used to do some processing or validation before the server gets the request data to the application. You can also write it in your server if you want. However, the WSGI specification recommends writing this in middleware. Here I implement a middleware that checks if the request 'user-agent' is a normal browser and then rejects it:

# coding: utf-8
# middleware.py
from __future__ import unicode_literals
class TestMiddle(object):
    def __init__(self, application):
        self.application = application
    def __call__(self, environ, start_response):
        if 'postman' in environ.get('USER_AGENT'):
            start_response('403 Not Allowed', [])
            return ['not allowed!']
        return self.application(environ, start_response)Copy the code

Init to receive the application, write the processing in the __call__ method, and return the application so that our middleware can be called as a function.

Then introduce middleware:

from middleware import TestMiddle
...
server.set_application(TestMiddle(application))Copy the code

Now restart the server and access the server with Postman:



As you can see, the middleware is working!

Next, let's talk about Django and Tornado's support for WSGI:

Django WSGI:

Django WSGI application

Django itself is too complex to use directly on the WSGi Server we wrote, but Django takes this into account and provides WSGIHandler:

class WSGIHandler(base.BaseHandler): request_class = WSGIRequest def __init__(self, *args, **kwargs): super(WSGIHandler, self).__init__(*args, **kwargs) self.load_middleware() def __call__(self, environ, start_response): 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 = '%d %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='')))) 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 Here WSGIHandler also uses start_response(force_str(status), response_headers) to wrap Django app into a standard WSGI app and return response. WSGIServer(Simple_server.wsgiserver, Object): """BaseHTTPServer that implements the Python WSGI protocol""" request_queue_size = 10 def __init__(self, *args, **kwargs): if kwargs.pop('ipv6', False): self.address_family = socket.AF_INET6 self.allow_reuse_address = kwargs.pop('allow_reuse_address', True) super(WSGIServer, self).__init__(*args, **kwargs) def server_bind(self): """Override server_bind to store the server name.""" super(WSGIServer, self).server_bind() self.setup_environ() def handle_error(self, request, client_address): if is_broken_pipe_error(): logger.info("- Broken pipe from %s\n", client_address) else: super(WSGIServer, self).handle_error(request, client_address)Copy the code

As you can see, WSGIHandler also wraps Django App into a standard WSGI app using start_response(force_str(status), response_headers) and returns response.

Django WSGI server

class WSGIServer(HTTPServer): """BaseHTTPServer that implements the Python WSGI protocol""" application = None def server_bind(self): """Override server_bind to store the server name.""" HTTPServer.server_bind(self) self.setup_environ() def setup_environ(self): # Set up base environment env = self.base_environ = {} env['SERVER_NAME'] = self.server_name env['GATEWAY_INTERFACE'] = 'CGI / 1.1' env = [' SERVER_PORT] STR (self. SERVER_PORT) env = [' REMOTE_HOST '] 'env = [' CONTENT_LENGTH'] 'env = [' SCRIPT_NAME']  '' def get_app(self): return self.application def set_app(self,application): self.application = applicationCopy the code

class WSGIServer(HTTPServer): """BaseHTTPServer that implements the Python WSGI protocol""" application = None def server_bind(self): """Override server_bind to store the server name.""" HTTPServer.server_bind(self) self.setup_environ() def setup_environ(self): # Set up base environment env = self.base_environ = {} env['SERVER_NAME'] = self.server_name env['GATEWAY_INTERFACE'] = 'CGI / 1.1' env = [' SERVER_PORT] STR (self. SERVER_PORT) env = [' REMOTE_HOST '] 'env = [' CONTENT_LENGTH'] 'env = [' SCRIPT_NAME']  '' def get_app(self): return self.application def set_app(self,application): self.application = applicationCopy the code

Tornado WSGI

Tornado implements event pool operations, TCP Server, and HTTP Server directly from the bottom with epoll itself, so it is a completely different asynchronous framework, but Tornado also provides support for WSGI. But there is no way to use Tornado asynchronism in this case.

Tornado doesn't provide WSGI support so much as wsGI compatibility. Tornado provides two ways:

WSGIContainer

WSGIAdapter

Tornado application should run on WSGI Server, tornado provides WSGIAdapter:

class WSGIAdapter(object): def __init__(self, application): if isinstance(application, WSGIApplication): self.application = lambda request: web.Application.__call__( application, request) else: self.application = application def __call__(self, environ, start_response): method = environ["REQUEST_METHOD"] uri = urllib_parse.quote(from_wsgi_str(environ.get("SCRIPT_NAME", ""))) uri += urllib_parse.quote(from_wsgi_str(environ.get("PATH_INFO", ""))) if environ.get("QUERY_STRING"): uri += "?" + environ["QUERY_STRING"] headers = httputil.HTTPHeaders() if environ.get("CONTENT_TYPE"): headers["Content-Type"] = environ["CONTENT_TYPE"] if environ.get("CONTENT_LENGTH"): headers["Content-Length"] = environ["CONTENT_LENGTH"] for key in environ: if key.startswith("HTTP_"): headers[key[5:].replace("_", "-")] = environ[key] if headers.get("Content-Length"): body = environ["wsgi.input"].read( int(headers["Content-Length"])) else: body = b"" protocol = environ["wsgi.url_scheme"] remote_ip = environ.get("REMOTE_ADDR", "") if environ.get("HTTP_HOST"): host = environ["HTTP_HOST"] else: host = environ["SERVER_NAME"] connection = _WSGIConnection(method, start_response, _WSGIRequestContext(remote_ip, Protocol) request = httputil. HTTPServerRequest (method, uri, "HTTP / 1.1," headers = headers, body = body, host = host, connection=connection) request._parse_body() self.application(request) if connection._error: raise connection._error if not connection._finished: raise Exception("request did not finish synchronously") return connection._write_bufferCopy the code

It can be seen that Tornado also changed its application to the standard WSGI APP using the process mentioned above. Finally, let's try to run Tornado App on our own server:

# coding: utf-8
# tornado_wsgi.py
from __future__ import unicode_literals
import datetime
import tornado.web
import tornado.wsgi
from middleware import TestMiddle
from server import WSGIServer
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("this is a tornado wsgi application")
if __name__ == "__main__":
    application = tornado.web.Application([
        (r"/", MainHandler),
    ])
    wsgi_app = tornado.wsgi.WSGIAdapter(application)
    server = WSGIServer(('', 9090))
    server.set_application(TestMiddle(wsgi_app))
    print 'RAPOWSGI Server Serving HTTP service on port {0}'.format(9090)
    print '{0}'.format(datetime.datetime.now().
                       strftime('%a, %d %b %Y %H:%M:%S GMT'))
    server.serve_forever()Copy the code

Run:python tornado_wsgi.py, open the browser:localhost:9090And the middleware is working fine:

Simple_wsgi_server Let's Build A Web Server

The original address