simplify server/client exception handling

boswatch/network/client.py

@@ -30,8 +30,8 @@ class TCPClient:
         """!Create a new instance
 
         @param timeout: timeout for the client in sec. (3)"""
-        self._sock = None
-        self._timeout = timeout
+        socket.setdefaulttimeout(timeout)
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
     def connect(self, host="localhost", port=8080):
         """!Connect to the server
@@ -41,17 +41,14 @@ class TCPClient:
         @return True or False"""
         try:
             if not self.isConnected:
-                self._sock = socket
-                self._sock.setdefaulttimeout(self._timeout)
-                self._sock = socket.create_connection((host, port))
+                self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self._sock.connect((host, port))
                 logging.debug("connected to %s:%s", host, port)
                 return True
             logging.warning("client always connected")
             return True
-        except ConnectionRefusedError:
-            logging.error("cannot connect to %s:%s - connection refused", host, port)
-        except socket.timeout:  # pragma: no cover
-            logging.warning("cannot connect to %s:%s - timeout after %s sec", host, port, self._timeout)
+        except socket.error as e:
+            logging.error(e)
         return False
 
     def disconnect(self):
@@ -61,13 +58,12 @@ class TCPClient:
         try:
             if self.isConnected:
                 self._sock.close()
-                self._sock = None
                 logging.debug("disconnected")
                 return True
             logging.warning("client always disconnected")
             return True
-        except AttributeError:
-            logging.error("cannot disconnect - no connection established")
+        except socket.error as e:
+            logging.error(e)
         return False
 
     def transmit(self, data):
@@ -76,16 +72,13 @@ class TCPClient:
         @param data: data to send to the server
         @return True or False"""
         try:
-            if not self._sock:  # check if socket is still available
-                logging.error("cannot receive - no connection established")
-                return False
             logging.debug("transmitting: %s", data)
             header = str(len(data)).ljust(HEADERSIZE)
             self._sock.sendall(bytes(header + data, "utf-8"))
             logging.debug("transmitted...")
             return True
-        except ConnectionResetError:
-            logging.error("cannot transmit - host closed connection")
+        except socket.error as e:
+            logging.error(e)
         return False
 
     def receive(self):
@@ -93,9 +86,6 @@ class TCPClient:
 
         @return received data"""
         try:
-            if not self._sock:  # check if socket is still available
-                logging.error("cannot receive - no connection established")
-                return False
             read, _, _ = select.select([self._sock], [], [], 1)
             if not read:  # check if there is something to read
                 return False
@@ -106,23 +96,18 @@ class TCPClient:
             received = self._sock.recv(length).decode("utf-8")
             logging.debug("received %d bytes: %s", length, received)
             return received
-        except ConnectionResetError:
-            logging.error("cannot receive - host closed connection")
-        except socket.timeout:  # pragma: no cover
-            logging.warning("cannot receive - timeout after %s sec", self._timeout)
+        except socket.error as e:
+            logging.error(e)
         return False
 
     @property
     def isConnected(self):
         """!Property of client connected state"""
-        if self._sock:
-            try:
-                aliveMsg = "<alive>"
-                header = str(len(aliveMsg)).ljust(HEADERSIZE)
-                self._sock.sendall(bytes(header + aliveMsg, "utf-8"))
-                return True
-            except (AttributeError, BrokenPipeError):
-                logging.error("Unknown error: ")
-            except ConnectionResetError:
-                pass
+        try:
+            aliveMsg = "<alive>"
+            header = str(len(aliveMsg)).ljust(HEADERSIZE)
+            self._sock.sendall(bytes(header + aliveMsg, "utf-8"))
+            return True
+        except socket.error as e:
+            logging.error(e)
         return False

boswatch/network/server.py

@@ -69,8 +69,9 @@ class _ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
                 self.request.sendall(bytes(header + data, "utf-8"))
             self.request.close()
 
-        except (ConnectionResetError, ConnectionAbortedError):  # pragma: no cover
-            logging.debug("%s connection closed", req_name)
+        except socket.error as e:
+            logging.error(e)
+            return False
         finally:
             del self.server.clientsConnected[threading.current_thread().name]
             logging.info("Client disconnected: %s", self.client_address[0])
@@ -129,8 +130,9 @@ class TCPServer:
                 self._server_thread.start()
                 logging.debug("TCPServer started in Thread: %s", self._server_thread.name)
                 return True
-            except OSError:
-                logging.exception("Socket Error")
+            except socket.error as e:
+                logging.error(e)
+                return False
 
         else:
             logging.warning("server always started")