解决粘包的进阶方法

1
import socket
2
import struct
3
import json
4
import subprocess
5
import os
6

7
class MYTCPServer:
8
    address_family = socket.AF_INET
9

10
    socket_type = socket.SOCK_STREAM
11

12
    allow_reuse_address = False
13

14
    max_packet_size = 8192
15

16
    coding='utf-8'
17

18
    request_queue_size = 5
19

20
    server_dir='file_upload'
21

22
    def __init__(self, server_address, bind_and_activate=True):
23
        """Constructor.  May be extended, do not override."""
24
        self.server_address=server_address
25
        self.socket = socket.socket(self.address_family,
26
                                    self.socket_type)
27
        if bind_and_activate:
28
            try:
29
                self.server_bind()
30
                self.server_activate()
31
            except:
32
                self.server_close()
33
                raise
34

35
    def server_bind(self):
36
        """Called by constructor to bind the socket.
37
        """
38
        if self.allow_reuse_address:
39
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
40
        self.socket.bind(self.server_address)
41
        self.server_address = self.socket.getsockname()
42

43
    def server_activate(self):
44
        """Called by constructor to activate the server.
45
        """
46
        self.socket.listen(self.request_queue_size)
47

48
    def server_close(self):
49
        """Called to clean-up the server.
50
        """
51
        self.socket.close()
52

53
    def get_request(self):
54
        """Get the request and client address from the socket.
55
        """
56
        return self.socket.accept()
57

58
    def close_request(self, request):
59
        """Called to clean up an individual request."""
60
        request.close()
61

62
    def run(self):
63
        while True:
64
            self.conn,self.client_addr=self.get_request()
65
            print('from client ',self.client_addr)
66
            while True:
67
                try:
68
                    head_struct = self.conn.recv(4)
69
                    if not head_struct:break
70

71
                    head_len = struct.unpack('i', head_struct)[0]
72
                    head_json = self.conn.recv(head_len).decode(self.coding)
73
                    head_dic = json.loads(head_json)
74

75
                    print(head_dic)
76
                    #head_dic={'cmd':'put','filename':'a.txt','filesize':123123}
77
                    cmd=head_dic['cmd']
78
                    if hasattr(self,cmd):
79
                        func=getattr(self,cmd)
80
                        func(head_dic)
81
                except Exception:
82
                    break
83

84
    def put(self,args):
85
        file_path=os.path.normpath(os.path.join(
86
            self.server_dir,
87
            args['filename']
88
        ))
89

90
        filesize=args['filesize']
91
        recv_size=0
92
        print('----->',file_path)
93
        with open(file_path,'wb') as f:
94
            while recv_size < filesize:
95
                recv_data=self.conn.recv(self.max_packet_size)
96
                f.write(recv_data)
97
                recv_size+=len(recv_data)
98
                print('recvsize:%s filesize:%s' %(recv_size,filesize))
99

100

101
tcpserver1=MYTCPServer(('127.0.0.1',8080))
102

103
tcpserver1.run()

1
import socket
2
import struct
3
import json
4
import os
5

6

7

8
class MYTCPClient:
9
    address_family = socket.AF_INET
10

11
    socket_type = socket.SOCK_STREAM
12

13
    allow_reuse_address = False
14

15
    max_packet_size = 8192
16

17
    coding='utf-8'
18

19
    request_queue_size = 5
20

21
    def __init__(self, server_address, connect=True):
22
        self.server_address=server_address
23
        self.socket = socket.socket(self.address_family,
24
                                    self.socket_type)
25
        if connect:
26
            try:
27
                self.client_connect()
28
            except:
29
                self.client_close()
30
                raise
31

32
    def client_connect(self):
33
        self.socket.connect(self.server_address)
34

35
    def client_close(self):
36
        self.socket.close()
37

38
    def run(self):
39
        while True:
40
            inp=input(">>: ").strip()
41
            if not inp:continue
42
            l=inp.split()
43
            cmd=l[0]
44
            if hasattr(self,cmd):
45
                func=getattr(self,cmd)
46
                func(l)
47

48

49
    def put(self,args):
50
        cmd=args[0]
51
        filename=args[1]
52
        if not os.path.isfile(filename):
53
            print('file:%s is not exists' %filename)
54
            return
55
        else:
56
            filesize=os.path.getsize(filename)
57

58
        head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
59
        print(head_dic)
60
        head_json=json.dumps(head_dic)
61
        head_json_bytes=bytes(head_json,encoding=self.coding)
62

63
        head_struct=struct.pack('i',len(head_json_bytes))
64
        self.socket.send(head_struct)
65
        self.socket.send(head_json_bytes)
66
        send_size=0
67
        with open(filename,'rb') as f:
68
            for line in f:
69
                self.socket.send(line)
70
                send_size+=len(line)
71
                print(send_size)
72
            else:
73
                print('upload successful')
74

75

76

77

78
client=MYTCPClient(('127.0.0.1',8080))
79

80
client.run()