Shulou(Shulou.com)06/02 Report--

Today, I will talk to you about how to understand the Python WSGI protocol in WEB development. Many people may not understand it very well. In order to make you understand better, the editor has summarized the following content for you. I hope you can get something from this article.

Web application development

What is the essence of Web applications?

A brief description of the nature of Web applications is that we access web files specified on the Internet and display them on the browser through a browser.

The process is shown in the following figure:

From a deeper technical point of view, there are several steps:

Browser, the content to be requested is sent to the server according to the HTTP protocol

Server, find the specified HTML page according to the request content

Browser, parse the requested HTML content and display it.

The full name of HTTP protocol is HyperText Transfer Protocol (Hypertext transfer Protocol).

HTTP protocol is the application layer of our commonly used five-layer protocol (layer 5 is the application layer, transport layer, network layer, data link layer, physical layer). The content of the agreement in HTTP protocol is called message, which mainly includes message header-Header and message body-Body.

The message when the client requests is called Request, and the message when the server responds is called Response.

Header: including request method, HTTP version, URI, status code, COOKIE, etc.

Body: the content of a response or request, including HTML,CSS,JS, etc.

HTTP protocol is not described too much here. You can click here to learn more about HTTP protocol.

HTML's full name is Hyper Text Markup Language (Hypertext markup language)

To put it simply, HTML is a markup language made up of different elements, which defines the meaning and structure of web content, and all the content we see in browsers is made up of elements. Technologies other than HTML are usually used to describe the performance and presentation effect of a web page (such as CSS), or function and behavior (such as JavaScript).

The course of WEB Development

Static development

Put the written HTML page directly on the server, and then access the files of the specified server directly through the browser.

Dynamic development

As our needs change, static development alone can no longer fully satisfy us. For example, if only part of the content of the page we view will change, then we will develop the same page. First, development is a kind of repetitive work and a complete waste. Second, when the amount of data changes greatly, it is completely unable to keep up with the speed, and the data change is not updated regularly. In order to deal with this problem, dynamic web technology was born. The early dynamic web page development technology is CGICGI full name: Common Gateway Interface, universal gateway interface, it is a section of program, runs on the server such as: HTTP server, provides the interface with the client HTML page. CGI programs can be Python scripts, PERL scripts, SHELL scripts, C or C++ programs, etc. Various programming languages also give different solutions for dynamic web page development, such as JAVA's servlet,Python 's WSGI protocol and so on.

Python's WSGI protocol is also what we will talk about in this chapter.

CGI process

The process of WSGI

What is WSGI?

WSGI, whose full name is Web Server Gateway Interface, serves as a recommended standard interface between Web servers and Python Web applications or frameworks to facilitate portability of Web applications across a variety of Web servers.

WSGI is not a framework but a protocol. We can divide the WSGI protocol into three components: Application,Server,Middleware and the content transmitted in the protocol.

Mapping these three component pairs to the specific components we use are:

Server: commonly used are uWSGI,gunicorn and so on.

Application:Django,Flask et al.

Middleware: decorators in frames such as Flask

Click here to see the official definition of the WSGI protocol

Component Application

An application is a callable object that can be called repeatedly. In Python, it can be a function or a class. If it is a class, to implement the _ _ call__ method, the callable object is required to receive two parameters and return a content result.

The two parameters received are environ and start_response.

Environ is a Dict object composed of web server parsing some information of HTTP protocol, such as request method, request URI and so on.

Start_response is a function that takes two parameters, a HTTP status code and a response header in a HTTP message.

Implement an application with a function according to the official example

Def simple_app (environ, start_response): "Simplest 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!") # the returned result must be bytes return ["\ n" .join (return_body) .encode ("utf-8")]

Component Server

The Web server mainly realizes the corresponding information conversion, takes out the information in the network request according to the HTTP protocol, assembles the new data according to the WSGI protocol, and transmits the provided start_response to the Application. Finally, the content returned by Application is received and parsed according to WSGI protocol. Finally, a request is completed by organizing the content return according to the HTTP protocol.

The steps for Server operation are as follows:

Build envrion according to HTTP protocol content

Provides a start_response function that receives HTTP STATU and HTTP HEADER

Call Application with envrion and start_response as parameters

Receive the result returned by Application

According to HTTP protocol, HTTP response header (start_response receive) and HTTP response body (Application return result) are written sequentially.

The following is an example of server in the pep3333 protocol, implemented as a CGI request.

Import os, sysenc, esc = sys.getfilesystemencoding (), 'surrogateescape'def unicode_to_wsgi (u): # Convert an environment variable to a WSGI "bytes-as-unicode" string return u.encode (enc, esc). Decode (' iso-8859-1') def wsgi_to_bytes (s): return s.encode ('iso-8859-1') def run_with_cgi (application): # construct environ content # 1 CGI-related variables according to WSGI protocol This script is used for cgi execution, so the previous web server has encapsulated the CGI variable Here we directly use the variable environ ['wsgi.input'] = sys.stdin.buffer environ [' wsgi.errors'] = sys.stderr environ ['wsgi.version'] = (1, 0) environ [' wsgi.multithread'] = False environ ['wsgi.multiprocess'] = True environ [' wsgi.run_once'] = True if environ.get ('HTTPS') defined by wsgi of type environ = {k: unicode_to_wsgi (v) for kvie v in os.environ.items ()} # 2 'off') in (' on','1'): environ ['wsgi.url_scheme'] =' https' else: environ ['wsgi.url_scheme'] =' http' headers_set = [] headers_sent = [] def write (data): # return the content out = sys.stdout.buffer if not headers_set: raise AssertionError ("write () before start_response ()") elif not headers_sent: # Before the first output, send the stored headers status Response_headers = headers_sent [:] = headers_set out.write (wsgi_to_bytes ('Status:% s\ r\ n'% status)) for header in response_headers: out.write (wsgi_to_bytes ('% s:% s\ r\ n'% header)) out.write (wsgi_to_bytes ('\ r\ n')) out.write (data) out.flush () def start_response (status, response_headers Exc_info=None): if exc_info: try: if headers_sent: # Re-raise original exception if headers sent raise exc_info [1] .with _ traceback (exc_info [2]) finally: exc_info=None # avoid dangling circular ref elif headers_set: raise AssertionError ("Headers already set!") Headers_set [:] = [status, response_headers] # Note: error checking on the headers should happen here, # * after* the headers are set. That way, if an error # occurs, start_response can only be re-called with # exc_info set. Return write # gives the above parameters to the application result = application (environ, start_response) try: # to write back the requested result. For data in result: if data: # don't send headers until body appears write (data) if not headers_sent: write ('') # send headers now if body was empty finally: if hasattr (result, 'close'): result.close ()

Component Middleware

Middleware can be understood as a set of decorators for an application.

From the application side's point of view, it can provide a start_response-like function that receives HTTP STATU and Headers; and environ just like the start_response function.

From the server's point of view, he can accept two parameters and return an Application-like object.

Let's take a look at an example to record the time spent on each request:

Import timeclass ResponseTimingMiddleware (object): "def _ init__ (self, app): self.app = app def _ call__ (self, environ, start_response): start_time = time.time () response = self.app (environ) Start_response) response_time = (time.time ()-start_time) * 1000 timing_text = "record request time-consuming middleware output\ n\ nThis request takes time: {: .10f} ms\ n\ n\ n" .format (response_time) response.append (timing_text.encode ('utf-8')) return response

Content of the agreement

Focus on what the environ contains, which is the information that the browser requests each time. A little more exploration is how the request header and body in the HTTP request message are defined and how to go back.

Environ is a dictionary. Environ should contain variables defined by CGI, mainly the contents of HTTP protocol, such as request method, POST/GET, request URI, etc., as well as variables defined by WSGI protocol itself, such as requesting information to be read in body. List the main variables as follows:

CGI related variables

The variable indicates REQUEST_METHODPOST,GET, etc., and the verb of the HTTP request identifies the HTTP protocol that the SERVER_PROTOCOL server is running. Here, it is regarded as the path information attached by HTTP/1.0.PATH_INFO, which is issued by the browser. Query _ STRING requests the "?" of URL. The content of any Content-Type field in the later part of the CONTENT_TYPEHTTP request the number of bytes of the CONTENT_LENGTH standard input .HTTP _ [variable] some other variables, such as HTTP_ACCEPT,HTTP_REFERER, etc.

The above content is the foundation of dynamic development, and only according to the above content can the request be processed dynamically.

WSGI defines variables

Variable description wsgi.versionWSGI version, requirements is tuple (1Jing 0), identify WSGI 1.0 protocol wsgi.url_scheme represents the calling application's URL protocol, http or httpswsgi.input class file object, read HTTP request body bytes of the input stream wsgi.errors class file object, write error output stream wsgi.multithread if it is multithreaded, it is set to True, otherwise it is False. Wsgi.multiprocess is set to True if it is multi-process, otherwise it is False. If wsgi.run_once only needs to be run once, set it to True

The WSGI protocol has some methods that must be implemented for two input and output streams.

Stream method wsgi.inputread (size) wsgi.inputreadline () wsgi.inputreadlines (hint) wsgi.inputiter () wsgi.errorsflush () wsgi.errorswrite (str) wsgi.errorswritelines (seq)

These are basically the main variables defined in the WSGI protocol and basically cover the variables we need for development.

The Server side generates these environ dictionaries according to the content of the protocol, then sends the request information to Application,Application to confirm the content of the request to be processed according to this information, and then returns the response message. This is the process from the beginning.

Sample display

The Server side is related to the implementation of http. We directly use the built-in wsgiref of python to implement it. The specific code is as follows:

Import timefrom wsgiref.simple_server import make_serverclass ResponseTimingMiddleware (object): "def _ init__ (self, app): self.app = app def _ call__ (self, environ, start_response): start_time = time.time () response = self.app (environ) Start_response) response_time = (time.time ()-start_time) * 1000 timing_text = "record request time-consuming middleware output\ n\ nThis request takes time: {: .10f} ms\ n\ n\ n" .format (response_time) response.append (timing_text.encode ('utf-8')) return responsedef simple_app (environ, start_response): "" Simplest 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!") # the returned result must be bytes return ["\ n" .join (return_body) .encode ("utf-8")] # create application app = ResponseTimingMiddleware (simple_app) # start the service Listen 8080httpd = make_server ('localhost', 8080, app) httpd.serve_forever ()

After starting the service, we open a browser to access http://localhost:8080, and the execution result is as follows.

As you can see in the figure above, the middleware we mentioned earlier and the results returned by the execution in Application are all implemented.

After reading the above, do you have any further understanding of how to understand the Python WSGI protocol in WEB development? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.