day08 多线程socket 编程，tcp粘包处理

 复习下socket 编程的步骤：

服务端：

 

1 声明socket 实例

server = socket.socket()  #括号里不写  默认地址簇使用AF_INET  即 IPv4       默认type 为 sock.SOCK_STREAM 即 TCP/IP 协议   

2 绑定IP地址和端口

server.bind(('localhost',9999))  #ip地址和端口  元组形式 ，端口为整数形式

 

3 开始监听

server.listen()

 

4 进入阻塞状态，等待连接进入

######## 从这里开始可以加入循环，循环不同的连接 ,这样就可以接受不同的客户端的连接了#####

#while True:

 

  # 获取客户端ip地址和端口  开启一个连接实例

 

 

##############  从这里开始循环，这样就可以循环收到客户端数据，但是只收这一个客户端 ###########

##客户端一断开，conn收到的就全为空数据，这样就进入了一个死循环，所以需要一个if 判断

#while True:

5 收数据

data = conn.recv(1024)  #接收最大数据量， 官方建议最大8192  写整数据

# 这里加入if 判断

# if not data:

#    break

print(data)

 

6 可以往回发送数据

conn.send(data.upper()) #可以发送任何数据，这里把收到的变为大写

 

7 server.close()

 

  

客户端：

1 声明socket 实例：

client= socket.socket()

2 连接服务端：

client.connect(('server_ip',9999))   #连接服务端的ip及端口 元组形式 ，端口为整数形式

3 发数据

client.send(data)   #发送数据，任意数据

# 4 收取服务端返回的数据

#   recv_data = client.recv(1024)

 

 

动态导入模块：

实践：
1 lib下的aa
def test():
    print("hehe")
class C(object):
    name = "yang"
    def __init__(self):
        self.name = 'shenyang'



lib外的test
import importlib
dd = importlib.import_module('lib.aa')
dd.test()
print(dd.C().name)

 

 运行：

 

 

断言：

判断类型

 

正确判断

 

判断错误

和 if  判断  一样 但是更简洁，一句话就OK 

 

 

 

继续socket 编程：

 

客户端虽然写的是收1024  但是不一定收到1024  只代表最多收到1024  即使服务端返回100个字节 也收

 

客户端收完数据，收多少 要服务端先发一个要发多少的数据，客户端收到后，开始接收数据，直到收到指定大小的数据为止，不再接收

 

实践：

服务端

#!/usr/bin/env python3
# Author: Shen Yang
import socket,os
ip_address = '192.168.16.10'
port = 8888
bind_address = (ip_address,port)
server = socket.socket()
server.bind(bind_address)
server.listen()
while True:
    conn,addr = server.accept()
    while True:
        data = conn.recv(1024).decode()
        if not data:
            print("丢失连接")
            break
        print("这是来自",addr,data)
        cmd_res = os.popen(data).read()
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))
        conn.send(cmd_res.encode('utf-8'))
server.close()

客户端

#!/usr/bin/env python3
# Author: Shen Yang
import socket
ip_address = '192.168.16.10'
# ip_address = '192.168.81.133'
port = 8888
conn_address = (ip_address,port)
client = socket.socket()
client.connect(conn_address)
while True:
    cmd = input(":> ").encode('utf-8')
    if len(cmd) == 0:
        continue
    client.send(cmd)
    cmd_size = int(client.recv(1024).decode())
    print(cmd_size)
    recov_size = 0
    recov_data = b''
    while recov_size < cmd_size:
        data = client.recv(1024)
        #print(data)
        recov_size += len(data)
        #print(recov_size)
        recov_data += data
    else:
        print("收完了,大小",recov_size)
        print(recov_data.decode())
client.close()

 

 

 上面的代码 在linux 发送 会出现粘包   客户端收到的是两个数据

 

终极解决办法：

 

服务端添加接收过程：

客户端加发送过程：

实践：

ssh_server：

#!/usr/bin/env python3
import socket,os
ip_address = '192.168.81.133'
port = 8888
bind_address = (ip_address,port)
server = socket.socket()
server.bind(bind_address)
server.listen()
while True:
    conn,addr = server.accept()
    while True:
        data = conn.recv(1024).decode()
        if not data:
            print("丢失连接")
            break
        print("这是来自",addr,data)
        cmd_res = os.popen(data).read()
        conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8'))
        ack = conn.recv(1024).decode()
        print(ack)
        conn.send(cmd_res.encode('utf-8'))
server.close()

 

ssh_client

#!/usr/bin/env python3
import socket
ip_address = '192.168.81.133'
port = 8888
conn_address = (ip_address,port)
client = socket.socket()
client.connect(conn_address)
while True:
    cmd = input(":> ").encode('utf-8')
    if len(cmd) == 0:
        continue
    client.send(cmd)
    cmd_size = int(client.recv(1024).decode())
    print(cmd_size)
    client.send("收到大小".encode('utf-8'))
    recov_size = 0
    recov_data = b''
    while recov_size < cmd_size:
        data = client.recv(1024)
        #print(data)
        recov_size += len(data)
        #print(recov_size)
        recov_data += data
    else:
        print("收完了,大小",recov_size)
        print(recov_data.decode())
client.close()

 

 

传文件：

 

server 端逻辑：

 

使用 os.stat  获取文件详细信息，发送给客户端

 

另外一个解决粘包的方法：

只收指定大小的数据  永远不可能粘包

 

实践：

 ftp_server.py

#!/usr/bin/env python3
import socket,os,hashlib
ip_address = '192.168.81.133'
port = 8888
bind_address = (ip_address,port)
server = socket.socket()
server.bind(bind_address)
server.listen()
while True:
    conn,addr = server.accept()
    while True:
        print("等待新链接")
        data = conn.recv(1024)
        if not data:
            print("丢失连接")
            break
        print("这是来自",addr,data)
        cmd,file_name = data.decode().split()
        if os.path.isfile(file_name):
          m = hashlib.md5()
          f = open(file_name,'rb')
          file_size = os.stat(file_name).st_size
          conn.send(str(file_size).encode())
          ack = conn.recv(1024).decode()
          print("确认:",ack)
          for line in f:
            m.update(line)
            print("sending...")
            conn.send(line)
          f.close()
          conn.send(m.hexdigest().encode())
        print("发送完毕")
server.close()

ftp_client.py 

#!/usr/bin/env python3
import socket,hashlib
ip_address = '192.168.81.133'
port = 8888
conn_address = (ip_address,port)
client = socket.socket()
client.connect(conn_address)
while True:
    cmd = input("input your cmd:> ").strip()
    if len(cmd) == 0:
        continue
    if cmd.startswith("get"):
      client.send(cmd.encode('utf-8'))
      file_name = cmd.split()[1]
      server_response = client.recv(1024)
      print("收到回应:",server_response)
      client.send("收到".encode('utf-8'))
      total_file_size = int(server_response.decode())
      print("总的",total_file_size)
      f = open(file_name + '.new','wb')
      recov_file_size = 0
      m = hashlib.md5()
      while recov_file_size < total_file_size:
          if total_file_size - recov_file_size > 1024:
             size = 1024
          else:
             size =  total_file_size - recov_file_size
             print("最后收",size)
          #print("收数据...")
          data = client.recv(size)
          m.update(data)
          recov_file_size += len(data)
          f.write(data)
      else:
          print("收完了,大小",recov_file_size,total_file_size)
          f.close()
          print("服务器端发送的原MD5",client.recv(1024).decode())
          print("自己算出来的最终MD5",m.hexdigest())
client.close()

 

 

 

开始学习SocketSever

 

SocketSever  是对socket 的再封装

 

最常用的是 TCP 和 UDP 

继承关系：

 

 创建socket server 步骤：

 

 

 下面是重写的handle：

跟客户端所有的交互都是在handle 里处理的

每一个客户端请求都是实例化一个handle

 

 

继续修改handle

增加循环：

并增加判断客户端退出：

 

实践：

server：

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                print("来自",self.client_address)
                print(self.data)
                self.request.send(self.data.upper())
            except ConnectionResetError as e:
                print("客户端退出",e)
                break
if __name__ == "__main__":
    HOST,PORT="localhost",9999
    server = socketserver.TCPServer((HOST,PORT),MyTCPHandler)
    server.serve_forever()

 

client：

import  socket
client = socket.socket() #声明socket类型，同时生成socket连接对象
#client.connect(('192.168.16.200',9999))
client.connect(('localhost',9999))
while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    client.send(msg.encode("utf-8"))
    data = client.recv(10240)
    print("recv:",data.decode())
client.close()

上面的并不支持多并发

到现在为止，只是写了一个一对一的服务器

 

下面写入多并发：

只改一个地方：

1 使用多线程 来实现

2 使用多进程实现：  （windos 下不行，不支持，但是linux  绝得好使）

 

 

 

 

介绍 socketserver的一些方法：

 

1 返回文件描述符  (系统自己调用，我们一般用不到)

2 处理单个请求，一般也用不到

3 一直收请求，直到收到一个明确的shutdown   （每0.5秒检测是否给我发了shutdown 的信号）

收到shutdown 后调用 service_action() 清理垃圾僵尸进程

 

4 告诉 server_forever() 关闭

5 地址的重用，不需要等待tcp断开

 

 

普通的sock server

server = socket.socket() #获得socket实例

server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  #重用地址

 

 

请求的三个过程，都可以自定义：

1 setup

2 handle

3 finish