搭個 Web 伺服器（二）

曾幾何時，你所選擇的 Python Web 框架會限制你所可選擇的 Web 伺服器，反之亦然。如果某個框架及伺服器設計用來協同工作的，那麼一切正常：

但你可能正面對著（或者曾經面對過）嘗試將一對無法適配的框架和伺服器搭配在一起的問題：

基本上，你需要選擇那些能夠一起工作的框架和伺服器，而不能選擇你想用的那些。

所以，你該如何確保在不對 Web 伺服器或框架的代碼做任何更改的情況下，讓你的 Web 伺服器和多個不同的 Web 框架一同工作呢？這個問題的答案，就是 Python Web 伺服器網關介面 （ Web Server Gateway Interface ） （縮寫為 WSGI，念做「wizgy」）。

WSGI 允許開發者互不干擾地選擇 Web 框架及 Web 伺服器的類型。現在，你可以真正將 Web 伺服器及框架任意搭配，然後選出你最中意的那對組合。比如，你可以使用 Django，Flask 或者 Pyramid，與 Gunicorn，Nginx/uWSGI 或 Waitress 進行結合。感謝 WSGI 同時對伺服器與框架的支持，我們可以真正隨意選擇它們的搭配了。

所以，WSGI 就是我在第一部分中提出，又在本文開頭重複了一遍的那個問題的答案。你的 Web 伺服器必須實現 WSGI 介面的伺服器部分，而現代的 Python Web 框架均已實現了 WSGI 介面的框架部分，這使得你可以直接在 Web 伺服器中使用任意框架，而不需要更改任何伺服器代碼，以對特定的 Web 框架實現兼容。

現在，你已經知道 Web 伺服器及 Web 框架對 WSGI 的支持使得你可以選擇最合適的一對來使用，而且它也有利於伺服器和框架的開發者，這樣他們只需專註於其擅長的部分來進行開發，而不需要觸及另一部分的代碼。其它語言也擁有類似的介面，比如：Java 擁有 Servlet API，而 Ruby 擁有 Rack。

這些理論都不錯，但是我打賭你在說：「Show me the code!」 那好，我們來看看下面這個很小的 WSGI 伺服器實現：

### 使用 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):
        ### 創建一個監聽的套接字
        self.listen_socket = listen_socket = socket.socket(
            self.address_family,
            self.socket_type
        )
        ### 允許復用同一地址
        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        ### 綁定地址
        listen_socket.bind(server_address)
        ### 激活套接字
        listen_socket.listen(self.request_queue_size)
        ### 獲取主機的名稱及埠
        host, port = self.listen_socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port
        ### 返回由 Web 框架/應用設定的響應頭部欄位
        self.headers_set = []

    def set_app(self, application):
        self.application = application

    def serve_forever(self):
        listen_socket = self.listen_socket
        while True:
            ### 獲取新的客戶端連接
            self.client_connection, client_address = listen_socket.accept()
            ### 處理一條請求後關閉連接，然後循環等待另一個連接建立
            self.handle_one_request()

    def handle_one_request(self):
        self.request_data = request_data = self.client_connection.recv(1024)
        ### 以 'curl -v' 的風格輸出格式化請求數據
        print(''.join(
            &apos;< {line}n&apos;.format(line=line)
            for line in request_data.splitlines()
        ))

        self.parse_request(request_data)

        ### 根據請求數據構建環境變數字典
        env = self.get_environ()

        ### 此時需要調用 Web 應用來獲取結果，
        ### 取回的結果將成為 HTTP 響應體
        result = self.application(env, self.start_response)

        ### 構造一個響應，回送至客戶端
        self.finish_response(result)

    def parse_request(self, text):
        request_line = text.splitlines()[0]
        request_line = request_line.rstrip(&apos;rn&apos;)
        ### 將請求行分成幾個部分
        (self.request_method,  # GET
         self.path,            # /hello
         self.request_version  # HTTP/1.1
         ) = request_line.split()

    def get_environ(self):
        env = {}
        ### 以下代碼段沒有遵循 PEP8 規則，但這樣排版，是為了通過強調
        ### 所需變數及它們的值，來達到其展示目的。
        ###
        ### WSGI 必需變數
        env[&apos;wsgi.version&apos;]      = (1, 0)
        env[&apos;wsgi.url_scheme&apos;]   = &apos;http&apos;
        env[&apos;wsgi.input&apos;]        = StringIO.StringIO(self.request_data)
        env[&apos;wsgi.errors&apos;]       = sys.stderr
        env[&apos;wsgi.multithread&apos;]  = False
        env[&apos;wsgi.multiprocess&apos;] = False
        env[&apos;wsgi.run_once&apos;]     = False
        ### CGI 必需變數
        env[&apos;REQUEST_METHOD&apos;]    = self.request_method    # GET
        env[&apos;PATH_INFO&apos;]         = self.path              # /hello
        env[&apos;SERVER_NAME&apos;]       = self.server_name       # localhost
        env[&apos;SERVER_PORT&apos;]       = str(self.server_port)  # 8888
        return env

    def start_response(self, status, response_headers, exc_info=None):
        ### 添加必要的伺服器頭部欄位
        server_headers = [
            (&apos;Date&apos;, &apos;Tue, 31 Mar 2015 12:54:48 GMT&apos;),
            (&apos;Server&apos;, &apos;WSGIServer 0.2&apos;),
        ]
        self.headers_set = [status, response_headers + server_headers]
        ### 為了遵循 WSGI 協議，start_response 函數必須返回一個 &apos;write&apos;
        ### 可調用對象（返回值.write 可以作為函數調用）。為了簡便，我們
        ### 在這裡無視這個細節。
        ### return self.finish_response

    def finish_response(self, result):
        try:
            status, response_headers = self.headers_set
            response = &apos;HTTP/1.1 {status}rn&apos;.format(status=status)
            for header in response_headers:
                response += &apos;{0}: {1}rn&apos;.format(*header)
            response += &apos;rn&apos;
            for data in result:
                response += data
            ### 以 &apos;curl -v&apos; 的風格輸出格式化請求數據
            print(&apos;&apos;.join(
                &apos;> {line}n&apos;.format(line=line)
                for line in response.splitlines()
            ))
            self.client_connection.sendall(response)
        finally:
            self.client_connection.close()

SERVER_ADDRESS = (HOST, PORT) = &apos;&apos;, 8888

def make_server(server_address, application):
    server = WSGIServer(server_address)
    server.set_app(application)
    return server

if __name__ == &apos;__main__&apos;:
    if len(sys.argv) < 2:
        sys.exit(&apos;Provide a WSGI application object as module:callable&apos;)
    app_path = sys.argv[1]
    module, application = app_path.split(&apos;:&apos;)
    module = __import__(module)
    application = getattr(module, application)
    httpd = make_server(SERVER_ADDRESS, application)
    print(&apos;WSGIServer: Serving HTTP on port {port} ...n&apos;.format(port=PORT))
    httpd.serve_forever()

當然，這段代碼要比第一部分的伺服器代碼長不少，但它仍然很短（只有不到 150 行），你可以輕鬆理解它，而不需要深究細節。上面的伺服器代碼還可以做更多——它可以用來運行一些你喜歡的框架寫出的 Web 應用，可以是 Pyramid，Flask，Django 或其它 Python WSGI 框架。

不相信嗎？自己來試試看吧。把以上的代碼保存為 webserver2.py，或直接從 Github 上下載它。如果你打算不加任何參數而直接運行它，它會抱怨一句，然後退出。

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

它想做的其實是為你的 Web 應用服務，而這才是重頭戲。為了運行這個伺服器，你唯一需要的就是安裝好 Python。不過，如果你希望運行 Pyramid，Flask 或 Django 應用，你還需要先安裝那些框架。那我們把這三個都裝上吧。我推薦的安裝方式是通過 virtualenv 安裝。按照以下幾步來做，你就可以創建並激活一個虛擬環境，並在其中安裝以上三個 Web 框架。

$ [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

現在，你需要創建一個 Web 應用。我們先從 Pyramid 開始吧。把以下代碼保存為 pyramidapp.py，並與剛剛的 webserver2.py 放置在同一目錄，或直接從 Github 下載該文件：

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()

現在，你可以用你自己的 Web 伺服器來運行你的 Pyramid 應用了：

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

你剛剛讓你的伺服器去載入 Python 模塊 pyramidapp 中的可執行對象 app。現在你的伺服器可以接收請求，並將它們轉發到你的 Pyramid 應用中了。在瀏覽器中輸入 http://localhost:8888/hello ，敲一下回車，然後看看結果：

你也可以使用命令行工具 curl 來測試伺服器：

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

看看伺服器和 curl 向標準輸出流列印的內容吧。

現在來試試 Flask。運行步驟跟上面的一樣。

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

將以上代碼保存為 flaskapp.py，或者直接從 Github 下載，然後輸入以下命令運行伺服器：

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

現在在瀏覽器中輸入 http://localhost:8888/hello ，敲一下回車：

同樣，嘗試一下 curl，然後你會看到伺服器返回了一條 Flask 應用生成的信息：

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

這個伺服器能處理 Django 應用嗎？試試看吧！不過這個任務可能有點複雜，所以我建議你將整個倉庫克隆下來，然後使用 Github 倉庫中的 djangoapp.py 來完成這個實驗。這裡的源代碼主要是將 Django 的 helloworld 工程（已使用 Django 的 django-admin.py startproject 命令創建完畢）添加到了當前的 Python 路徑中，然後導入了這個工程的 WSGI 應用。（LCTT 譯註：除了這裡展示的代碼，還需要一個配合的 helloworld 工程才能工作，代碼可以參見 Github 倉庫。）

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

app = wsgi.application

將以上代碼保存為 djangoapp.py，然後用你的 Web 伺服器運行這個 Django 應用：

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

輸入以下鏈接，敲回車：

你這次也可以在命令行中測試——你之前應該已經做過兩次了——來確認 Django 應用處理了你的請求：

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

你試過了嗎？你確定這個伺服器可以與那三個框架搭配工作嗎？如果沒試，請去試一下。閱讀固然重要，但這個系列的內容是重新搭建，這意味著你需要親自動手干點活。去試一下吧。別擔心，我等著你呢。不開玩笑，你真的需要試一下，親自嘗試每一步，並確保它像預期的那樣工作。

好，你已經體驗到了 WSGI 的威力：它可以使 Web 伺服器及 Web 框架隨意搭配。WSGI 在 Python Web 伺服器及框架之間提供了一個微型介面。它非常簡單，而且在伺服器和框架端均可以輕易實現。下面的代碼片段展示了 WSGI 介面的伺服器及框架端實現：

def run_application(application):
    """伺服器端代碼。"""
    ### Web 應用/框架在這裡存儲 HTTP 狀態碼以及 HTTP 響應頭部，
    ### 伺服器會將這些信息傳遞給客戶端
    headers_set = []
    ### 用於存儲 WSGI/CGI 環境變數的字典
    environ = {}

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

    ### 伺服器喚醒可執行變數「application」，獲得響應頭部
    result = application(environ, start_response)
    ### 伺服器組裝一個 HTTP 響應，將其傳送至客戶端
    …

def app(environ, start_response):
    """一個空的 WSGI 應用"""
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return ['Hello world!']

run_application(app)

這是它的工作原理：

1. Web 框架提供一個可調用對象 application （WSGI 規範沒有規定它的實現方式）。
2. Web 伺服器每次收到來自客戶端的 HTTP 請求後，會喚醒可調用對象 applition。它會向該對象傳遞一個包含 WSGI/CGI 變數的環境變數字典 environ，以及一個可調用對象 start_response。
3. Web 框架或應用生成 HTTP 狀態碼和 HTTP 響應頭部，然後將它傳給 start_response 函數，伺服器會將其存儲起來。同時，Web 框架或應用也會返回 HTTP 響應正文。
4. 伺服器將狀態碼、響應頭部及響應正文組裝成一個 HTTP 響應，然後將其傳送至客戶端（這一步並不在 WSGI 規範中，但從邏輯上講，這一步應該包含在工作流程之中。所以為了明確這個過程，我把它寫了出來）

這是這個介面規範的圖形化表達：

到現在為止，你已經看過了用 Pyramid、Flask 和 Django 寫出的 Web 應用的代碼，你也看到了一個 Web 伺服器如何用代碼來實現另一半（伺服器端的） WSGI 規範。你甚至還看到了我們如何在不使用任何框架的情況下，使用一段代碼來實現一個最簡單的 WSGI Web 應用。

其實，當你使用上面的框架編寫一個 Web 應用時，你只是在較高的層面工作，而不需要直接與 WSGI 打交道。但是我知道你一定也對 WSGI 介面的框架部分感興趣，因為你在看這篇文章呀。所以，我們不用 Pyramid、Flask 或 Django，而是自己動手來創造一個最樸素的 WSGI Web 應用（或 Web 框架），然後將它和你的伺服器一起運行：

def app(environ, start_response):
    """一個最簡單的 WSGI 應用。

    這是你自己的 Web 框架的起點 ^_^
    """
    status = '200 OK'
    response_headers = [('Content-Type', 'text/plain')]
    start_response(status, response_headers)
    return ['Hello world from a simple WSGI application!n']

同樣，將上面的代碼保存為 wsgiapp.py 或直接從 Github 上下載該文件，然後在 Web 伺服器上運行這個應用，像這樣：

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

在瀏覽器中輸入下面的地址，然後按下回車。這是你應該看到的結果：

你剛剛在學習如何創建一個 Web 伺服器的過程中自己編寫了一個最樸素的 WSGI Web 框架！棒極了！

現在，我們再回來看看伺服器傳給客戶端的那些東西。這是在使用 HTTP 客戶端調用你的 Pyramid 應用時，伺服器生成的 HTTP 響應內容：

這個響應和你在本系列第一部分中看到的 HTTP 響應有一部分共同點，但它還多出來了一些內容。比如說，它擁有四個你曾經沒見過的 HTTP 頭部：Content-Type, Content-Length, Date 以及 Server。這些頭部內容基本上在每個 Web 伺服器返回的響應中都會出現。不過，它們都不是被嚴格要求出現的。這些 HTTP 請求/響應頭部欄位的目的在於它可以向你傳遞一些關於 HTTP 請求/響應的額外信息。

既然你對 WSGI 介面了解的更深了一些，那我再來展示一下上面那個 HTTP 響應中的各個部分的信息來源：

我現在還沒有對上面那個 environ 字典做任何解釋，不過基本上這個字典必須包含那些被 WSGI 規範事先定義好的 WSGI 及 CGI 變數值。伺服器在解析 HTTP 請求時，會從請求中獲取這些變數的值。這是 environ 字典應該有的樣子：

Web 框架會利用以上字典中包含的信息，通過字典中的請求路徑、請求動作等等來決定使用哪個視圖來處理響應、在哪裡讀取請求正文、在哪裡輸出錯誤信息（如果有的話）。

現在，你已經創造了屬於你自己的 WSGI Web 伺服器，你也使用不同 Web 框架做了幾個 Web 應用。而且，你在這個過程中也自己創造出了一個樸素的 Web 應用及框架。這個過程真是累人。現在我們來回顧一下，你的 WSGI Web 伺服器在服務請求時，需要針對 WSGI 應用做些什麼：

• 首先，伺服器開始工作，然後會載入一個可調用對象 application，這個對象由你的 Web 框架或應用提供
• 然後，伺服器讀取一個請求
• 然後，伺服器會解析這個請求
• 然後，伺服器會使用請求數據來構建一個 environ 字典
• 然後，它會用 environ 字典及一個可調用對象 start_response 作為參數，來調用 application，並獲取響應體內容。
• 然後，伺服器會使用 application 返回的響應體，和 start_response 函數設置的狀態碼及響應頭部內容，來構建一個 HTTP 響應。
• 最終，伺服器將 HTTP 響應回送給客戶端。

這基本上是伺服器要做的全部內容了。你現在有了一個可以正常工作的 WSGI 伺服器，它可以為使用任何遵循 WSGI 規範的 Web 框架（如 Django、Flask、Pyramid，還有你剛剛自己寫的那個框架）構建出的 Web 應用服務。最棒的部分在於，它可以在不用更改任何伺服器代碼的情況下，與多個不同的 Web 框架一起工作。真不錯。

在結束之前，你可以想想這個問題：「你該如何讓你的伺服器在同一時間處理多個請求呢？」

敬請期待，我會在第三部分向你展示一種解決這個問題的方法。乾杯！

順便，我在撰寫一本名為《搭個 Web 伺服器：從頭開始》的書。這本書講解了如何從頭開始編寫一個基本的 Web 伺服器，裡面包含本文中沒有的更多細節。訂閱郵件列表，你就可以獲取到這本書的最新進展，以及發布日期。

via: https://ruslanspivak.com/lsbaws-part2/

作者：Ruslan 譯者：StdioA 校對：wxy

本文由 LCTT 原創編譯，Linux中國 榮譽推出

本文轉載來自 Linux 中國: https://github.com/Linux-CN/archive