030-2018-1018 FTP上传+打包工具+粘包现象2

笔记

 

一 昨日内容回顾

 

缓冲区 : 暂时存放传输数据的,防止你的程序在发送数据的时候卡住,提高代码运行效率

输入缓冲区:recv

输出缓冲区:send

缓冲区有长度限制

 

MTU:最大传输单元,网络层限制是1500B,每次发送数据的时候最好不要超过这个数

 

粘包

粘包现象:

1 连续发送小的数据,间隔时间很短,有可能一次就接收到了这几个连续的拼接在一起的小数据.  #原因:为了提高tcp传输效率,内部提供了一个叫做Nagel算法,他的意思就是为了避免你连续发送小的数据.

 

2 当你一次接收的数据长度小于你一次发送的数据长度,那么一次接受完剩下的数据会在下一次接收数据的时候被一起接收.#原因面向流的传输

 

粘包的根本原因:

两端互相不知道对方发送数据的长度

 

针对上面的原因有两种解决粘包的方案

1 在发送数据前,先发送数据的长度,那么接收根据数据的长度来进行接收数据

 

 

今日内容

1 粘包的高端解决方案

Struct

 

 

通过struct来进行Cmd指令演示

 

2 FTP简单上传

看代码

3 socketserver 

 

 

 

---

ss_client.py

import socket

tcp_client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
tcp_client.connect(server_ip_port)
while 1:
    client_msg = input('大阳哥>>>')
    tcp_client.send(client_msg.encode('utf-8'))
    from_server_msg = tcp_client.recv(1024).decode('utf-8')
    print(from_server_msg)

ss_sever.py

import socketserver

#1 定义一个类
class MyServer(socketserver.BaseRequestHandler): #2 类里面继承socketserver.BaseRequestHandler
    # 3 类里面定义一个handle方法,handle名称不能变
    def handle(self):
        while 1:
        # self.request      #conn链接通道
            from_client_data = self.request.recv(1024).decode('utf-8')
            print(from_client_data)
            server_input = input('明巍sb说>>>')
            self.request.send(server_input.encode('utf-8'))
        # self.request.close()
if __name__ == '__main__':
    #服务端的IP地址和端口
    ip_port = ('127.0.0.1',8001)
    socketserver.TCPServer.allow_reuse_address = True
    #绑定IP地址和端口,并且启动我定义的上面这个类
    server = socketserver.ThreadingTCPServer(ip_port,MyServer)
    #永久的给我执行下去
    server.serve_forever()

---

神奇的打包工具struct.py

import struct
num = 156
#将int类型的数据打包成4个字节的数据
num_stru = struct.pack('i',num)
print(len(num_stru))
print(num_stru)
print('11111111111111111111111111111111')

#在通过int类型解包,将前面打包的数据解包成打包之前的int数据
num2 = struct.unpack('i',num_stru) #解包出来是个元组
print(num2)#(156,)
print(num2[0])

---

简单ftp上传客户端实例.py

import socket
import struct
import os
import json

tcp_client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
tcp_client.connect(server_ip_port)
read_size = 1024


file_info = {
    'file_path':r'D:\python_workspace\day030\aaa.mp4',
    'file_name':'aaa.mp4',
    'file_size':None,
}

#获取文件大小
file_size = os.path.getsize(file_info['file_path'])

#将文件大小添加到文件信息的字典中
file_info['file_size'] = file_size
#因为我们要发送的数据是字节类型,那么必须将字典转换为bytes类型,但是字典不能直接转换为bytes,所以我们想到了json,
#通过json模块将字典类型的文件信息数据转换为了json类型的字符串
file_info_json = json.dumps(file_info)
#获取了字符串的长度
file_info_len = len(file_info_json)
#将长度打包为4个字节的数据,
file_info_stru = struct.pack('i',file_info_len)
#将打包好的4个自己的数据和我的文件信息数据一起发送给了服务端
tcp_client.send(file_info_stru)
tcp_client.send(file_info_json.encode('utf-8'))

#统计文件数据
all_file_data = b''
#统计文件数据长度
all_size_len = 0

with open(file_info['file_path'],'rb') as f:
    while all_size_len < file_size:
        every_read_data = f.read(read_size)
        all_file_data += every_read_data
        all_size_len += len(every_read_data)
        #发送每次读取的数据
        tcp_client.send(every_read_data)

print(tcp_client.recv(1024).decode('utf-8'))
tcp_client.close()

简单ftp上传服务端实例.py

import socket
import struct
import json
import os
tcp_server = socket.socket()
ip_port = ('127.0.0.1',8001) #127.0.0.1本机的回环地址,供内部程序之间测试用的
tcp_server.bind(ip_port)
tcp_server.listen()
#客户端上传的文件路径,都放在这个路径下
client_file_path = r'D:\jj'

conn,addr = tcp_server.accept()
#首先接收到文件信息长度转换出来的4个字节的数据
file_info_stru = conn.recv(4)
#解包文件信息的长度
file_info_len = struct.unpack('i',file_info_stru)[0]
#然后接收文件的描述信息
client_file_info = conn.recv(file_info_len).decode('utf-8')
#将接收到的json字符串反序列化
abc_file_info = json.loads(client_file_info)
print('abc_file_info>>>',abc_file_info)
client_file_size = abc_file_info['file_size']

recv_all_size = 0

#拼接一下全路径
client_full_path = client_file_path + '\\' + abc_file_info['file_name']
# client_full_path = os.path.join(client_file_path,abc_file_info['file_name'])
with open(client_full_path,'wb') as f:
    while recv_all_size < client_file_size:
        every_recv_data = conn.recv(1024)
        f.write(every_recv_data)
        recv_all_size += len(every_recv_data)


conn.send('小伙玩的行,上传成功!'.encode('utf-8'))
conn.close()
tcp_server.close()

 

---

粘包现象2客户端.py

import socket
import struct
client = socket.socket()
server_ip_port = ('192.168.15.113',8001)
client.connect(server_ip_port)
while 1:
    msg = input('请输入要执行的指令>>>')
    client.send(msg.encode('utf-8'))
    #先接收服务端要发送给我的信息的长度,前4个字节,固定的
    from_server_msglen = client.recv(4)
    unpack_len_msg = struct.unpack('i',from_server_msglen)[0]
    #接收数据长度统计,和服务端发给我的数据长度作比较,来确定跳出循环的条件
    recv_msg_len = 0
    #统计拼接接收到的数据,注意:这个不是统计长度
    all_msg = b''
    while recv_msg_len < unpack_len_msg:
        every_recv_data = client.recv(1024)
        #将每次接收的数据进行拼接和统计
        all_msg += every_recv_data
        #对每次接收到的数据的长度进行累加
        recv_msg_len += len(every_recv_data)

    print(all_msg.decode('gbk'))

粘包现象2服务端.py

import socket
import subprocess
import struct

server = socket.socket()
ip_port = ('192.168.15.113',8001)
server.bind(ip_port)
server.listen()
conn,addr = server.accept()
while 1:
    #来自客户端的指令
    print('等待接受信息。。。')
    from_client_cmd = conn.recv(1024).decode('utf-8')
    print(from_client_cmd)
    #通过subprocess模块执行服务端的系统指令,并且拿到指令执行结果
    sub_obj = subprocess.Popen(
        from_client_cmd, #客户端的指令
        shell=True,
        stdout=subprocess.PIPE, #标准输出:正确指令的执行结果在这里
        stderr=subprocess.PIPE, #标准错误输出:错误指令的执行结果在这里
    )
    #接受到的返回信息是bytes类型的，并且windows系统的默认编码为gbk
    server_cmd_msg = sub_obj.stdout.read()
    # server_cmd_err = sub_obj.stderr.read().decode('gbk')
    #首先计算出你将要发送的数据的长度
    cmd_msg_len = len(server_cmd_msg)
    #先对数据长度进行打包,打包成4个字节的数据,目的是为了和你将要发送的数据拼在一起,就好我们自定制了一个消息头
    msg_len_stru = struct.pack('i',cmd_msg_len)
    conn.send(msg_len_stru) #首先发送打包成功后的那4个字节的数据
    conn.sendall(server_cmd_msg) #循环send数据,直到数据全部发送成功

 

---