11.2 创建TCP服务器

问题

你想实现一个服务器，通过TCP协议和客户端通信。

解决方案

创建一个TCP服务器的一个简单方法是使用 socketserver 库。例如，下面是一个简单的应答服务器：

  1. from socketserver import BaseRequestHandler, TCPServer
  2.  
  3. class EchoHandler(BaseRequestHandler):
  4.     def handle(self):
  5.         print('Got connection from', self.client_address)
  6.         while True:
  7.  
  8.             msg = self.request.recv(8192)
  9.             if not msg:
  10.                 break
  11.             self.request.send(msg)
  12.  
  13. if __name__ == '__main__':
  14.     serv = TCPServer(('', 20000), EchoHandler)
  15.     serv.serve_forever()

在这段代码中，你定义了一个特殊的处理类，实现了一个 handle() 方法，用来为客户端连接服务。request 属性是客户端socket，client_address 有客户端地址。为了测试这个服务器，运行它并打开另外一个Python进程连接这个服务器：

  1. >>> from socket import socket, AF_INET, SOCK_STREAM
  2. >>> s = socket(AF_INET, SOCK_STREAM)
  3. >>> s.connect(('localhost', 20000))
  4. >>> s.send(b'Hello')
  5. 5
  6. >>> s.recv(8192)
  7. b'Hello'
  8. >>>

很多时候，可以很容易的定义一个不同的处理器。下面是一个使用 StreamRequestHandler基类将一个类文件接口放置在底层socket上的例子：

  1. from socketserver import StreamRequestHandler, TCPServer
  2.  
  3. class EchoHandler(StreamRequestHandler):
  4.     def handle(self):
  5.         print('Got connection from', self.client_address)
  6.         # self.rfile is a file-like object for reading
  7.         for line in self.rfile:
  8.             # self.wfile is a file-like object for writing
  9.             self.wfile.write(line)
  10.  
  11. if __name__ == '__main__':
  12.     serv = TCPServer(('', 20000), EchoHandler)
  13.     serv.serve_forever()

讨论

socketserver 可以让我们很容易的创建简单的TCP服务器。但是，你需要注意的是，默认情况下这种服务器是单线程的，一次只能为一个客户端连接服务。如果你想处理多个客户端，可以初始化一个 ForkingTCPServer 或者是 ThreadingTCPServer 对象。例如：

  1. from socketserver import ThreadingTCPServer
  2.  
  3.  
  4. if __name__ == '__main__':
  5.     serv = ThreadingTCPServer(('', 20000), EchoHandler)
  6.     serv.serve_forever()

使用fork或线程服务器有个潜在问题就是它们会为每个客户端连接创建一个新的进程或线程。由于客户端连接数是没有限制的，因此一个恶意的黑客可以同时发送大量的连接让你的服务器奔溃。

如果你担心这个问题，你可以创建一个预先分配大小的工作线程池或进程池。你先创建一个普通的非线程服务器，然后在一个线程池中使用 serve_forever() 方法来启动它们。

  1. if __name__ == '__main__':
  2.     from threading import Thread
  3.     NWORKERS = 16
  4.     serv = TCPServer(('', 20000), EchoHandler)
  5.     for n in range(NWORKERS):
  6.         t = Thread(target=serv.serve_forever)
  7.         t.daemon = True
  8.         t.start()
  9.     serv.serve_forever()

一般来讲，一个 TCPServer 在实例化的时候会绑定并激活相应的 socket 。不过，有时候你想通过设置某些选项去调整底下的 socket` ，可以设置参数 bind_and_activate=False 。如下：

  1. if __name__ == '__main__':
  2.     serv = TCPServer(('', 20000), EchoHandler, bind_and_activate=False)
  3.     # Set up various socket options
  4.     serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
  5.     # Bind and activate
  6.     serv.server_bind()
  7.     serv.server_activate()
  8.     serv.serve_forever()

上面的 socket 选项是一个非常普遍的配置项，它允许服务器重新绑定一个之前使用过的端口号。由于要被经常使用到，它被放置到类变量中，可以直接在 TCPServer 上面设置。在实例化服务器的时候去设置它的值，如下所示：

  1. if __name__ == '__main__':
  2.     TCPServer.allow_reuse_address = True
  3.     serv = TCPServer(('', 20000), EchoHandler)
  4.     serv.serve_forever()

在上面示例中，我们演示了两种不同的处理器基类（ BaseRequestHandler 和 StreamRequestHandler ）。StreamRequestHandler 更加灵活点，能通过设置其他的类变量来支持一些新的特性。比如：

  1. import socket
  2.  
  3. class EchoHandler(StreamRequestHandler):
  4.     # Optional settings (defaults shown)
  5.     timeout = 5                      # Timeout on all socket operations
  6.     rbufsize = -1                    # Read buffer size
  7.     wbufsize = 0                     # Write buffer size
  8.     disable_nagle_algorithm = False  # Sets TCP_NODELAY socket option
  9.     def handle(self):
  10.         print('Got connection from', self.client_address)
  11.         try:
  12.             for line in self.rfile:
  13.                 # self.wfile is a file-like object for writing
  14.                 self.wfile.write(line)
  15.         except socket.timeout:
  16.             print('Timed out!')

最后，还需要注意的是巨大部分Python的高层网络模块（比如HTTP、XML-RPC等）都是建立在 socketserver 功能之上。也就是说，直接使用 socket 库来实现服务器也并不是很难。下面是一个使用 socket 直接编程实现的一个服务器简单例子：

  1. from socket import socket, AF_INET, SOCK_STREAM
  2.  
  3. def echo_handler(address, client_sock):
  4.     print('Got connection from {}'.format(address))
  5.     while True:
  6.         msg = client_sock.recv(8192)
  7.         if not msg:
  8.             break
  9.         client_sock.sendall(msg)
  10.     client_sock.close()
  11.  
  12. def echo_server(address, backlog=5):
  13.     sock = socket(AF_INET, SOCK_STREAM)
  14.     sock.bind(address)
  15.     sock.listen(backlog)
  16.     while True:
  17.         client_sock, client_addr = sock.accept()
  18.         echo_handler(client_addr, client_sock)
  19.  
  20. if __name__ == '__main__':
  21.     echo_server(('', 20000))

原文:

http://python3-cookbook.readthedocs.io/zh_CN/latest/c11/p02_creating_tcp_server.html