目录
1. 基于tcp实现远程执行命令
tcp协议执行命令得到数据比较可靠，因为要根据命令的运行结果判断下一步的操作，无论命令的结果是正确或者是错误,客户端都需要知道返回的信息，所以不能用dup协议
服务端:
# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1',8082))
server.listen(5)
# 服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
conn,client_addr=server.accept()
# 第二件事：拿到链接对象，与其进行通信循环
while True:
try:
cmd=conn.recv(1024)
if len(cmd) == 0:break
obj=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res=obj.stdout.read()
stderr_res=obj.stderr.read()
print(len(stdout_res)+len(stderr_res))
# conn.send(stdout_res+stderr_res) # ???
conn.send(stdout_res)
conn.send(stderr_res)
# with open("1.mp4",mode='rb') as f:
# for line in f:
# conn.send(line)
except Exception:
break
conn.close()
客户端:
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8088))
while True:
cmd=input('请输入命令>>：').strip()
if len(cmd) == 0:continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路：
# 1、拿到数据的总大小total_size
# 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
# 3、直到recv_size=total_size，结束循环
cmd_res=client.recv(1024) # 本次接收，最大接收1024Bytes
print(cmd_res.decode('gbk')) # 强调：windows系统用gbk
2. 粘包问题
2.1 什么是粘包问题
须知：只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来
首先需要掌握一个socket收发消息的原理
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束，所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
1. TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 **即面向消息的通信是有消息保护边界的。**
3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头
udp是不可靠传输，tcp是可靠传输的原因：
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留
2.3 如何解决粘包问题
2.3.1 自定制报头—struct模块
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据
# struct模块
# 该模块可以把一个类型，如数字，转成固定长度的bytes
import json
import struct
header_dic={
"filename":"a.txt",
"total_size":3123123,
"md5":"123123xi12ix12",
"asf":"123123xi12ix12",
"asf1":"123123xi12ix12",
"asf2":"123123xi12ix12",
"asf3":"123123xi12ix12",
}
json_str=json.dumps(header_dic)
json_str_bytes=json_str.encode('utf-8')
print(len(json_str_bytes))#172
res=struct.pack('i',999449)
print(res,len(res))#b'x19@x0fx00' 4
res=struct.pack('i',len(json_str_bytes))
print(res,len(res))#b'xacx00x00x00' 4
2.3.2 最终版
服务端:
# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
import json
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1',8083))
server.listen(5)
# 服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
conn,client_addr=server.accept()
# 第二件事：拿到链接对象，与其进行通信循环
while True:
try:
cmd=conn.recv(1024)
if len(cmd) == 0:break
obj=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res=obj.stdout.read()
stderr_res=obj.stderr.read()
total_size=len(stdout_res)+len(stderr_res)
# 1、制作头
header_dic={
"filename":"a.txt",
"total_size":total_size,
"md5":"123123xi12ix12"
}
json_str = json.dumps(header_dic)
json_str_bytes = json_str.encode('utf-8')
# 2、先把头的长度发过去
x=struct.pack('i',len(json_str_bytes))
conn.send(x)
# 3、发头信息
conn.send(json_str_bytes)
# 4、再发真实的数据
conn.send(stdout_res)
conn.send(stderr_res)
except Exception:
break
conn.close()
客户端:
import struct
import json
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8083))
while True:
cmd=input('请输入命令>>：').strip()
if len(cmd) == 0:continue
client.send(cmd.encode('utf-8'))
# 接收端
# 1、先手4个字节，从中提取接下来要收的头的长度
x=client.recv(4)
header_len=struct.unpack('i',x)[0]
# 2、接收头，并解析
json_str_bytes=client.recv(header_len)
json_str=json_str_bytes.decode('utf-8')
header_dic=json.loads(json_str)
print(header_dic)
total_size=header_dic["total_size"]
# 3、接收真实的数据
recv_size = 0
while recv_size < total_size:
recv_data=client.recv(1024)
recv_size+=len(recv_data)
print(recv_data.decode('utf-8'),end='')
else:
print()
3. socketserver模块实现并发
3.1 基于TCP协议的使用
服务端:
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
def handle(self):
# 如果tcp协议，self.request=>conn
print(self.client_address)
while True:
try:
msg = self.request.recv(1024)
if len(msg) == 0: break
self.request.send(msg.upper())
except Exception:
break
self.request.close()
# 服务端应该做两件事
# 第一件事：循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
s=socketserver.ThreadingTCPServer(('127.0.0.1',8889),MyRequestHandle)
s.serve_forever()
# 等同于
# while True:
# conn,client_addr=server.accept()
# 启动一个线程(conn,client_addr)
# 第二件事：拿到链接对象，与其进行通信循环===>handle
客户端:
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8889))
while True:
msg=input('请输入命令>>：').strip()
if len(msg) == 0:continue
client.send(msg.encode('utf-8'))
res=client.recv(1024)
print(res.decode('utf-8'))
3.2 基于UDP协议的使用
服务端:
import socketserver
class MyRequestHanlde(socketserver.BaseRequestHandler):
def handle(self):
client_data=self.request[0]
server=self.request[1]
client_address=self.client_address
print('客户端发来的数据%s' %client_data)
server.sendto(client_data.upper(),client_address)
s=socketserver.ThreadingUDPServer(("127.0.0.1",8888),MyRequestHanlde)
s.serve_forever()
# 相当于:只负责循环地收
# while True:
# data,client_addr=server.recvfrom(1024)
# 启动一个线程处理后续的事情(data,client_addr)
客户端:
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
msg=input('>>>: ').strip()
client.sendto(msg.encode('utf-8'),('115.29.65.16',8888))
res=client.recvfrom(1024)
print(res)
client.close()