PyThreadSafeClientServer/Client.py at master · icarpis/PyThreadSafeClientServer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import socket
import threading
import select

class ClientConnection():

    def __init__(self, ip, port, callback, silence=True, bufferSize = 1000):
        self.mutex = threading.Lock()
        self.sock = None
        self.ip = ip
        self.port = port
        self.callback = callback
        self.clientThread = None
        self.connected = False
        self.silence = silence
        self.bufferSize = bufferSize
        self.localPort = None

    def __clientThread(self):
        try:
            inputs = [ self.sock ]
            outputs = [ ]
            timeout = 1
            while self.connected:
                readable, writable, exceptional = select.select(inputs, outputs, inputs, timeout)
                if not ((readable or writable or exceptional)):
                    if (not self.connected):
                        break
                    continue

                if (not self.connected):
                    break

                for sock in readable:
                    data = sock.recv(self.bufferSize)
                    if (not data):
                        self.connected = False
                    if (self.callback):
                        self.callback(self.sock.getsockname(), data)

                if (not self.connected):
                    break
        except Exception as e:
            print (self.localPort, " - Client callback has thrown an exception!  ", e)
            pass
        finally:
            if (self.callback):
                self.callback(self.sock.getsockname(), None)
            print(self.localPort, "Exiting Client Thread")

    def Connect(self):
        try:
            self.mutex.acquire()
            if (self.connected):
                return False
            self.connected = True
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server_address = (self.ip, self.port)
            print ('Client: connecting to %s port %s' % server_address)
            self.sock.connect(server_address)
            self.sock.setblocking(0)
            self.localPort = self.sock.getsockname()[1]
            t = threading.Thread( target=self.__clientThread)
            self.clientThread = t
            self.clientThread.start()
            return True
        except Exception as e:
            self.mutex.release()
            self.Disconnect()
            print (e)
            return False
        finally:
            if (self.mutex.locked()):
                self.mutex.release()

    def Disconnect(self):
        try:
            self.mutex.acquire()
            if (not self.connected):
                return False

            self.connected = False
            if (self.clientThread):
                try:
                    self.clientThread.join()
                except Exception as e:
                    pass
            if (self.sock):
                self.sock.close()
            return True
        finally:
            self.mutex.release()

    def IsConnected(self):
        try:
            self.mutex.acquire()
            return self.connected
        finally:
            self.mutex.release()

    def SendData(self, data):
        try:
            self.mutex.acquire()
            if (not self.connected):
                return False
            if (self.sock):
                if (not self.silence):
                    print (self.sock.getsockname(), 'Client: sending "%s"' % data)
                self.sock.sendall(data)
                return True
        except Exception as e:
            print(e)
            return False
        finally:
            self.mutex.release()