Python开发【第八章】：Socket

一、Socket

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

socket和file的区别：

• file模块是针对某个指定文件进行【打开】【读写】【关闭】
• socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

1、信息交互的程序

服务端：

#server端
 
import socket
 
ip_port = ("127.0.0.1",9999)    #服务器端ip和服务端口
server = socket.socket()            #创建server
#server = <socket.socket fd=344, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0>
 
server.bind(ip_port)                #绑定地址ip
#server = <socket.socket fd=344, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999)>
server.listen(5)                    #开始监听，允许5个客户端排队
conn,addr = server.accept()         #等待连接
#conn = <socket.socket fd=340, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999),
#  raddr=('127.0.0.1', 60086)>
#addr = ('127.0.0.1', 60086)
 
client_data = conn.recv(1024)       #收取信息，1024字节
#client_data = b'hello'
conn.sendall(client_data.upper())           #发送数据
 
conn.close()                        #关闭程序

客户端：

#client端
 
import socket
 
ip_port = ("127.0.0.1",9999)        #要连接的服务器IP和端口
client = socket.socket()             #创建client
 
client.connect(ip_port)              #连接服务器端
info = "hello"
 
client.sendall(info.encode("utf-8"))   #发送数据包,把str转换为bytes类型
server_data = client.recv(1024)         #收取数据包
 
print(server_data.decode("utf-8"))

注：如果客户端发送空字符给服务端，客户端发送没有问题，但是服务器是不会接受空字符的，服务器依然会停留在接受状态，程序会一直卡着

2、功能介绍

① server = socket.socket()

参数一：地址簇
 
　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6
 
　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
 
参数二：类型
 
　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP
 
　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务
 
参数三：协议
 
　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

详情

# 服务端
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)
 
while True:
    data,(host,port) = sk.recvfrom(1024)
    print(data,host,port)
    sk.sendto(bytes('ok', encoding='utf-8'), (host,port))
 
#客户端
import socket
ip_port = ('127.0.0.1',9999)
 
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
    inp = input('数据：').strip()
    if inp == 'exit':
        break
    sk.sendto(bytes(inp, encoding='utf-8'),ip_port)
    data = sk.recvfrom(1024)
    print(data)
 
sk.close()

UDP Demo

② server.bind(address)

　　server.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址

③ server.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5,这个值不能无限大，因为要在内核中维护连接队列

④ server.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错

⑤ conn,addr = server.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。接收TCP 客户的连接（阻塞式）等待连接的到来

⑥ client.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

⑦ client.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

⑧ client.close()

　　关闭套接字

⑨ client.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略

⑩ client.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址

⑪ server.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送

⑫ server.sendall(string[,flag])　　

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常；

内部通过递归调用send，将所有内容发送出去

⑬ server.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议

⑭ sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

⑮ sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）

⑯ sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

⑰ sk.fileno()

　　套接字的文件描述符

3、聊天机器人

我们对上面的代码进行下升级，做个聊天机器人

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#server
 
import socket
 
ip_port = ("127.0.0.1",8888)
server = socket.socket()
server.bind(ip_port)
server.listen(5)
 
while True:
    print("等待连接........")
    conn, addr = server.accept()
    while True:
        data = conn.recv(1024).decode("utf-8")
        if data == "exit":
            conn.sendall("exit".encode("utf-8"))
            break
        elif data == "":
            conn.sendall("汪星人星球正要进攻地球。。。。".encode("utf-8"))
        else:
            print(data)
            conn.sendall("继续发送电波".encode("utf-8"))
    conn.close()

server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#client
 
import socket
 
ip_port = ("127.0.0.1",8888)
client = socket.socket()
client.connect(ip_port)
 
while True:
    info = input("->>>")
    client.sendall(info.encode("utf-8"))
    data = client.recv(1024).decode("utf-8")
    if data == "exit":
        break
    else:
            print(data)
client.close()

client端

4、ssh程序

整合下上面的代码，做个ssh连接的客户端，实现基本xshell功能

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#ssh server
 
import socket,os
 
ip_port = ("127.0.0.1",9999)
server = socket.socket()
server.bind(ip_port)
server.listen(5)
 
while True:
    conn,add = server.accept()
    while True:
        client_data = conn.recv(1024)
        recv_data = client_data.decode("utf-8")
        if recv_data == "exit":
            break
        send_data = os.popen(recv_data).read()
        if not send_data:
            conn.sendall(client_data+"命令不存在".encode("utf-8"))
        else:
            conn.sendall(send_data.encode("utf-8"))
    conn.close()

ssh 服务端

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#ssh client
 
import socket
 
ip_port = ("127.0.0.1",9999)
client = socket.socket()
client.connect(ip_port)
 
while True:
    info = input("->>").strip()
    if not info:
        continue
    client.sendall(info.encode("utf-8"))
    if info == "exit":
        break
    server_data = client.recv(1024)
    print(server_data.decode("utf-8"))
 
client.close()

ssh 客户端

5、粘包

ssh程序运行的时候会出现一个问题，啥问题类？当我们执行ipconfig /all 命令时，服务器给返回的信息是不完整的，当我们再次执行其他命令时，返回的信息依然是ipconfig /all上次未传完的数据；这是由于我们每次传输的数据只能是字节，未传完的数据只能等待下次传输，这个现象就是粘包现象。那好，我们直接把1024字节调成无穷大不就好了，呵呵！！ 调大并没有卵用；难道就没有办法解决了吗？！突然想到一个办法了，发送数据前，先把数据包的大小发过来，我循环收取，直到收到的数据与数据包大小一样不就得了。哈哈，机智如我~嘎嘎

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#ssh server
 
import socket,os
 
ip_port = ("127.0.0.1",9999)
server = socket.socket()
server.bind(ip_port)
server.listen(5)
 
while True:
    conn,add = server.accept()
    while True:
        print("开始收")
        client_data = conn.recv(1024)
        client_data = client_data.decode("utf-8")
        if client_data == "exit":           #收到exit 退出
            break
        send_data = os.popen(client_data).read()    #执行命令结果，要发送的数据
 
        send_data = send_data.encode("utf-8")       #转换为bytes类型
 
        length = str(len(send_data))              #统计发送数据的长度
        conn.sendall(length.encode("utf-8"))      #长度以bytes类型发送过去
 
        return_value = conn.recv(1024)
        return_value = return_value.decode("utf-8")
 
        if return_value == "start":
              conn.sendall(send_data)
    conn.close()

ssh 服务端升级版

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#ssh client
 
import socket
 
ip_port = ("127.0.0.1",9999)
client = socket.socket()
client.connect(ip_port)
 
while True:
    cmd = input("->>").strip()
    if not cmd:                 #空字符 重新输入
        continue
    client.sendall(cmd.encode("utf-8"))     #要执行的命令发送过去
    if cmd == "exit":           #如果为exit 退出连接
        break
 
    length = client.recv(1024)     #数据长度
    length = length.decode("utf-8")
    length = int(length)            #长度转换为int
 
    client.sendall("start".encode("utf-8"))     #发送字节start
 
    sum_data = b""                   #初始汇总的数据
    while length > 0:              #循环收数据
        server_data = client.recv(1024)
        length -=len(server_data)
        sum_data +=server_data
    print(sum_data.decode("utf-8"))                 #打印最终的执行数据
 
client.close()

ssh 客户端升级版

注：int类型在socket传输中，要先把int类型转换为str格式，再转化为bytes类型；另当前程序只能实现一对一，还不能一对多处理，思考下如何能多用户同时使用？

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
import socket,os,hashlib
 
ip_port = ("127.0.0.1",9999)
server = socket.socket()
server.bind(ip_port)
server.listen(5)
 
while True:
    conn,add = server.accept()
    while True:
        print("开始")
        data = conn.recv(1024)
 
        cmd,filename = data.decode().split()
        if os.path.isfile(filename):
            with open(filename,"rb") as file:
                file_size = os.stat(filename).st_size
                conn.sendall(str(file_size).encode())   #发送文件大小
                ack = conn.recv(1024)           #等待ack
                m = hashlib.md5()
                for line in file:
                    m.update(line)
                    conn.sendall(line)
            conn.sendall(m.hexdigest().encode())
    conn.close()

ftp 上传服务端

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
import socket,hashlib
 
ip_port = ("127.0.0.1",9999)
client = socket.socket()
client.connect(ip_port)
 
while True:
    cmd = input("->>").strip()
    if not cmd:continue
    client.sendall(cmd.encode())     #要执行的命令发送过去
    if cmd.startswith("get"):
        filename = cmd.split()[1]
        server_response = client.recv(1024)
        file_total_size = int(server_response.decode())
        client.sendall("ok".encode())
        with open("%s"%filename,"wb") as file:
            revice_size = 0
            m = hashlib.md5()
            while revice_size < file_total_size:
                if file_total_size - revice_size > 1024:
                    size =1024
                else:
                    size = file_total_size - revice_size
                data = client.recv(size)
                revice_size += len(data)
                file.write(data)
                m.update(data)
                print(file_total_size,revice_size,file_total_size - revice_size)
 
            new_file_md5 = m.hexdigest()
            server_file_md5 = client.recv(1024).decode()
            print("new",new_file_md5)
            print("old",server_file_md5)
 
client.close()

ftp 上传服务端

二、socketserver（多连接）

　　正如前面的socket模块部分看到的一样，写一个简单套接字服务器不是很难，如果想实现超出继承的应用，最好寻求一些帮助，socketserver模块是标准库中很多服务器框架的基础，这些服务器架构包括BaseHTTPServer、SimpleHTTPServer、CGIHTTPServer、SimpleXMLRPCServer、DocXMLRPCServer,所有的这些服务器框架都为基础服务器增加了特定功能；

　　socketserver内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求

ThreadingTCPServer（多线程，真并发）

ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

使用ThreadingTCPServer:

• 创建一个继承自 SocketServer.BaseRequestHandler 的类
• 类中必须定义一个名称为 handle 的方法
• 启动ThreadingTCPServer

用socketserver对ssh程序做修改，实现多用户同时操作互不影响

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#scoketserver
 
import socketserver,os
 
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            conn = self.request
           # conn,add = server.accept()
            while True:
                print("开始收")
                client_data = conn.recv(1024)
                client_data = client_data.decode("utf-8")
                if client_data == "exit":           #收到exit 退出
                    break
                send_data = os.popen(client_data).read()    #执行命令结果，要发送的数据
                send_data = send_data.encode("utf-8")       #转换为bytes类型
 
                length = str(len(send_data))              #统计发送数据的长度
                conn.sendall(length.encode("utf-8"))      #长度以bytes类型发送过去
 
                return_value = conn.recv(1024)
                return_value = return_value.decode("utf-8")
 
                if return_value == "start":
                    if not send_data:            # 如果执行结果为空，表示命令不存在
                        conn.sendall((client_data +"命令不存在").encode("utf-8"))
                    else:
                      conn.sendall(send_data)
            conn.close()
 
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(("127.0.0.1",8888),Myserver)
    server.serve_forever()

ssh 服务端多用户同时连接

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
 
#ssh client
 
import socket
 
ip_port = ("127.0.0.1",8888)
client = socket.socket()
client.connect(ip_port)
 
while True:
    cmd = input("->>").strip()
    if not cmd:                 #空字符 重新输入
        continue
    client.sendall(cmd.encode("utf-8"))     #要执行的命令发送过去
    if cmd == "exit":           #如果为exit 退出连接
        break
 
    length = client.recv(1024)     #数据长度
    length = length.decode("utf-8")
    length = int(length)            #长度转换为int
 
    client.sendall("start".encode("utf-8"))     #发送字节start
 
    sum_data = ""                   #初始汇总的数据
    while length >= 0:              #循环收数据
        server_data = client.recv(1024)
        length -=1024
        sum_data +=server_data.decode("utf-8")
    print(sum_data)                 #打印最终的执行数据
 
client.close()

ssh 客户端多用户同时连接

ThreadingTCPServer源码剖析

内部调用流程为：

• 启动服务端程序
• 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
• 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
• 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
• 当客户端连接到达服务器
• 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
• 执行 ThreadingMixIn.process_request_thread 方法
• 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass()  即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）

相关源码：

class BaseServer:
 
    """Base class for server classes.
 
    Methods for the caller:
 
    - __init__(server_address, RequestHandlerClass)
    - serve_forever(poll_interval=0.5)
    - shutdown()
    - handle_request()  # if you do not use serve_forever()
    - fileno() -> int   # for select()
 
    Methods that may be overridden:
 
    - server_bind()
    - server_activate()
    - get_request() -> request, client_address
    - handle_timeout()
    - verify_request(request, client_address)
    - server_close()
    - process_request(request, client_address)
    - shutdown_request(request)
    - close_request(request)
    - handle_error()
 
    Methods for derived classes:
 
    - finish_request(request, client_address)
 
    Class variables that may be overridden by derived classes or
    instances:
 
    - timeout
    - address_family
    - socket_type
    - allow_reuse_address
 
    Instance variables:
 
    - RequestHandlerClass
    - socket
 
    """
 
    timeout = None
 
    def __init__(self, server_address, RequestHandlerClass):
        """Constructor.  May be extended, do not override."""
        self.server_address = server_address
        self.RequestHandlerClass = RequestHandlerClass
        self.__is_shut_down = threading.Event()
        self.__shutdown_request = False
 
    def server_activate(self):
        """Called by constructor to activate the server.
 
        May be overridden.
 
        """
        pass
 
    def serve_forever(self, poll_interval=0.5):
        """Handle one request at a time until shutdown.
 
        Polls for shutdown every poll_interval seconds. Ignores
        self.timeout. If you need to do periodic tasks, do them in
        another thread.
        """
        self.__is_shut_down.clear()
        try:
            while not self.__shutdown_request:
                # XXX: Consider using another file descriptor or
                # connecting to the socket to wake this up instead of
                # polling. Polling reduces our responsiveness to a
                # shutdown request and wastes cpu at all other times.
                r, w, e = _eintr_retry(select.select, [self], [], [],
                                       poll_interval)
                if self in r:
                    self._handle_request_noblock()
        finally:
            self.__shutdown_request = False
            self.__is_shut_down.set()
 
    def shutdown(self):
        """Stops the serve_forever loop.
 
        Blocks until the loop has finished. This must be called while
        serve_forever() is running in another thread, or it will
        deadlock.
        """
        self.__shutdown_request = True
        self.__is_shut_down.wait()
 
    # The distinction between handling, getting, processing and
    # finishing a request is fairly arbitrary.  Remember:
    #
    # - handle_request() is the top-level call.  It calls
    #   select, get_request(), verify_request() and process_request()
    # - get_request() is different for stream or datagram sockets
    # - process_request() is the place that may fork a new process
    #   or create a new thread to finish the request
    # - finish_request() instantiates the request handler class;
    #   this constructor will handle the request all by itself
 
    def handle_request(self):
        """Handle one request, possibly blocking.
 
        Respects self.timeout.
        """
        # Support people who used socket.settimeout() to escape
        # handle_request before self.timeout was available.
        timeout = self.socket.gettimeout()
        if timeout is None:
            timeout = self.timeout
        elif self.timeout is not None:
            timeout = min(timeout, self.timeout)
        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)
        if not fd_sets[0]:
            self.handle_timeout()
            return
        self._handle_request_noblock()
 
    def _handle_request_noblock(self):
        """Handle one request, without blocking.
 
        I assume that select.select has returned that the socket is
        readable before this function was called, so there should be
        no risk of blocking in get_request().
        """
        try:
            request, client_address = self.get_request()
        except socket.error:
            return
        if self.verify_request(request, client_address):
            try:
                self.process_request(request, client_address)
            except:
                self.handle_error(request, client_address)
                self.shutdown_request(request)
 
    def handle_timeout(self):
        """Called if no new request arrives within self.timeout.
 
        Overridden by ForkingMixIn.
        """
        pass
 
    def verify_request(self, request, client_address):
        """Verify the request.  May be overridden.
 
        Return True if we should proceed with this request.
 
        """
        return True
 
    def process_request(self, request, client_address):
        """Call finish_request.
 
        Overridden by ForkingMixIn and ThreadingMixIn.
 
        """
        self.finish_request(request, client_address)
        self.shutdown_request(request)
 
    def server_close(self):
        """Called to clean-up the server.
 
        May be overridden.
 
        """
        pass
 
    def finish_request(self, request, client_address):
        """Finish one request by instantiating RequestHandlerClass."""
        self.RequestHandlerClass(request, client_address, self)
 
    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
        self.close_request(request)
 
    def close_request(self, request):
        """Called to clean up an individual request."""
        pass
 
    def handle_error(self, request, client_address):
        """Handle an error gracefully.  May be overridden.
 
        The default is to print a traceback and continue.
 
        """
        print '-'*40
        print 'Exception happened during processing of request from',
        print client_address
        import traceback
        traceback.print_exc() # XXX But this goes to stderr!
        print '-'*40
 
BaseServer

BaseServer

class TCPServer(BaseServer):
 
    """Base class for various socket-based server classes.
 
    Defaults to synchronous IP stream (i.e., TCP).
 
    Methods for the caller:
 
    - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
    - serve_forever(poll_interval=0.5)
    - shutdown()
    - handle_request()  # if you don't use serve_forever()
    - fileno() -> int   # for select()
 
    Methods that may be overridden:
 
    - server_bind()
    - server_activate()
    - get_request() -> request, client_address
    - handle_timeout()
    - verify_request(request, client_address)
    - process_request(request, client_address)
    - shutdown_request(request)
    - close_request(request)
    - handle_error()
 
    Methods for derived classes:
 
    - finish_request(request, client_address)
 
    Class variables that may be overridden by derived classes or
    instances:
 
    - timeout
    - address_family
    - socket_type
    - request_queue_size (only for stream sockets)
    - allow_reuse_address
 
    Instance variables:
 
    - server_address
    - RequestHandlerClass
    - socket
 
    """
 
    address_family = socket.AF_INET
 
    socket_type = socket.SOCK_STREAM
 
    request_queue_size = 5
 
    allow_reuse_address = False
 
    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        BaseServer.__init__(self, server_address, RequestHandlerClass)
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise
 
    def server_bind(self):
        """Called by constructor to bind the socket.
 
        May be overridden.
 
        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()
 
    def server_activate(self):
        """Called by constructor to activate the server.
 
        May be overridden.
 
        """
        self.socket.listen(self.request_queue_size)
 
    def server_close(self):
        """Called to clean-up the server.
 
        May be overridden.
 
        """
        self.socket.close()
 
    def fileno(self):
        """Return socket file number.
 
        Interface required by select().
 
        """
        return self.socket.fileno()
 
    def get_request(self):
        """Get the request and client address from the socket.
 
        May be overridden.
 
        """
        return self.socket.accept()
 
    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
        try:
            #explicitly shutdown.  socket.close() merely releases
            #the socket and waits for GC to perform the actual close.
            request.shutdown(socket.SHUT_WR)
        except socket.error:
            pass #some platforms may raise ENOTCONN here
        self.close_request(request)
 
    def close_request(self, request):
        """Called to clean up an individual request."""
        request.close()
 
TCPServer

TCPServer

class ThreadingMixIn:
    """Mix-in class to handle each request in a new thread."""
 
    # Decides how threads will act upon termination of the
    # main process
    daemon_threads = False
 
    def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.
 
        In addition, exception handling is done here.
 
        """
        try:
            self.finish_request(request, client_address)
            self.shutdown_request(request)
        except:
            self.handle_error(request, client_address)
            self.shutdown_request(request)
 
    def process_request(self, request, client_address):
        """Start a new thread to process the request."""
        t = threading.Thread(target = self.process_request_thread,
                             args = (request, client_address))
        t.daemon = self.daemon_threads
        t.start()

ThreadingMixIn

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

ThreadingTCPServer

class BaseRequestHandler:
 
    """Base class for request handler classes.
 
    This class is instantiated for each request to be handled.  The
    constructor sets the instance variables request, client_address
    and server, and then calls the handle() method.  To implement a
    specific service, all you need to do is to derive a class which
    defines a handle() method.
 
    The handle() method can find the request as self.request, the
    client address as self.client_address, and the server (in case it
    needs access to per-server information) as self.server.  Since a
    separate instance is created for each request, the handle() method
    can define arbitrary other instance variariables.
 
    """
 
    def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        self.setup()
        try:
            self.handle()
        finally:
            self.finish()
 
    def setup(self):
        pass
 
    def handle(self):
        pass
 
    def finish(self):
        pass

SocketServer.BaseRequestHandler

对源码进行精简做一个程序：

import socket
import threading
import select
 
def process(request, client_address):
    print request,client_address
    conn = request
    conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
    flag = True
    while flag:
        data = conn.recv(1024)
        if data == 'exit':
            flag = False
        elif data == '0':
            conn.sendall('通过可能会被录音.balabala一大推')
        else:
            conn.sendall('请重新输入.')
 
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1',8002))
sk.listen(5)
 
while True:
    r, w, e = select.select([sk,],[],[],1)
    print 'looping'
    if sk in r:
        print 'get request'
        request, client_address = sk.accept()
        t = threading.Thread(target=process, args=(request, client_address))  # 每个连接过来创建一个线程
        t.daemon = False
        t.start()
 
sk.close()

如精简代码可以看出，SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）

三、IO多路复用（多连接）

IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：

• 　　当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。
• 　　当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。
• 　　如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。
• 　　如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。
• 　　如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

select模块（实现伪并发）

Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用

select 模块
 
Windows Python：
    提供： select
Mac Python：
    提供： select
Linux Python：
    提供： select、poll、epoll

• select

　　select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

• poll

　　poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。

• epoll

　　直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

select.select方法：

　　select函数需要3个序列作为它的必选参数，此外还有一个可选的以秒单位的超时时间作为第4个参数。3个序列用于输入、输出以及异常情况（错误）；如果没有给定超时时间，select会阻塞（也就是处于等待状态），知道其中的一个文件描述符以及为行动做好了准备，如果给定了超时时间，select最多阻塞给定的超时时间，如果超时时间为0，那么就给出一个连续的poll（即不阻塞）；select的返回值是3个序列，每个代表相应参数的一个活动子集。第一个序列用于监听socket对象内部是否发生变化，如果有变化表示有新的连接，下面直接看程序代码

select.select伪并发程序服务端

import socket
import select
 
sk = socket.socket()
sk.bind(('127.0.0.1',8002))
sk.listen(5)
sk.setblocking(0)　　#不阻塞
 
inputs = [sk,]
messages = {}
outputs = []
while True:
    readable_list, writeable_list, error_list = select.select(inputs, outputs, [], 1)
    # readable_list 监听服务端对象，当inputs列表有变化时，变化的值会赋值给readable_list中
    # 如果有新的连接进来，sk会发生变化，此时readable_list—的值为sk
    # 如果conn对象发生变化，表示客户端发送了新的消息过来，此时readable_list的值为客户端连接
    # writeable_lists实现读写分离，需要回复信息的conn对象添加到里面
    print(len(inputs),len(readable_list),len(writeable_list),len(outputs))
 
    for r in readable_list:
        # 当客户端第一次连接服务端时，未在inputs里
        if r == sk:
            print('accept')
            conn, address = r.accept()
            conn.sendall("hello".encode())
            inputs.append(conn)     #添加到inputs
            messages[conn]=[]          #设置messages key值r为列表
 
        # 当客户端连接上服务端之后，再次发送数据时，已经存在inputs
        else:
            try:
                received = r.recv(1024)
                # 当正常接收客户端发送的数据时
                if not received:
                    raise  Exception("断开连接")
                else:
                    messages[r].append(received)
                    outputs.append(r)
 
                # 当客户端关闭程序时
            except Exception as e:
                    inputs.remove(r)
                    del messages[r]
    for w in writeable_list:
        msg = messages[w].pop()
        rest =  msg + "response".encode()
        w.sendall(rest)
        outputs.remove(w)
 
sk.close()

select.select伪并发程序客户端

import socket
 
sk = socket.socket()
sk.connect(("127.0.0.1",8002))
print(sk.recv(1024).decode())
 
while True:
    command = input("--->>>")
    sk.sendall(command.encode())
    res = sk.recv(1024)
    print(res.decode())
sk.close()

select.poll方法：

　　poll方法使用起来比select简单。在调用poll时，会得到一个poll对象。然后就可以使用poll的对象的register方法注册一个文件描述符（或者是带有fileno方法的对象）。注册后可以使用unregister方法移出注册的对象。注册了一些对象（比如套接字）以后，就可以调用poll方法（带有一个可选的超时时间参数）并得到一个（fd，event）格式列表（可能为空），其中fd是文件描述符，event则告诉你发生了什么。这是一个位掩码（bitmask），意思是它是一个整数，这个整数的每个位对应不同的事件。那些不同的事件是select模块的常量，为了验证是否设置了一个定位（也就是说，一个给定的事件是否发生了），可以使用按位与操作符（&）：if event & select.POLLIN

select模块中的polling事件常量：

事件名                                描述
 
POLLIN                              读取来自文件描述符的数据
POLLPRT                             读取来自文件描述符的紧急数据
POLLOUT                             文件描述符已经准备好数据，写入时不会发生阻塞
POLLERR                             与文件描述符有关的错误情况
POLLHUP                             挂起，连接丢失
POLLNVAL                            无效请求，连接没有打开

poll的简单程序服务端（linux）

#poll 异步I/O
 
import socket,select
 
s = socket.socket()
host = "127.0.0.1"
port = 8002
s.bind((host,port))
 
fdmap = {s.fileno():s}      #文件描述符到套接字对象的映射
 
s.listen(5)
p = select.poll()           #poll对象
p.register(s)               #注册一个文件描述符（带有fileno方法的对象)
while True:
    events = p.poll()
    for fd,event in events:
        if fd == s.fileno():        #新的连接进来
            c,addr = s.accept()
            print("Got connectins from",addr)
            p.register(c)           #注册一个文件描述符（带有fileno方法的对象)
            fdmap[c.fileno()] = c   #添加到fdmap
        elif event & select.POLLIN:     #读取来自文件描述符的数据
            data = fdmap[fd].recv(1024)
            if not data:                #表示客户端断开
                print(fdmap[fd].getpeername(),"disconnected")
                p.unregister(fd)        #清除文件描述符
                del fdmap[fd]           #删除fdmap对应的key值
            else:
                print(data.decode())

poll程序客户端

#poll 异步I/O
 
import socket
 
sk = socket.socket()
sk.connect(("127.0.0.1",8002))
 
while True:
    command = input("--->>>")
    sk.sendall(command.encode())
sk.close()

epoll方法：

epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

一 epoll操作过程

epoll操作过程需要三个接口，分别如下：

int epoll_create(int size)；//创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大，这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值，参数size并不是限制了epoll所能监听的描述符最大个数，只是对内核初始分配内部数据结构的一个建议。
当创建好epoll句柄后，它就会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
函数是对指定描述符fd执行op操作。
- epfd：是epoll_create()的返回值。
- op：表示op操作，用三个宏来表示：添加EPOLL_CTL_ADD，删除EPOLL_CTL_DEL，修改EPOLL_CTL_MOD。分别添加、删除和修改对fd的监听事件。
- fd：是需要监听的fd（文件描述符）
- epoll_event：是告诉内核需要监听什么事

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待epfd上的io事件，最多返回maxevents个事件。
参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

#_*_coding:utf-8_*_
__author__ = 'Alex Li'
 
import socket, logging
import select, errno
 
logger = logging.getLogger("network-server")
 
def InitLog():
    logger.setLevel(logging.DEBUG)
 
    fh = logging.FileHandler("network-server.log")
    fh.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.ERROR)
 
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    ch.setFormatter(formatter)
    fh.setFormatter(formatter)
 
    logger.addHandler(fh)
    logger.addHandler(ch)
 
if __name__ == "__main__":
    InitLog()
 
    try:
        # 创建 TCP socket 作为监听 socket
        listen_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
    except socket.error as  msg:
        logger.error("create socket failed")
 
    try:
        # 设置 SO_REUSEADDR 选项
        listen_fd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    except socket.error as  msg:
        logger.error("setsocketopt SO_REUSEADDR failed")
 
    try:
        # 进行 bind -- 此处未指定 ip 地址，即 bind 了全部网卡 ip 上
        listen_fd.bind(('', 2003))
    except socket.error as  msg:
        logger.error("bind failed")
 
    try:
        # 设置 listen 的 backlog 数
        listen_fd.listen(10)
    except socket.error as  msg:
        logger.error(msg)
 
    try:
        # 创建 epoll 句柄
        epoll_fd = select.epoll()
        # 向 epoll 句柄中注册 监听 socket 的 可读 事件
        epoll_fd.register(listen_fd.fileno(), select.EPOLLIN)
    except select.error as  msg:
        logger.error(msg)
 
    connections = {}
    addresses = {}
    datalist = {}
    while True:
        # epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
        epoll_list = epoll_fd.poll()
 
        for fd, events in epoll_list:
            # 若为监听 fd 被激活
            if fd == listen_fd.fileno():
                # 进行 accept -- 获得连接上来 client 的 ip 和 port，以及 socket 句柄
                conn, addr = listen_fd.accept()
                logger.debug("accept connection from %s, %d, fd = %d" % (addr[0], addr[1], conn.fileno()))
                # 将连接 socket 设置为 非阻塞
                conn.setblocking(0)
                # 向 epoll 句柄中注册 连接 socket 的 可读 事件
                epoll_fd.register(conn.fileno(), select.EPOLLIN | select.EPOLLET)
                # 将 conn 和 addr 信息分别保存起来
                connections[conn.fileno()] = conn
                addresses[conn.fileno()] = addr
            elif select.EPOLLIN & events:
                # 有 可读 事件激活
                datas = ''
                while True:
                    try:
                        # 从激活 fd 上 recv 10 字节数据
                        data = connections[fd].recv(10)
                        # 若当前没有接收到数据，并且之前的累计数据也没有
                        if not data and not datas:
                            # 从 epoll 句柄中移除该 连接 fd
                            epoll_fd.unregister(fd)
                            # server 侧主动关闭该 连接 fd
                            connections[fd].close()
                            logger.debug("%s, %d closed" % (addresses[fd][0], addresses[fd][1]))
                            break
                        else:
                            # 将接收到的数据拼接保存在 datas 中
                            datas += data
                    except socket.error as  msg:
                        # 在 非阻塞 socket 上进行 recv 需要处理 读穿 的情况
                        # 这里实际上是利用 读穿 出 异常 的方式跳到这里进行后续处理
                        if msg.errno == errno.EAGAIN:
                            logger.debug("%s receive %s" % (fd, datas))
                            # 将已接收数据保存起来
                            datalist[fd] = datas
                            # 更新 epoll 句柄中连接d 注册事件为 可写
                            epoll_fd.modify(fd, select.EPOLLET | select.EPOLLOUT)
                            break
                        else:
                            # 出错处理
                            epoll_fd.unregister(fd)
                            connections[fd].close()
                            logger.error(msg)
                            break
            elif select.EPOLLHUP & events:
                # 有 HUP 事件激活
                epoll_fd.unregister(fd)
                connections[fd].close()
                logger.debug("%s, %d closed" % (addresses[fd][0], addresses[fd][1]))
            elif select.EPOLLOUT & events:
                # 有 可写 事件激活
                sendLen = 0
                # 通过 while 循环确保将 buf 中的数据全部发送出去
                while True:
                    # 将之前收到的数据发回 client -- 通过 sendLen 来控制发送位置
                    sendLen += connections[fd].send(datalist[fd][sendLen:])
                    # 在全部发送完毕后退出 while 循环
                    if sendLen == len(datalist[fd]):
                        break
                # 更新 epoll 句柄中连接 fd 注册事件为 可读
                epoll_fd.modify(fd, select.EPOLLIN | select.EPOLLET)
            else:
                # 其他 epoll 事件不进行处理
                continue
 
epoll socket echo server

epoll socket echo server

selectors模块

selectors模块已经封装了epoll，select方法；epoll优先级大于select

import selectors
import socket
 
sel = selectors.DefaultSelector()
 
def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)
 
def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()
 
sock = socket.socket()
sock.bind(('localhost', 10000))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)
 
while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)