Python web伺服器3: 靜態伺服器&併發web伺服器

一、總體內容

• 1.1、顯示固定的頁面
• 1.2、tcp長連線和短連線
• 1.3、返回瀏覽器需要的介面分析：實現http伺服器的型別

二、顯示固定的頁面

• 2.1、伺服器端程式碼（TCP）

  import socket
  
  
  def server_client(new_socket):
        """為這個客戶端返回資料"""
        # # 組織相應 頭資訊(header)
        # 1.接收瀏覽器傳送過來的請求，即 http請求
        # GET / HTTP/1.1
        # ....
        request = new_socket.recv(1024)
        print(request)
  
        # 2.返回http格式的資料，給瀏覽器
        # 2.1、準備傳送給瀏覽器的資料---header
        response = "HTTP/1.1 200 OK\r\n" # 200表示找到這個資源
        response += "\r\n" # 用一個空的行與body進行隔開
        # 2.2、準備傳送給瀏覽器的資料 ---body
        response += "<h4>您好嗎？/h4>"
        new_socket.send(response.encode("utf-8"))
  
        # 3.關閉套接字
        new_socket.close()
  
  
  def main():
       """用來完成整體的控制"""
       # 1.建立套接字
       tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
       # 2.繫結
       tcp_server_socket.bind(("192.168.3.6", 7280))
       # 3.變為監聽套接字
       tcp_server_socket.listen(128)
  
       while True:
             # 4.等待客戶端的連結
             new_socket, client_addr = tcp_server_socket.accept()
             # 5.為這個客戶端服務
             server_client(new_socket)
  
       # 6.關閉監聽的套接字
       tcp_server_socket.close()
  
  
  if __name__ == '__main__':
       main()
  

  • 伺服器端

    
    
    

    伺服器端
  • 網頁端: 輸入 IP:埠號 就可以顯示網頁
    
    

    網頁端

三、tcp長連線和短連線
TCP在真正的讀寫操作之前，server與client之間必須建立一個連線，當讀寫操作完成後，雙方不再需要這個連線時它們可以釋放這個連線，連線的建立通過三次握手，釋放則需要四次握手，所以說每個連線的建立都是需要資源消耗和時間消耗的。

• 3.1、TCP通訊的整個過程，如下圖:

  
  
  

  三次握手、四次揮手

• 3.2、TCP短連線
  模擬一種TCP短連線的情況:

  • client 向 server 發起連線請求
  • server 接到請求，雙方建立連線
  • client 向 server 傳送訊息
  • server 回應 client
  • 一次讀寫完成，此時雙方任何一個都可以發起 close 操作

  在步驟5中，一般都是 client 先發起 close 操作。當然也不排除有特殊的情況。
  從上面的描述看，短連線一般只會在 client/server 間傳遞一次讀寫操作！

• 3.3、TCP長連線
  再模擬一種長連線的情況:

  • client 向 server 發起連線
  • server 接到請求，雙方建立連線
  • client 向 server 傳送訊息
  • server 回應 client
  • 一次讀寫完成，連線不關閉
  • 後續讀寫操作...
  • 長時間操作之後client發起關閉請求

• 3.4、TCP長/短連線操作過程

  • (1)、短連線的操作步驟是：建立連線——資料傳輸——關閉連線...建立連線——資料傳輸——關閉連線

    
    
    

    短連線

  • (2)、長連線的操作步驟是：建立連線——資料傳輸...（保持連線）...資料傳輸——關閉連線

    
    
    

    長連線

• 3.5、TCP長/短連線的優點和缺點

  • 長連線可以省去較多的TCP建立和關閉的操作，減少浪費，節約時間。對於頻繁請求資源的客戶來說，較適用長連線。
  • client與server之間的連線如果一直不關閉的話，會存在一個問題，隨著客戶端連線越來越多，server早晚有扛不住的時候，這時候server端需要採取一些策略，如關閉一些長時間沒有讀寫事件發生的連線，這樣可以避免一些惡意連線導致server端服務受損；
    如果條件再允許就可以以客戶端機器為顆粒度，限制每個客戶端的最大長連線數，這樣可以完全避免某個蛋疼的客戶端連累後端服務。
  • 短連線對於伺服器來說管理較為簡單，存在的連線都是有用的連線，不需要額外的控制手段。
  • 但如果客戶請求頻繁，將在TCP的建立和關閉操作上浪費時間和頻寬。

• 3.6、TCP長/短連線的應用場景

  • 長連線多用於操作頻繁，點對點的通訊，而且連線數不能太多情況。每個TCP連線都需要三次握手，這需要時間，如果每個操作都是先連線，再操作的話那麼處理速度會降低很多，所以每個操作完後都不斷開，再次處理時直接傳送資料包就OK了，不用建立TCP連線。
    例如：資料庫的連線用長連線，如果用短連線頻繁的通訊會造成socket錯誤，而且頻繁的socket 建立也是對資源的浪費。

  • 而像WEB網站的http服務一般都用短連結，因為長連線對於服務端來說會耗費一定的資源，而像WEB網站這麼頻繁的成千上萬甚至上億客戶端的連線用短連線會更省一些資源，如果用長連線，而且同時有成千上萬的使用者，如果每個使用者都佔用一個連線的話，那可想而知吧。所以併發量大，但每個使用者無需頻繁操作情況下需用短連好。

四、返回瀏覽器需要的介面分析 以及 併發伺服器

• 4.1、伺服器端程式碼

  import socket
  import re
  
  
  def server_client(new_socket):
        """為這個客戶端返回資料"""
        # # 組織相應 頭資訊(header)
        # 1.接收瀏覽器傳送過來的請求，即 http請求
        # GET / HTTP/1.1
        # ....
        request = new_socket.recv(1024).decode("utf-8")
        # print(request)
  
        request_lines = request.splitlines()
        print("")
        print(">"*20)
        print(request_lines)
  
        # GET /index.html HTTP/1.1
        # get post put del
        file_name = ""
        ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  
        if ret:
            file_name = ret.group(1)
            print("file_name=%s" % file_name)
            print("*"*50,file_name)
            if file_name == "/":
                file_name = "/index.html"
  
        # 2.返回http格式的資料，給瀏覽器
        # 2.1、準備傳送給瀏覽器的資料---header
        try:
             f = open("./html"+file_name,"rb")
        except:
             response = "HTTP/1.1 404 NOT FOUND\r\n"
             response += "\r\n"
             response += "----file not found"
             new_socket.send(response.encode("utf-8"))
        else:
             print("-----------OK------------")
             html_content = f.read()
             f.close()
  
             response = "HTTP/1.1 200 OK\r\n"  # 200表示找到這個資源
             response += "\r\n"  # 用一個空的行與body進行隔開
             # 2.2、準備傳送給瀏覽器的資料 ---body
             # 將response的header傳送給瀏覽器
             new_socket.send(response.encode("utf-8"))
             # 將response的 body 傳送給瀏覽器
             new_socket.send(html_content)
  
       # 3.關閉套接字
       new_socket.close()
  
  
  def main():
         """用來完成整體的控制"""
         # 1.建立套接字
         tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         # 2.繫結
         tcp_server_socket.bind(("192.168.3.6", 7590))
         # 3.變為監聽套接字
         tcp_server_socket.listen(128)
  
         while True:
               # 4.等待客戶端的連結
               new_socket, client_addr = tcp_server_socket.accept()
               # 5.為這個客戶端服務
               server_client(new_socket)
  
         # 6.關閉監聽的套接字
         tcp_server_socket.close()
  
  
  if __name__ == '__main__':
         main()
  

  分析一下上面程式碼中的正則：ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  ”^”這個字元是在中括號 []中被使用的話就是表示字元類的否定，如果不是的話就是表示限定開頭。我這裡說的是直接在[]中使用，不包括巢狀使用。
  其實也就是說 [] 代表的是一個字符集，^ 只有在字符集中才是反向字符集的意思。
  [^/]+(/[^ ]*： 意思是 : [^/]:除了 / 以外，+：至少一個字元，/[^ ]*：表示除了空格，也就是到空格就不匹配了，*：表示匹配前一個字元出現0次或者無限次，即可有可無

• 4.2、多程式實現http伺服器

  import socket
  import multiprocessing
  import re
  
  
  def server_client(new_socket):
      """為這個客戶端返回資料"""
      # # 組織相應 頭資訊(header)
      # 1.接收瀏覽器傳送過來的請求，即 http請求
      # GET / HTTP/1.1
      # ....
      request = new_socket.recv(1024).decode("utf-8")
      # print(request)
  
      request_lines = request.splitlines()
      print("")
      print(">"*20)
      print(request_lines)
  
      # GET /index.html HTTP/1.1
      # get post put del
      file_name = ""
      ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  
      if ret:
  
          file_name = ret.group(1)
  
          print("file_name=%s" % file_name)
  
          print("*"*50,file_name)
          if file_name == "/":
              file_name = "/index.html"
  
      # 2.返回http格式的資料，給瀏覽器
      # 2.1、準備傳送給瀏覽器的資料---header
  
      try:
          f = open("./html"+file_name,"rb")
      except:
          response = "HTTP/1.1 404 NOT FOUND\r\n"
          response += "\r\n"
          response += "----file not found"
          new_socket.send(response.encode("utf-8"))
      else:
  
          print("-----------OK------------")
  
          html_content = f.read()
          f.close()
  
          response = "HTTP/1.1 200 OK\r\n"  # 200表示找到這個資源
          response += "\r\n"  # 用一個空的行與body進行隔開
          # 2.2、準備傳送給瀏覽器的資料 ---body
          # 將response的header傳送給瀏覽器
          new_socket.send(response.encode("utf-8"))
          # 將response的 body 傳送給瀏覽器
          new_socket.send(html_content)
  
      # 3.關閉套接字
      new_socket.close()
  
  
  def main():
      """用來完成整體的控制"""
      # 1.建立套接字
      tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     # 2.繫結
     tcp_server_socket.bind(("192.168.3.6", 7590))
     # 3.變為監聽套接字
     tcp_server_socket.listen(128)
  
     while True:
         # 4.等待客戶端的連結
         new_socket, client_addr = tcp_server_socket.accept()
  
         # 5.開闢一個程式為這個客戶端服務
         p = multiprocessing.Process(target=server_client,args=(new_socket,))
         p.start()
  
         new_socket.close()
  
  
     # 6.關閉監聽的套接字
     tcp_server_socket.close()
  
  
  if __name__ == '__main__':
      main()
  

  • 提示：上面程式碼在while True:裡面有一個：new_socket.close(),因為程式是複製一份資源，程式裡面有一個new_socket指向資源，主程式也有一份指向資源，等子程式 new_socket 呼叫close()的時候，資源不會被釋放，所以在主程式先把指向子程式的資源釋放掉
  • 缺點：每一個子程式都要複製一份資源，如果很多很多客戶端，那麼伺服器的記憶體就很快用完，伺服器會承受不了，那麼我們就需要用 多執行緒 了

• 4.3、多執行緒實現http伺服器
  把上面程式碼在while True:改為如下

  import threading
  
  while True:
  
        # 4.等待客戶端的連結
        new_socket, client_addr = tcp_server_socket.accept()
  
        # 5.開闢一個程式為這個t客戶端服務
        t = threading.Thread(target=server_client,args=(new_socket,))
        t.start()
  

  • 提示：上面程式碼在while True:裡面沒有一個：new_socket.close(),因為多執行緒沒有複製一份資源，子執行緒 new_socket 呼叫close()的時候，資源被釋放
  • 缺點：每一個子執行緒都要開闢一條執行緒，如果很多很多客戶端，那麼伺服器也會受不了的，並不是子執行緒越多越好

• 4.3、協程gevent實現http伺服器

  import gevent
  from gevent import monkey
  
  
  # 將程式中用到的耗時操作的程式碼，換為gevent中自己實現的模組
  monkey.patch_all()
  
  
  while True:
        # 4.等待客戶端的連結
        new_socket, client_addr = tcp_server_socket.accept()
  
        # 5.開闢一個協程為這個t客戶端服務
        gevent.spawn(server_client,new_socket)
  

• 4.4、單程式非堵塞 模型

  from socket import *
  import time
  
  # 用來儲存所有的新連結的socket
  g_socket_list = list()
  
  def main():
      server_socket = socket(AF_INET, SOCK_STREAM)
      server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
      server_socket.bind(('', 7890))
      server_socket.listen(128)
      # 將套接字設定為非堵塞
      # 設定為非堵塞後，如果accept時，恰巧沒有客戶端connect，那麼accept會
      # 產生一個異常，所以需要try來進行處理
      server_socket.setblocking(False)
  
      while True:
  
           # 用來測試
           time.sleep(0.5)
  
           try:
                 newClientInfo = server_socket.accept()
           except Exception as result:
                 pass
           else:
                 print("一個新的客戶端到來:%s" % str(newClientInfo))
                 newClientInfo[0].setblocking(False)  # 設定為非堵塞
                 g_socket_list.append(newClientInfo)
  
                 for client_socket, client_addr in g_socket_list:
                      try:
                         recvData = client_socket.recv(1024)
                         if recvData:
                               print('recv[%s]:%s' % (str(client_addr), recvData))
                         else:
                               print('[%s]客戶端已經關閉' % str(client_addr))
                               client_socket.close()
                               g_socket_list.remove((client_socket,client_addr))
                      except Exception as result:
                              pass
  
             print(g_socket_list)  # for test
  
  if __name__ == '__main__':
       main()
  

• 4.5、epoll

  • IO 多路複用

    • 就是我們說的select，poll，epoll，有些地方也稱這種IO方式為event driven IO。
    • select/epoll的好處就在於單個process就可以同時處理多個網路連線的IO。
    • 它的基本原理就是select，poll，epoll這個function會不斷的輪詢所負責的所有socket，當某個socket有資料到達了，就通知使用者程式。

  • epoll 簡單模型

    import socket
    import select
    
    # 建立套接字
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 設定可以重複使用繫結的資訊
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
    
    # 繫結本機資訊
    s.bind(("",7788))
    
    # 變為被動
    s.listen(128)
    
    # 建立一個epoll物件
    epoll = select.epoll()
    
    # 測試，用來列印套接字對應的檔案描述符
    # print(s.fileno())
    # print(select.EPOLLIN|select.EPOLLET)
    
    # 註冊事件到epoll中
    # epoll.register(fd[, eventmask])
    # 注意，如果fd已經註冊過，則會發生異常
    # 將建立的套接字新增到epoll的事件監聽中
    epoll.register(s.fileno(), select.EPOLLIN|select.EPOLLET)
    
    connections = {}
    addresses = {}
    
    # 迴圈等待客戶端的到來或者對方傳送資料
    while True:
    
        # epoll 進行 fd 掃描的地方 -- 未指定超時時間則為阻塞等待
        epoll_list = epoll.poll()
    
        # 對事件進行判斷
        for fd, events in epoll_list:
    
              # print fd
              # print events
    
              # 如果是socket建立的套接字被啟用
              if fd == s.fileno():
                  new_socket, new_addr = s.accept()
    
                  print('有新的客戶端到來%s' % str(new_addr))
    
                  # 將 conn 和 addr 資訊分別儲存起來
                  connections[new_socket.fileno()] = new_socket
                  addresses[new_socket.fileno()] = new_addr
    
                  # 向 epoll 中註冊 新socket 的 可讀 事件
                  epoll.register(new_socket.fileno(), select.EPOLLIN|select.EPOLLET)
    
                  # 如果是客戶端傳送資料
              elif events == select.EPOLLIN:
                  # 從啟用 fd 上接收
                  recvData = connections[fd].recv(1024).decode("utf-8")
    
                   if recvData:
                        print('recv:%s' % recvData)
                   else:
                        # 從 epoll 中移除該 連線 fd
                        epoll.unregister(fd)
    
                        # server 側主動關閉該 連線 fd
                        connections[fd].close()
                        print("%s---offline---" % str(addresses[fd]))
                        del connections[fd]
                        del addresses[fd]
    

    說明
    - EPOLLIN （可讀）
    - EPOLLOUT （可寫）
    - EPOLLET （ET模式）
    epoll 對檔案描述符的操作有兩種模式：LT（level trigger）和ET（edge trigger）。LT模式是預設模式，LT模式與ET模式的區別如下：

    • LT模式：當epoll檢測到描述符事件發生並將此事件通知應用程式，應用程式可以不立即處理該事件。下次呼叫epoll時，會再次響應應用程式並通知此事件。
    • ET模式：當epoll檢測到描述符事件發生並將此事件通知應用程式，應用程式必須立即處理該事件。如果不處理，下次呼叫epoll時，不會再次響應應用程式並通知此事件。

  • web靜態伺服器-epool:以下程式碼，支援http的長連線，即使用了Content-Length(也就是返回內容的長度)

    import socket
    import time
    import sys
    import re
    import select
    
    
    class WSGIServer(object):
           """定義一個WSGI伺服器的類"""
    
          def __init__(self, port, documents_root):
    
               # 1. 建立套接字
               self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
               # 2. 繫結本地資訊
               self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
               self.server_socket.bind(("", port))
               # 3. 變為監聽套接字
               self.server_socket.listen(128)
    
               self.documents_root = documents_root
    
               # 建立epoll物件
               self.epoll = select.epoll()
               # 將tcp伺服器套接字加入到epoll中進行監聽
               self.epoll.register(self.server_socket.fileno(), select.EPOLLIN|select.EPOLLET)
    
                # 建立新增的fd對應的套接字
               self.fd_socket = dict()
    
          def run_forever(self):
               """執行伺服器"""
    
               # 等待對方連結
              while True:
                  # epoll 進行 fd 掃描的地方 -- 未指定超時時間則為阻塞等待
                  epoll_list = self.epoll.poll()
    
                  # 對事件進行判斷
                  for fd, event in epoll_list:
                       # 如果是伺服器套接字可以收資料，那麼意味著可以進行accept
                       if fd == self.server_socket.fileno():
                           new_socket, new_addr = self.server_socket.accept()
                           # 向 epoll 中註冊 連線 socket 的 可讀 事件
                           self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
                           # 記錄這個資訊
                           self.fd_socket[new_socket.fileno()] = new_socket
                       # 接收到資料
                       elif event == select.EPOLLIN:
                           request = self.fd_socket[fd].recv(1024).decode("utf-8")
                           if request:
                                self.deal_with_request(request, self.fd_socket[fd])
                           else:
                                # 在epoll中登出客戶端的資訊
                                self.epoll.unregister(fd)
                                # 關閉客戶端的檔案控制程式碼
                                self.fd_socket[fd].close()
                                # 在字典中刪除與已關閉客戶端相關的資訊
                                del self.fd_socket[fd]
    
           def deal_with_request(self, request, client_socket):
                  """為這個瀏覽器伺服器"""
    
                 if not request:
                     return
    
                 request_lines = request.splitlines()
                 for i, line in enumerate(request_lines):
                        print(i, line)
    
                 # 提取請求的檔案(index.html)
                 # GET /a/b/c/d/e/index.html HTTP/1.1
                 ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
                 if ret:
                    print("正則提取資料:", ret.group(1))
                    print("正則提取資料:", ret.group(2))
                    file_name = ret.group(2)
                    if file_name == "/":
                          file_name = "/index.html"
    
    
                 # 讀取檔案資料
                 try:
                    f = open(self.documents_root+file_name, "rb")
                 except:
                    response_body = "file not found, 請輸入正確的url"
    
                    response_header = "HTTP/1.1 404 not found\r\n"
                    response_header += "Content-Type: text/html; charset=utf-8\r\n"
                    response_header += "Content-Length: %d\r\n" % len(response_body)
                    response_header += "\r\n"
    
                    # 將header返回給瀏覽器
                    client_socket.send(response_header.encode('utf-8'))
    
                    # 將body返回給瀏覽器
                    client_socket.send(response_body.encode("utf-8"))
                 else:
                    content = f.read()
                    f.close()
    
                    response_body = content
    
                    response_header = "HTTP/1.1 200 OK\r\n"
                    response_header += "Content-Length: %d\r\n" % len(response_body)
                    response_header += "\r\n"
    
                    # 將資料返回給瀏覽器
                    client_socket.send(response_header.encode("utf-8")+response_body)
    
    
    # 設定伺服器服務靜態資源時的路徑
    DOCUMENTS_ROOT = "./html"
    
    
    def main():
          """控制web伺服器整體"""
          # python3 xxxx.py 7890
          if len(sys.argv) == 2:
               port = sys.argv[1]
               if port.isdigit():
                    port = int(port)
          else:
               print("執行方式如: python3 xxx.py 7890")
               return
    
          print("http伺服器使用的port:%s" % port)
          http_server = WSGIServer(port, DOCUMENTS_ROOT)
          http_server.run_forever()
    
    
    if __name__ == "__main__":
          main()
    

  • 總結：I/O 多路複用的特點：‘

    通過一種機制使一個程式能同時等待多個檔案描述符，而這些檔案描述符（套接字描述符）其中的任意一個進入讀就緒狀態，epoll()函式就可以返回。 所以, IO多路複用，本質上不會有併發的功能，因為任何時候還是隻有一個程式或執行緒進行工作，它之所以能提高效率是因為select\epoll 把進來的socket放到他們的 '監視' 列表裡面，當任何socket有可讀可寫資料立馬處理，那如果select\epoll 手裡同時檢測著很多socket， 一有動靜馬上返回給程式處理，總比一個一個socket過來,阻塞等待,處理高效率。

    當然也可以多執行緒/多程式方式，一個連線過來開一個程式/執行緒處理，這樣消耗的記憶體和程式切換頁會耗掉更多的系統資源。 所以我們可以結合IO多路複用和多程式/多執行緒 來高效能併發，IO複用負責提高接受socket的通知效率，收到請求後，交給程式池/執行緒池來處理邏輯。