Let’s Build A Web Server. Part 2

Nhớ lại, trong phần một tôi hỏi bạn một câu hỏi: “Làm thế nào để bạn chạy ứng dụng Django, và ứng dụng Flask và ứng dụng Pyramid trên một máy chủ web mà không thực hiện một thay đổi nào cho máy chủ đáp ứng đầy đủ các khuôn khổ web khách nhau?”. Đọc tiếp để tìm câu trả lời.

Trong quá khứ, bạn chọn một Python Web Framework có thể bị giới hạn về nhưng máy chủ web có thể dùng được, và ngược lại. Nếu Framework và máy chủ được thiết kế để làm việc cùng nhau, thì bạn vẫn ổn:

Nhưng bạn có thể phải đối mặt với (và có thể bạn đã) các vấn đề khi cố gắng kết hợp Framework với Server mà không được thiết kế để làm việc cùng nhau.

Về cơ bản, bạn cần sử dụng cái gì đó để chúng làm việc với nhau, chứ không phải bạn muốn là sử dụng.

Vậy, làm thế nào bạn chắc chắn có thể chạy một máy chủ web với nhiều Web Framework khác nhau mà không làm thay đổi máy chủ web hoặc web Framework? Và để trả lời cho vấn đề đó đã trở thành Python Web Server Gateway Interface (or WSGI for short, pronounced “wizgy”).

WSGI cho phép lập trình viên lựa chọn một Web Framework từ Web Server. Bây giờ bạn có thể trộn và kết hợp Web Servers và Web Frameworks và chọn một kiểu ghép nối phù hợp với nhu cầu của bạn. Bạn cần chạy Django, Flask hoặc Pyramid, ví dụ: với Gunicorn hoặc Nginx/uWSGI hoặc Waitress. Trộn và kết hợp đồng thời, nhờ sự hỗ trợ WSGI trong Server và Framework.

Vậy, WSGI là câu trả lời cho câu hỏi của Tôi ở phần một và lặp lại ở đầu bài viết này. Web Server phải triển khai phần máy chủ của giao diện WSGI, và tất cả Python Web Frameworks đã được triển khai ở giao diện của WSGI, cái cho phép bạn sử dụng với Web Server không bao giờ sửa đổi Web Server để phù hợp với Web Framework.

Giờ bạn đã biết Web Server hỗ trợ WSGI và Web Framework cho phép bạn chọn một ghép nối phù hợp, nhưng nó cũng có lợi cho các nhà phát triển bởi vì chúng có thể tập chung vào một lĩnh vực mà không tập trung vào nhưng nhánh khác. Các ngôn ngữ khác cũng có giao diện tương tự: Java có Servlet API và Ruby has Rack.

Tất cả đều tốt. Nhưng tôi cá là bạn đang nói: “Cho tôi xem code!”. Okey,  nhìn vào máy chủ WSGI khá rõ ràng nè.

# Tested with Python 2.7.9, Linux & Mac OS X
import socket
import StringIO
import sys

class WSGIServer(object):
   address_family = socket.AF_INET
   socket_type = socket.SOCK_STREAM
   request_queue_size = 1
 
   def __init__(self, server_address):
       # Create a listening socket
       self.listen_socket = listen_socket = socket.socket(
           self.address_family,
           self.socket_type
       )

       # Allow to reuse the same address
       listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
       # Bind
       listen_socket.bind(server_address)
       # Activate
       listen_socket.listen(self.request_queue_size)
       # Get server host name and port
       host, port = self.listen_socket.getsockname()[:2]
       self.server_name = socket.getfqdn(host)
       self.server_port = port
       # Return headers set by Web framework/Web application
       self.headers_set = []
 
   def set_app(self, application):
       self.application = application
   def serve_forever(self):
       listen_socket = self.listen_socket
       while True:
           # New client connection
           self.client_connection, client_address = listen_socket.accept()
           # Handle one request and close the client connection. Then
           # loop over to wait for another client connection
           self.handle_one_request()
 
   def handle_one_request(self):
       self.request_data = request_data = self.client_connection.recv(1024)
       # Print formatted request data a la 'curl -v'
       print(''.join(
           '< {line}\n'.format(line=line)
           for line in request_data.splitlines()
       ))
 
       self.parse_request(request_data)
       # Construct environment dictionary using request data
       env = self.get_environ()
       # It's time to call our application callable and get
       # back a result that will become HTTP response body
       result = self.application(env, self.start_response)
       # Construct a response and send it back to the client
       self.finish_response(result)
 
   def parse_request(self, text):
       request_line = text.splitlines()[0]
       request_line = request_line.rstrip('\r\n')
       # Break down the request line into components
       (self.request_method,  # GET
        self.path,            # /hello
        self.request_version  # HTTP/1.1
        ) = request_line.split()
 
   def get_environ(self):
       env = {}
       # The following code snippet does not follow PEP8 conventions
       # but it's formatted the way it is for demonstration purposes
       # to emphasize the required variables and their values
       #
       # Required WSGI variables
       env['wsgi.version']      = (1, 0)
       env['wsgi.url_scheme']   = 'http'
       env['wsgi.input']        = StringIO.StringIO(self.request_data)
       env['wsgi.errors']       = sys.stderr
       env['wsgi.multithread']  = False
       env['wsgi.multiprocess'] = False
       env['wsgi.run_once']     = False

       # Required CGI variables
       env['REQUEST_METHOD']    = self.request_method # GET
       env['PATH_INFO']         = self.path # /hello
       env['SERVER_NAME']       = self.server_name # localhost
       env['SERVER_PORT']       = str(self.server_port) # 8888
       return env
 
   def start_response(self, status, response_headers, exc_info=None):
       # Add necessary server headers
       server_headers = [
           ('Date', 'Tue, 31 Mar 2015 12:54:48 GMT'),
           ('Server', 'WSGIServer 0.2'),
       ]

       self.headers_set = [status, response_headers + server_headers]
       # To adhere to WSGI specification the start_response must return
       # a 'write' callable. We simplicity's sake we'll ignore that detail
       # for now.
       # return self.finish_response
 
   def finish_response(self, result):
       try:
           status, response_headers = self.headers_set
           response = 'HTTP/1.1 {status}\r\n'.format(status=status)
           for header in response_headers:
               response += '{0}: {1}\r\n'.format(*header)
           response += '\r\n'
           for data in result:
               response += data
           # Print formatted response data a la 'curl -v'
           print(''.join(
               '> {line}\n'.format(line=line)
               for line in response.splitlines()
           ))
           self.client_connection.sendall(response)
       finally:
           self.client_connection.close()

SERVER_ADDRESS = (HOST, PORT) = '', 8888
 
def make_server(server_address, application):
   server = WSGIServer(server_address)
   server.set_app(application)
   return server
 
if __name__ == '__main__':
   if len(sys.argv) < 2:
       sys.exit('Provide a WSGI application object as module:callable')

   app_path = sys.argv[1]
   module, application = app_path.split(':')
   module = __import__(module)
   application = getattr(module, application)
   httpd = make_server(SERVER_ADDRESS, application)
   print('WSGIServer: Serving HTTP on port {port} ...\n'.format(port=PORT))
   httpd.serve_forever()

Không tin tôi? Thử nó và tự bạn kiểm chứng. Lưu code phí trên với tên webserver2.py hoặc tải nó ở link github: https://github.com/rspivak/lsbaws/blob/master/part2/webserver2.py . Nếu bạn thử và chạy nó không có bất kỳ tham số nó sẽ biên dịch và thoát.

$ python webserver2.py
Provide a WSGI application object as module:callable

Nó thực sự muốn phục vụ ứng dụng web của bạn và đó là nơi vui vẻ bắt đầu. Để chạy máy chủ, bạn cần cài đặt Python. Nhưng để chạy được ứng dụng được viết bằng Pyramid, Flask, and Django bạn cần cài đặt nhưng framework này trước. Hãy cài đặt cả ba. Phương pháp của tôi là sử dụng virtualenv. Chỉ cần làm theo các bước dưới đây để tạo và kích hoạt môi trường ảo sau đó cài đặt ba web framework.

$ [sudo] pip install virtualenv
$ mkdir ~/envs
$ virtualenv ~/envs/lsbaws/
$ cd ~/envs/lsbaws/
$ ls
bin  include  lib
$ source bin/activate
(lsbaws) $ pip install pyramid
(lsbaws) $ pip install flask
(lsbaws) $ pip install django

from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response(
        'Hello world from Pyramid!\n',
        content_type='text/plain',
    )

config = Configurator()
config.add_route('hello', '/hello')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()

(lsbaws) $ python webserver2.py pyramidapp:app
WSGIServer: Serving HTTP on port 8888 ...

$ curl -v http://localhost:8888/hello
...

from flask import Flask
from flask import Response
flask_app = Flask('flaskapp')

@flask_app.route('/hello')
def hello_world():
    return Response(
        'Hello world from Flask!\n',
        mimetype='text/plain'
    )

app = flask_app.wsgi_app

(lsbaws) $ python webserver2.py flaskapp:app
WSGIServer: Serving HTTP on port 8888 ...

$ curl -v http://localhost:8888/hello
...

import sys
sys.path.insert(0, './helloworld')
from helloworld import wsgi

app = wsgi.application

(lsbaws) $ python webserver2.py djangoapp:app
WSGIServer: Serving HTTP on port 8888 ...

$ curl -v http://localhost:8888/hello
...

def run_application(application):
    """Server code."""
    # This is where an application/framework stores
    # an HTTP status and HTTP response headers for the server
    # to transmit to the client
    headers_set = []
    # Environment dictionary with WSGI/CGI variables
    environ = {}

    def start_response(status, response_headers, exc_info=None):
        headers_set[:] = [status, response_headers]

    # Server invokes the ‘application' callable and gets back the
    # response body
    result = application(environ, start_response)
    # Server builds an HTTP response and transmits it to the client
    …

def app(environ, start_response):
    """A barebones WSGI app."""
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return ['Hello world!']

run_application(app)

def app(environ, start_response):
    """A barebones WSGI application.

    This is a starting point for your own Web framework :)
    """
    status = '200 OK'
    response_headers = [('Content-Type', 'text/plain')]
    start_response(status, response_headers)
    return ['Hello world from a simple WSGI application!\n']

(lsbaws) $ python webserver2.py wsgiapp:app
WSGIServer: Serving HTTP on port 8888 ...