Improvements and simplification of notifier + port to client

Drone/client.py

@@ -105,6 +105,8 @@ class Client(object):
 
     def start(self):
         logger.info("Starting client")
+        messaging.NotifierSock().init(self.selector)
+
         try:
             while True:
                 self._reconnect()
@@ -195,6 +197,7 @@ class Client(object):
             #    self.server_connection.send_message("ping")
             #    self._last_ping_time = time.time()
             # logging.debug("tick")
+
             for key, mask in events:  # TODO add notifier to client!
                 connection = key.data
                 if connection is None:

Server/server.py

@@ -134,12 +134,13 @@ class Server(messaging.Singleton):
     # noinspection PyArgumentList
     def _client_processor(self):
         logging.info("Client processor (selector) thread started!")
+
+        messaging.NotifierSock().init(self.sel)
+
         self.server_socket.listen()
         self.server_socket.setblocking(False)
         self.sel.register(self.server_socket, selectors.EVENT_READ, data=None) #| selectors.EVENT_WRITE
 
-        messaging.NotifierSock().bind((self.ip, self.port))
-
         while self.client_processor_thread_running.is_set():
             events = self.sel.select()
             #logging.error('tick')
@@ -165,11 +166,7 @@ class Server(messaging.Singleton):
         logging.info("Got connection from: {}".format(str(addr)))
         conn.setblocking(False)
 
-        if addr[0] == self.ip and messaging.NotifierSock().addr is None:
-            client = messaging.NotifierSock()
-            logging.info("Notifier sock client")
-
-        elif not any([client_addr == addr[0] for client_addr in Client.clients.keys()]):
+        if not any([client_addr == addr[0] for client_addr in Client.clients.keys()]):
             client = Client(addr[0])
             logging.info("New client")
         else:

messaging_lib.py

@@ -494,40 +494,42 @@ class ConnectionManager(object):
             ))
 
 
-class NotifierSock(Singleton):  # TODO remake as connecting ONLY to self socket and selector
+class NotifierSock(Singleton):
     def __init__(self):
-        self.receive_socket = None
-        self.addr = None
+        self._server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+        self._server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 
-        self._notify_socket = None
-        self._notify_lock = threading.Lock()
+        self._sending_sock = socket.socket()
+        self._send_lock = threading.Lock()
 
-    def bind(self, server_addr):
-        self._notify_socket = socket.socket()
-        self._notify_socket.connect(server_addr)
-        logger.info("Notify socket: bind")
+        self._receiving_sock = None
 
-    def connect(self, _, client_socket, client_addr):
-        self.receive_socket = client_socket
-        self.addr = client_addr
+    def init(self, selector, port=26000):
+        port += random.randint(0, 100)  # local testing fix
 
+        self._server_socket.bind(('', port))
+        self._server_socket.listen(1)
+        self._sending_sock.connect(('127.0.0.1', port))
+        self._receiving_sock, _ = self._server_socket.accept()
         logger.info("Notify socket: connected")
 
+        selector.register(self._receiving_sock, selectors.EVENT_READ, data=self)
+        logger.info("Notify socket: selector registered")
+
     def notify(self):
-        with self._notify_lock:
-            if self.addr is not None:
-                self._notify_socket.sendall(bytes(1))
+        with self._send_lock:
+            if self._receiving_sock is not None:
+                self._sending_sock.sendall(bytes(1))
                 logger.debug("Notify socket: notified")
 
     def process_events(self, mask):
-        if mask & selectors.EVENT_READ:
+        if mask & selectors.EVENT_READ and self._receiving_sock is not None:
             try:
-                data = self.receive_socket.recv(1024)
-            except Exception:  # TODO remove
+                self._receiving_sock.recv(1024)
+                logger.debug("Notify socket: received")
+            except io.BlockingIOError:
                 pass
-            else:
-                if data:
-                    logger.debug("Notifier received {} from {}".format(data, self.addr))
-                else:
-                    self.addr = None
-                    logger.warning("Notifier: connection to {} lost!".format(self.addr))
+            except Exception as e:
+                print(e)