Explain how the SocketServer module in Python handles network requests

SocketServer creates a network service framework. It defines classes to handle synchronous network requests over TCP, UDP, UNIX streams and UNIX datagrams.

1. Server Types

There are five different server classes in SocketServer.

1.BaseServer defines the API, and it is not used for instantiation and direct use.
2.TCPServer is used for TCP/IP socket communication.
3.UDPServer uses datagram sockets.
4.UnixStreamServer and UnixDatagramServer use Unix-domain sockets and are intelligently used on unix platforms.

2. Server Objects

Build a server through which the requested address and requested processing class (not instance) can be monitored.

1.class SocketServer.BaseServer
This is the super class of all server objects in the module. It defines the interface and most of the implementation is completed in subclasses.

2.BaseServer.fileno

Returns an integer file descriptor to indicate which server is listening. This function is most commonly passed to select.select(), allowing multiple services to monitor the same process.

3.BaseServer.handle_request

To process a single request, this function will call the following methods sequentially. get_request(), verify_request and proccess_request.
The user provides the handle() method and throws an exception, then the handle_error() method will be called.
If no request is received within self.timeout, handle_timeout() and handle_request() will return.

4.BaseServer.serve_forever

BaseServer.serve_forever(poll_interval=0.5), handles requests until a clear shutdown() request. The rotation training is closed every poll_interval time. Ignore self.timeout. If you need to use scheduled tasks, you need to use other threads.

5.BaseServer.shutdown

Tell serve_forever() to stop the loop.

6.BaseServer.RequestHandlerClass

User request handler class, create an instance of this class for each request.

3. Implementing a Server

If you create a server, it can usually reuse existing classes and simply provide a custom request handling class. There are several BaseServer methods to override a subclass if that doesn't meet your needs.

1.verify_request(reqeust, client_address): Must return a Boolean value. If True is returned, the request will be processed. If False is returned, the request will be rejected. This function can be overridden to implement access control services.
2.process_request(request, client_address): Call finish_request to create an instance of RequestHandlerClass(). If needed, this function can create a new process or coroutine to handle the request.
3.finish_request(request, client_address): Create a request processing instance. Call handle() to handle the request.

4. Request Handlers

Request handlers do most of the work to receive incoming requests and decide what action to take. The handler is responsible for implementing the socket layer on the "protocol" (for example, HTTP or XML-RPC). Reads the request data from the incoming request handler, processes it, and writes a response. There are three ways to override this.

1.setup(): Prepare the request handler for the request, which is initialized and run before the handle.
2.handle(): Do the real request work. Parse incoming requests, process data and return responses.
3.finish(): Clean up the setup() created at any time.

5. Example

The following example shows tcp, udp and asynchronous

1.TCPServer example

import SocketServer


class MyHandler(SocketServer.BaseRequestHandler):
  
  def handle(self):
    self.data = self.request.recv(1024).strip()
    print '{} wrote:'.format(self.client_address[0])
    print self.data
    self.request.sendall(self.data.upper())


if __name__ == '__main__':
  HOST, PORT = 'localhost', 9999
  server = SocketServer.TCPServer((HOST, PORT), MyHandler)
  server.serve_forever()

##2.UDPSerr example

import SocketServer


class MyHandler(SocketServer.BaseRequestHandler):

  def handle(self):
    data = self.request[0].strip()
    socket = self.request[1]
    print '{} wrote:'.format(self.client_address[0])
    print data
    socket.sendto(data.upper(), self.client_address)


if __name__ == '__main__':
  HOST, PORT = 'localhost', 9999
  server = SocketServer.UDPServer((HOST, PORT), MyHandler)
  server.serve_forever()

3. Asynchronous examples

Asynchronous handlers can be constructed through the ThreadingMixIn and ForkingMixIn classes.

import socket
import threading
import SocketServer


class MyHandler(SocketServer.BaseRequestHandler):

  def handle(self):
    data = self.request.recv(1024)
    curr_thread = threading.current_thread()
    response = '{}: {}'.format(curr_thread.name, data)
    self.request.sendall(response)


class Server(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
  pass


def client(ip, port, message):
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.connect((ip, port))
  try:
    sock.sendall(message)
    response = sock.recv(1024)
    print 'Received: {}'.format(response)
  finally:
    sock.close()


if __name__ == '__main__':
  HOST, PORT = 'localhost', 0

  server = Server((HOST, PORT), MyHandler)
  ip, port = server.server_address

  serer_thread = threading.Thread(target=server.serve_forever)
  server_thread.daemon = True
  server_thread.start()
  print 'Server loop running in thread:', server_thread.name

  client(ip, port, 'Hello World 1')
  client(ip, port, 'Hello World 2')
  client(ip, port, 'Hello World 3')

  server.shutdown()
  server.server_close()

4.SocketServer implements non-blocking communication between client and server
(1) Creation SocketServerTCP server

#创建SocketServerTCP服务器： 
import SocketServer 
from SocketServer import StreamRequestHandler as SRH 
from time import ctime 
 
host = 'xxx.xxx.xxx.xxx' 
port = 9999 
addr = (host,port) 
 
class Servers(SRH): 
  def handle(self): 
    print 'got connection from ',self.client_address 
    self.wfile.write('connection %s:%s at %s succeed!' % (host,port,ctime())) 
    while True: 
      data = self.request.recv(1024) 
      if not data:  
        break 
      print data 
      print "RECV from ", self.client_address[0] 
      self.request.send(data) 
print 'server is running....' 
server = SocketServer.ThreadingTCPServer(addr,Servers) 
server.serve_forever()

(2) Create SocketServerTCP client

from socket import * 
 
host = 'xxx.xxx.xxx.xxx' 
port = 9999 
bufsize = 1024 
addr = (host,port) 
client = socket(AF_INET,SOCK_STREAM) 
client.connect(addr) 
while True: 
  data = raw_input() 
  if not data or data=='exit': 
    break 
  client.send('%s\r\n' % data) 
  data = client.recv(bufsize) 
  if not data: 
    break 
  print data.strip() 
client.close()

For more information on how the SocketServer module in Python handles network requests, please pay attention to the PHP Chinese website for related articles!