python study day08

1 socket处理命令

      客户端发送指令，服务器端读取指令并执行指令，把结果返回。
Socket 服务器端

import os
import socket
server = socket.socket()
server.bind(('localhost',9999))


server.listen(5)

while True:
    conn,addr = server.accept()
    print("new coon:",addr)

    while True:
        print("等待新指令")
        data = conn.recv(1024)
        if not data:
            print("客户端已断开")
            break
        data_ = data.decode()
        print("执行指令：",data)
        cmd_res = os.popen(data_).read()     #接受字符串，执行结果也是字符串

        print("before send",len(cmd_res))

        if len(cmd_res) ==0:
            cmd_res = 'cmd has no output...'
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))        #先发送大小给客户端

        conn.send(cmd_res.encode('utf-8'))
        print("send done")


server.close()

socket 客户端

import socket

client = socket.socket()

client.connect(('localhost',9999))

while True:

    cmd_data = input(">>:").strip()
    if len(cmd_data) == 0:continue
    client.send(cmd_data.encode('utf-8'))

    cmd_res_size = client.recv(1024).decode()   #接受命令结果的长度
    #recv = recv.decode()
    print("命令结果大小",cmd_res_size)
    receive_size = 0
    receive_data =b""

    while receive_size < int(cmd_res_size):
        data = client.recv(1024)
        receive_size+=len(data)
        receive_data +=data

    else:

        print("cmd res receive doen...",receive_size)
        print(receive_data.decode())

client.close()

2、socket中需要特别注意黏包情况

      1）可以用time.sleep(0.5)一下。让缓冲区超时（不能用于实时的情况）
      2）可以增加一条接受语句，在服务器端发数据的时候，先接收一下客户端发来的数据，再发送

Socket服务器端

import os
import socket
server = socket.socket()
server.bind(('localhost',9999))


server.listen(5)

while True:
    conn,addr = server.accept()
    print("new coon:",addr)

    while True:
        print("等待新指令")
        data = conn.recv(1024)
        if not data:
            print("客户端已断开")
            break
        data_ = data.decode()
        print("执行指令：",data)
        cmd_res = os.popen(data_).read()     #接受字符串，执行结果也是字符串

        print("before send",len(cmd_res))

        if len(cmd_res) ==0:
            cmd_res = 'cmd has no output...'
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))        #先发送大小给客户端
        print(conn.recv(1024))
        conn.send(cmd_res.encode('utf-8'))
        print("send done")


server.close()

socket客户端

import socket

client = socket.socket()

client.connect(('localhost',9999))

while True:

    cmd_data = input(">>:").strip()
    if len(cmd_data) == 0:continue
    client.send(cmd_data.encode('utf-8'))

    cmd_res_size = client.recv(1024).decode()   #接受命令结果的长度
    #recv = recv.decode()
    print("命令结果大小",cmd_res_size)
    client.send(b'start to send data')
    receive_size = 0
    receive_data =b""

    while receive_size < int(cmd_res_size):
        data = client.recv(1024)
        receive_size+=len(data)
        receive_data +=data

    else:

        print("cmd res receive doen...",receive_size)
        print(receive_data.decode())

client.close()

3、通过socket发文件 ftp

   1）ftp server
      1、读取文件
      2、检测文件是否存在
      3、打开文件
      4、检测文件大小。告诉客户端要接收多少数据
      5、发送文件大小给客户端
      6、等客户端确认（防止黏包）
      7、开始边读边发
      8、发送md5
   2）ftp client

Server 客户端：

import socket,os,hashlib

ftp_server = socket.socket()

ftp_server.bind(('localhost',9999))

ftp_server.listen(5)
m = hashlib.md5()
while True:
    ftp_client,addr = ftp_server.accept()
    while True:
        print("等待新指令")
        data = ftp_client.recv(1024)
        if not data:
            print("客户端已断开")
            break
        cmd,file_name = data.decode().split()
        print(file_name)
        if os.path.isfile(file_name):   #判断文件是否存在

            file_size = os.stat(file_name).st_size
            print(file_size)
            ftp_client.send(str(file_size).encode('utf-8')) #send file size
            ftp_client.recv(1024)           # wait for ack
            with open(file_name,'rb') as f:
                for line in f:
                    m.update(line)
                    ftp_client.send(line)

            print("file md5",m.hexdigest())

            ftp_client.send(m.hexdigest().encode('utf-8'))
            print("send done")

ftp_server.close()

client 客户端：

import socket,hashlib
ftp_client = socket.socket()
ftp_client.connect(('localhost',9999))
while True:
    cmd = input(">>:").strip()
    if len(cmd) ==0:continue
    if cmd.startswith("get"):
        ftp_client.send(cmd.encode('utf-8'))
        server_response = ftp_client.recv(1024)
        print("server response:",server_response)
        ftp_client.send(b"ready to recv file")
        file_total_size = int(server_response.decode())

        receive_size = 0
        filename = cmd.split()[1]
        m = hashlib.md5()
        while receive_size<file_total_size:
            if file_total_size-receive_size>1024:   #要收不止一次
                size = 1024
            else:
                size = file_total_size-receive_size     #最后一个收的数据，为了防止和下面接收的mds数据相混
                print("last receive:",size)
            with open(filename+"new",'ab') as f:
                data = ftp_client.recv(size)
                receive_size+=len(data)
                m.update(data)
                f.write(data)

        print(file_total_size,receive_size)
        md5 = ftp_client.recv(1024)
        print("receive md5",md5.decode())
        print("file md5" ,m.hexdigest())

ftp_client.close()

      为了防止接收的文件和下面接受的MD5值发生黏包，在每次接受文件的时候，判断已经收到的文件的大小和原文件的大小，若是二者只差小于1024，则动态改变最后一次接受数据的大小，这样就不会和下面的数据发生黏包。

4、socket 方法

1）socket.socket(family = AF_INET,type = SOCK_STREAM,porto = 0,fileno = None)
2）sk.bind(address)
　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
3）sk.listen(backlog)
　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列
4）sk.setblocking(bool)
　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
5）sk.accept()
　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
　　接收TCP 客户的连接（阻塞式）等待连接的到来
6）sk.connect(address)
　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
7）sk.connect_ex(address)
　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
8）sk.close()
　　关闭套接字
9）sk.recv(bufsize[,flag])
　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
10）sk.recvfrom(bufsize[.flag])
　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
11）sk.send(string[,flag])
　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
12）sk.sendall(string[,flag])
　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
内部通过递归调用send，将所有内容发送出去。
13）sk.sendto(string[,flag],address)
　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
14）sk.settimeout(timeout)
　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
15）sk.getpeername()
　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
16）sk.getsockname()
　　返回套接字自己的地址。通常是一个元组(ipaddr,port)
17）sk.fileno()
　　套接字的文件描述符
18）socket.sendfile(file, offset=0, count=None)
发送文件 ，但目前多数情况下并无什么卵用。

         实现socket端口复用

5、socketserver模块 处理多并发类型

      1）class socketserver.TCPServer(server_address,RequestHandlerClass,bind_and_activate = True)
这使用Internet TCP协议，它提供了客户机和服务器之间的连续数据流。如果bind_and_activate为真，构造函数将自动尝试调用server_bind()和server_activate()。其他参数传递给BaseServer基类。

      2）class socketserver.UDPServer(server_address,RequestHandlerClass,bind_and_active=True)
这使用的是数据报，它是离散的信息包，在传输过程中可能会出现无序或丢失。参数与TCPServer相同。
       3）class socketserver.UnixStreamServer(server_address,RequestHandlerClass,bind_and_active=True)
       4） class socketserver.UnixDatagramServer(server_address,RequestHandlerClass,bind_and_active=True)
这些不常用的类类似于TCP和UDP类，但是使用Unix域套接字;它们在非unix平台上不可用。参数与TCPServer相同。

步骤：
       1、你必须自己创建一个请求处理类，并且这个类要继承BaseRequestHandler，并且还有重构父类里handle()方法
       2、你必须实例化一个TCPserver class，并且传递server ip 和第一步创建的请求处理类给这个TCPserver
       3、server.handle_request() 只处理一个请求
       server.serve_forever() 处理多个请求，永远执行

      4、最后，调用server_close()关闭这个socket ()

代码：

import socketserver

class Handler(socketserver.BaseRequestHandler):#创建一个请求处理类

    def handle(self):#重构处理函数
        while True:
            try:
                self.data = self.request.recv(1024)
                print("receive data:",self.data)
                self.request.send(self.data.upper())
            except ConnectionResetError as e:
                print("error:",e)
                break


if __name__ == "__main__":
    HOST,PORT = "localhost",9999
	
    server = socketserver.TCPServer((HOST,PORT),Handler) #创建一个实例
    server.serve_forever()

5.1 多并发

       把上述代码，实例化的时候改成这样，就可以实现多并发
这是多线程

server = socketserver.ThreadingTCPServer((HOST,PORT),Handler)

这是多进程

server = socketserver.ForkingTCPServer((HOST,PORT),Handler)

这是在Ubuntu上好使，在window上不好使

5.2 运行重用地址

作业：开发一个支持多用户在线的FTP程序
要求：

1. 用户加密认证
2. 允许同时多用户登录
3. 每个用户有自己的家目录 ，且只能访问自己的家目录
4. 对用户进行磁盘配额，每个用户的可用空间不同
5. 允许用户在ftp server上随意切换目录
6. 允许用户查看当前目录下文件
7. 允许上传和下载文件，保证文件一致性
8. 文件传输过程中显示进度条
9. 附加功能：支持文件的断点续传