python2.0 s12 day8 _ socketserver学习

Socket
    概念
        一个socket就是一个点对点的链接.当今,大多数的通信都是基于Internet Protocl,因此大多数的网络Socket都是Internet Protocl(互联网)的通信(HTTP的比较多).
        更精确的,一个socket 是一个句柄,socket里面其实就只是一些整数(比如我和哪个IP地址有链接,对方的IP和port)

    socket API
        我们可以调用的socket API,一般是由操作系统提供的,它允许应用程序控制和使用Network socket,API通常基于加州大学伯克利分校的标准.它这个标准定义了,socket按照文件句柄方式设计的.
        你可以通过socket句柄读\写.
    A socket address
        IP地址和端口号的组合,像一个电话连接.打电话,需要一个电话号码,同时还需要一个分机号.
        socket中你需要一个地址,分机号就相当于端口号.

    接下来看下socket基础的一些知识点
        1.首先看下几种socket的通信时使用的地址类型(老师说是通信类型,不好理解,我觉得描述成使用的地址类型)
          Socket Families(地址簇)
            socket.AF_UNIX unix 本机进程间通信 用此地址簇
            socket.AF_INET IPV4  默认用的这个,常用的也是这个
            socket.AF_INET6 IPV6
        上面的这些是地址簇,当你再实例化一个socket句柄时,第一个参数就应该指定地址簇的类型.我们不指定,默认就是socket.AF_INET

        2.接下来看Socket类型 (又被称作套接字的类型)
          Socket Types
            socket.SOCK_STREAM      # tcp类套接字  再实例化socket句柄时默认采用这个.
            socket.SOCK_DGRAM       # udp类套接字
            socket.SOCK_RAW         # 原始套接字,普通的套接字无法处理ICMP\IGMP等网络报文(IP层,网络层),而SOCK_RAW可以,
            其次,SOCK_RAW也可以处理特殊的IPv4报文;此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
            SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
            socket.SOCK_RDM  #是一种可靠的UDP形式，即保证交付数据报但不保证顺序。
            socket.SOCK_SEQPACKET #废弃了,基本上不用了

            ps:  socket.SOCK_RAW 这个可以用于DDOS攻击.如何实现,可以去查查,通过一台机器模拟几万台机器.这个叫做洪水攻击.
            如何解决洪水攻击,本质上是解决不了的.只能用一些方法过滤,比如防火墙,或者再服务器上配置超时时间.这是tcp/ip bug

Socket 方法介绍:

    1 socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)  实例化socket句柄方法
        family = AF_INET设置通信类型,也可以理解成设置地址类型
        type=SOCK_STREAM  设置socket套接字类型
        proto=0  用不到,老师不知道
        fileno=None 用不到,老师不知道

    2 socket.socketpair([family[, type[, proto]]])  老师忘记了,说是一会试下,结果没试

    3 socket.create_connection(address[, timeout[, source_address]])
        这个方法跟那个socket.connect()方法差不多,客户端连接服务端使用的.
        但是我测试再没进行socket.socket()实例化前,是没有socket.connect()方法,只有socket.create_connection()方法
        我猜测,这个是客户端再没实例化之前创建连接的方法.或者猜测实例化后的sk.connect()就是调用这个方法的.
        具体怎样的可能要测试下才能知道.

    4 socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) #获取要连接的对端主机地址

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

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

    7 sk.setblocking(bool)
        是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
        什么时候会用到呢?默认sk.recv(),sk.send()
        再单线程下实现多并发就会用到.看以后的实例吧.

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

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

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

 sk.close()
        关闭套接字

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

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

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

 sk.sendall(string[,flag])
        将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
        内部通过递归调用send，将所有内容发送出去。

 sk.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()
        套接字的文件描述符

 socket.sendfile(file, offset=0, count=None)
        发送文件 ，但目前多数情况下并无什么卵用。
        新版本中才有,这里内部实现了循环发送文件,说它没卵用是因为socket没有对应接收文件的方法.

————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

socketserver

socket是单线程,要实现多个用户连接一个socket server ,就需要用socketserver模块搞一个多线程.
每一个连接过来都会创建单独的1个线程.最多能创建多少个线程跟你操作系统有关.

socketserver有四个基本的类:
    class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
        把这个类理解成:封装了通信类型设置为IPv4和IPv6,套接字类型设置成TCP 的一个类
        既:family = AF_INET,AF_INET6 设置通信类型, type=SOCK_STREAM 设置套接字类型为TCP

    class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)
        把这个类理解成:封装了通信类型设置为IPv4和IPv6,套接字类型设置成UDP 的一个类
        既:family = AF_INET,AF_INET6设置通信类型, type=SOCK_DGRAM 设置套接字类型为 UDP

    class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
        把这个类理解成:封装了通信类型设置为unix,套接字类型设置成TCP 的一个类
        既:family = AF_UNIX  设置通信类型, type=SOCK_STREAM 设置套接字类型为TCP

    class socketserver.UnixDatagramServer(server_address, RequestHandlerClass,bind_and_activate=True)  把 AF_UNIX包装成这个
        把这个类理解成:封装了通信类型设置为unix,套接字类型设置成TCP 的一个类
        既:family = AF_UNIX  设置通信类型, type=SOCK_DGRAM 设置套接字类型为UDP

    还有其他不常用的类,这四个类处理请求都是同步,他不是异步的,它只是把socket重新封装了一下.怎样进行多线程呢?解决办法呢?
    就是每一个请求都开启一个进程或者线程.用什么开进程或线程?用socketserver.ForkingMixIn多线程 socketserver.ThreadingMixIn 多线程

    There are five classes in an inheritance diagram, four of which represent synchronous servers of four types:

        +------------+
        | BaseServer |
        +------------+
              |
              v
        +-----------+        +------------------+
        | TCPServer |------->| UnixStreamServer |
        +-----------+        +------------------+
              |
              v
        +-----------+        +--------------------+
        | UDPServer |------->| UnixDatagramServer |
        +-----------+        +--------------------+

    还有其他不常用的类,这四个类处理请求都是同步,他不是异步的,它只是把socket重新封装了一下.怎样进行多线程呢?解决办法呢?
    解决方案：为每一个请求都开启一个进程或者线程.用什么开进程或线程?
    用多进程\多线程的处理模块在进行封装.
    class socketserver.ForkingMixIn  # 多进程
    class socketserver.ThreadingMixIn   # 多线程

　　我们可以再脑海里想象,再封装后的socketserver.TCPServer外,再封装一层处理多进程或者多线程的模块.实际也是这么做的，如下：

　　　　class ThreadingUDPServer(ThreadingMixIn, UDPServer):
   　　　　 pass

    所以最终我们要使用的是下面四个类:
        class socketserver.ForkingTCPServer     多进程的TCP类
        class socketserver.ForkingUDPServer     多进程的UDP类
        class socketserver.ThreadingTCPServer   多线程的TCP类
        class socketserver.ThreadingUDPServer   多线程的UDP类

Request Handler Objects (ps:请求处理的类)
    class socketserver.BaseRequestHandler
    有下面几种方法
        setup()
        handle()
        finish()
写一个socketserver.ThreadingTCPServer 下一个服务端实例：

 #!/usr/bin/evn python3.5
 #__author__:'ted.zhou'
 '''
 socketserver例子
 '''
 import socketserver　　　　　　　　＃导入socketserver模块
 class MyTCPHandler(socketserver.BaseRequestHandler):　　　　　　　　　　　　＃自定义一个Handler类，类继承socket.BaseRequestHandler基类，并且类中必须有handle()方法
     def handle(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　＃定义handle方法，里面要定义一些对socket套接字的具体处理过程
         while True:
             self.data = self.request.recv(1024).strip()
             if len(self.data) == 0:break
             print("{} wrote:".format(self.client_address[0]))
             print(self.data)
             self.request.sendall(self.data.upper())
 if __name__ == "__main__":
     HOST, PORT = "localhost", 9999

     # Create the server, binding to localhost on port 9999
     # server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
     server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)

     # Activate the server; this will keep running until you
     # interrupt the program with Ctrl-C
     server.serve_forever()

客户端代码实例：

 #!/usr/bin/env python3.5
 #__author__:'ted.zhou'
 import socket
 import sys

 HOST, PORT = "localhost", 9999
 # data = " ".join(sys.argv[1:])
 # data = input(">>>")
 # Create a socket (SOCK_STREAM means a TCP socket)
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

 try:
     # Connect to server and send data
     sock.connect((HOST, PORT))
     while True:
         data = input(">>>")
         sock.sendall(bytes(data + "\n", "utf-8"))
         # Receive data from the server and shut down
         received = str(sock.recv(1024), "utf-8")
         print(received)
 finally:
     sock.close()