aprsd 4.0.1__py3-none-any.whl → 4.1.0__py3-none-any.whl

aprsd/client/drivers/aprsis.py

@@ -1,6 +1,7 @@
 import datetime
 import logging
 import select
+import socket
 import threading
 
 import aprslib
@@ -18,7 +19,7 @@ from aprslib.exceptions import (
 import aprsd
 from aprsd.packets import core
 
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class Aprsdis(aprslib.IS):
@@ -31,7 +32,7 @@ class Aprsdis(aprslib.IS):
     aprsd_keepalive = datetime.datetime.now()
 
     # Which server we are connected to?
-    server_string = "None"
+    server_string = 'None'
 
     # timeout in seconds
     select_timeout = 1
@@ -39,10 +40,10 @@ class Aprsdis(aprslib.IS):
 
     def stop(self):
         self.thread_stop = True
-        LOG.warning("Shutdown Aprsdis client.")
+        LOG.warning('Shutdown Aprsdis client.')
 
     def close(self):
-        LOG.warning("Closing Aprsdis client.")
+        LOG.warning('Closing Aprsdis client.')
         super().close()
 
     @wrapt.synchronized(lock)
@@ -54,6 +55,57 @@ class Aprsdis(aprslib.IS):
         """If the connection is alive or not."""
         return self._connected
 
+    def _connect(self):
+        """
+        Attemps connection to the server
+        """
+
+        self.logger.info(
+            'Attempting connection to %s:%s', self.server[0], self.server[1]
+        )
+
+        try:
+            self._open_socket()
+
+            peer = self.sock.getpeername()
+
+            self.logger.info('Connected to %s', str(peer))
+
+            # 5 second timeout to receive server banner
+            self.sock.setblocking(1)
+            self.sock.settimeout(5)
+
+            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+            # MACOS doesn't have TCP_KEEPIDLE
+            if hasattr(socket, 'TCP_KEEPIDLE'):
+                self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 1)
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 3)
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
+
+            banner = self.sock.recv(512)
+            if is_py3:
+                banner = banner.decode('latin-1')
+
+            if banner[0] == '#':
+                self.logger.debug('Banner: %s', banner.rstrip())
+            else:
+                raise ConnectionError('invalid banner from server')
+
+        except ConnectionError as e:
+            self.logger.error(str(e))
+            self.close()
+            raise
+        except (socket.error, socket.timeout) as e:
+            self.close()
+
+            self.logger.error('Socket error: %s' % str(e))
+            if str(e) == 'timed out':
+                raise ConnectionError('no banner from server') from e
+            else:
+                raise ConnectionError(e) from e
+
+        self._connected = True
+
     def _socket_readlines(self, blocking=False):
         """
         Generator for complete lines, received from the server
@@ -61,12 +113,12 @@ class Aprsdis(aprslib.IS):
         try:
             self.sock.setblocking(0)
         except OSError as e:
-            self.logger.error(f"socket error when setblocking(0): {str(e)}")
-            raise aprslib.ConnectionDrop("connection dropped")
+            self.logger.error(f'socket error when setblocking(0): {str(e)}')
+            raise aprslib.ConnectionDrop('connection dropped') from e
 
         while not self.thread_stop:
-            short_buf = b""
-            newline = b"\r\n"
+            short_buf = b''
+            newline = b'\r\n'
 
             # set a select timeout, so we get a chance to exit
             # when user hits CTRL-C
@@ -91,11 +143,11 @@ class Aprsdis(aprslib.IS):
                         # We could just not be blocking, so empty is expected
                         continue
                     else:
-                        self.logger.error("socket.recv(): returned empty")
-                        raise aprslib.ConnectionDrop("connection dropped")
+                        self.logger.error('socket.recv(): returned empty')
+                        raise aprslib.ConnectionDrop('connection dropped')
             except OSError as e:
                 # self.logger.error("socket error on recv(): %s" % str(e))
-                if "Resource temporarily unavailable" in str(e):
+                if 'Resource temporarily unavailable' in str(e):
                     if not blocking:
                         if len(self.buf) == 0:
                             break
@@ -111,22 +163,22 @@ class Aprsdis(aprslib.IS):
         """
         Sends login string to server
         """
-        login_str = "user {0} pass {1} vers github.com/craigerl/aprsd {3}{2}\r\n"
+        login_str = 'user {0} pass {1} vers Python-APRSD {3}{2}\r\n'
         login_str = login_str.format(
             self.callsign,
             self.passwd,
-            (" filter " + self.filter) if self.filter != "" else "",
+            (' filter ' + self.filter) if self.filter != '' else '',
             aprsd.__version__,
         )
 
-        self.logger.debug("Sending login information")
+        self.logger.debug('Sending login information')
 
         try:
             self._sendall(login_str)
             self.sock.settimeout(5)
             test = self.sock.recv(len(login_str) + 100)
             if is_py3:
-                test = test.decode("latin-1")
+                test = test.decode('latin-1')
             test = test.rstrip()
 
             self.logger.debug("Server: '%s'", test)
@@ -134,26 +186,26 @@ class Aprsdis(aprslib.IS):
             if not test:
                 raise LoginError(f"Server Response Empty: '{test}'")
 
-            _, _, callsign, status, e = test.split(" ", 4)
-            s = e.split(",")
+            _, _, callsign, status, e = test.split(' ', 4)
+            s = e.split(',')
             if len(s):
-                server_string = s[0].replace("server ", "")
+                server_string = s[0].replace('server ', '')
             else:
-                server_string = e.replace("server ", "")
+                server_string = e.replace('server ', '')
 
-            if callsign == "":
-                raise LoginError("Server responded with empty callsign???")
+            if callsign == '':
+                raise LoginError('Server responded with empty callsign???')
             if callsign != self.callsign:
-                raise LoginError(f"Server: {test}")
-            if status != "verified," and self.passwd != "-1":
-                raise LoginError("Password is incorrect")
+                raise LoginError(f'Server: {test}')
+            if status != 'verified,' and self.passwd != '-1':
+                raise LoginError('Password is incorrect')
 
-            if self.passwd == "-1":
-                self.logger.info("Login successful (receive only)")
+            if self.passwd == '-1':
+                self.logger.info('Login successful (receive only)')
             else:
-                self.logger.info("Login successful")
+                self.logger.info('Login successful')
 
-            self.logger.info(f"Connected to {server_string}")
+            self.logger.info(f'Connected to {server_string}')
             self.server_string = server_string
 
         except LoginError as e:
@@ -164,7 +216,7 @@ class Aprsdis(aprslib.IS):
             self.close()
             self.logger.error(f"Failed to login '{e}'")
             self.logger.exception(e)
-            raise LoginError("Failed to login")
+            raise LoginError('Failed to login') from e
 
     def consumer(self, callback, blocking=True, immortal=False, raw=False):
         """
@@ -180,21 +232,21 @@ class Aprsdis(aprslib.IS):
         """
 
         if not self._connected:
-            raise ConnectionError("not connected to a server")
+            raise ConnectionError('not connected to a server')
 
-        line = b""
+        line = b''
 
         while True and not self.thread_stop:
             try:
                 for line in self._socket_readlines(blocking):
-                    if line[0:1] != b"#":
+                    if line[0:1] != b'#':
                         self.aprsd_keepalive = datetime.datetime.now()
                         if raw:
                             callback(line)
                         else:
                             callback(self._parse(line))
                     else:
-                        self.logger.debug("Server: %s", line.decode("utf8"))
+                        self.logger.debug('Server: %s', line.decode('utf8'))
                         self.aprsd_keepalive = datetime.datetime.now()
             except ParseError as exp:
                 self.logger.log(
@@ -211,7 +263,7 @@ class Aprsdis(aprslib.IS):
                     exp.packet,
                 )
             except LoginError as exp:
-                self.logger.error("%s: %s", exp.__class__.__name__, exp)
+                self.logger.error('%s: %s', exp.__class__.__name__, exp)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except (ConnectionDrop, ConnectionError):
@@ -227,7 +279,7 @@ class Aprsdis(aprslib.IS):
             except StopIteration:
                 break
             except Exception:
-                self.logger.error("APRS Packet: %s", line)
+                self.logger.error('APRS Packet: %s', line)
                 raise
 
             if not blocking:

aprsd/client/drivers/fake.py

@@ -1,3 +1,4 @@
+import datetime
 import logging
 import threading
 import time
@@ -20,6 +21,9 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
     # flag to tell us to stop
     thread_stop = False
 
+    # date for last time we heard from the server
+    aprsd_keepalive = datetime.datetime.now()
+
     lock = threading.Lock()
     path = []
 
@@ -63,6 +67,7 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
         raw = 'GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW   :KM6LYW: 19 Miles SW'
         pkt_raw = aprslib.parse(raw)
         pkt = core.factory(pkt_raw)
+        self.aprsd_keepalive = datetime.datetime.now()
         callback(packet=pkt)
         LOG.debug(f'END blocking FAKE consumer {self}')
         time.sleep(8)

aprsd/client/drivers/kiss.py

@@ -1,32 +1,36 @@
+import datetime
 import logging
 
-from ax253 import Frame
 import kiss
+from ax253 import Frame
 from oslo_config import cfg
 
 from aprsd import conf  # noqa
 from aprsd.packets import core
 from aprsd.utils import trace
 
-
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class KISS3Client:
     path = []
 
+    # date for last time we heard from the server
+    aprsd_keepalive = datetime.datetime.now()
+    _connected = False
+
     def __init__(self):
         self.setup()
 
     def is_alive(self):
-        return True
+        return self._connected
 
     def setup(self):
         # we can be TCP kiss or Serial kiss
         if CONF.kiss_serial.enabled:
             LOG.debug(
-                "KISS({}) Serial connection to {}".format(
+                'KISS({}) Serial connection to {}'.format(
                     kiss.__version__,
                     CONF.kiss_serial.device,
                 ),
@@ -39,7 +43,7 @@ class KISS3Client:
             self.path = CONF.kiss_serial.path
         elif CONF.kiss_tcp.enabled:
             LOG.debug(
-                "KISS({}) TCP Connection to {}:{}".format(
+                'KISS({}) TCP Connection to {}:{}'.format(
                     kiss.__version__,
                     CONF.kiss_tcp.host,
                     CONF.kiss_tcp.port,
@@ -52,18 +56,34 @@ class KISS3Client:
             )
             self.path = CONF.kiss_tcp.path
 
-        LOG.debug("Starting KISS interface connection")
-        self.kiss.start()
+        LOG.debug('Starting KISS interface connection')
+        try:
+            self.kiss.start()
+            if self.kiss.protocol.transport.is_closing():
+                LOG.warning('KISS transport is closing, not setting consumer callback')
+                self._connected = False
+            else:
+                self._connected = True
+        except Exception:
+            LOG.error('Failed to start KISS interface.')
+            self._connected = False
 
     @trace.trace
     def stop(self):
+        if not self._connected:
+            # do nothing since we aren't connected
+            return
+
         try:
             self.kiss.stop()
             self.kiss.loop.call_soon_threadsafe(
                 self.kiss.protocol.transport.close,
             )
-        except Exception as ex:
-            LOG.exception(ex)
+        except Exception:
+            LOG.error('Failed to stop KISS interface.')
+
+    def close(self):
+        self.stop()
 
     def set_filter(self, filter):
         # This does nothing right now.
@@ -74,18 +94,23 @@ class KISS3Client:
             frame = Frame.from_bytes(frame_bytes)
             # Now parse it with aprslib
             kwargs = {
-                "frame": frame,
+                'frame': frame,
             }
             self._parse_callback(**kwargs)
+            self.aprsd_keepalive = datetime.datetime.now()
         except Exception as ex:
-            LOG.error("Failed to parse bytes received from KISS interface.")
+            LOG.error('Failed to parse bytes received from KISS interface.')
             LOG.exception(ex)
 
     def consumer(self, callback):
-        LOG.debug("Start blocking KISS consumer")
+        if not self._connected:
+            raise Exception('KISS transport is not connected')
+
         self._parse_callback = callback
-        self.kiss.read(callback=self.parse_frame, min_frames=None)
-        LOG.debug(f"END blocking KISS consumer {self.kiss}")
+        if not self.kiss.protocol.transport.is_closing():
+            self.kiss.read(callback=self.parse_frame, min_frames=1)
+        else:
+            self._connected = False
 
     def send(self, packet):
         """Send an APRS Message object."""
@@ -94,24 +119,24 @@ class KISS3Client:
         path = self.path
         if isinstance(packet, core.Packet):
             packet.prepare()
-            payload = packet.payload.encode("US-ASCII")
+            payload = packet.payload.encode('US-ASCII')
             if packet.path:
                 path = packet.path
         else:
-            msg_payload = f"{packet.raw}{{{str(packet.msgNo)}"
+            msg_payload = f'{packet.raw}{{{str(packet.msgNo)}'
             payload = (
-                ":{:<9}:{}".format(
+                ':{:<9}:{}'.format(
                     packet.to_call,
                     msg_payload,
                 )
-            ).encode("US-ASCII")
+            ).encode('US-ASCII')
 
         LOG.debug(
             f"KISS Send '{payload}' TO '{packet.to_call}' From "
             f"'{packet.from_call}' with PATH '{path}'",
         )
         frame = Frame.ui(
-            destination="APZ100",
+            destination='APZ100',
             source=packet.from_call,
             path=path,
             info=payload,

aprsd/client/kiss.py

@@ -12,7 +12,7 @@ from aprsd.client.drivers import kiss
 from aprsd.packets import core
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 LOGU = logger
 
 
@@ -27,15 +27,15 @@ class KISSClient(base.APRSClient):
             if serializable:
                 keepalive = keepalive.isoformat()
             stats = {
-                "connected": self.is_connected,
-                "connection_keepalive": keepalive,
-                "transport": self.transport(),
+                'connected': self.is_connected,
+                'connection_keepalive': keepalive,
+                'transport': self.transport(),
             }
             if self.transport() == client.TRANSPORT_TCPKISS:
-                stats["host"] = CONF.kiss_tcp.host
-                stats["port"] = CONF.kiss_tcp.port
+                stats['host'] = CONF.kiss_tcp.host
+                stats['port'] = CONF.kiss_tcp.port
             elif self.transport() == client.TRANSPORT_SERIALKISS:
-                stats["device"] = CONF.kiss_serial.device
+                stats['device'] = CONF.kiss_serial.device
         return stats
 
     @staticmethod
@@ -56,15 +56,15 @@ class KISSClient(base.APRSClient):
             transport = KISSClient.transport()
             if transport == client.TRANSPORT_SERIALKISS:
                 if not CONF.kiss_serial.device:
-                    LOG.error("KISS serial enabled, but no device is set.")
+                    LOG.error('KISS serial enabled, but no device is set.')
                     raise exception.MissingConfigOptionException(
-                        "kiss_serial.device is not set.",
+                        'kiss_serial.device is not set.',
                     )
             elif transport == client.TRANSPORT_TCPKISS:
                 if not CONF.kiss_tcp.host:
-                    LOG.error("KISS TCP enabled, but no host is set.")
+                    LOG.error('KISS TCP enabled, but no host is set.')
                     raise exception.MissingConfigOptionException(
-                        "kiss_tcp.host is not set.",
+                        'kiss_tcp.host is not set.',
                     )
 
             return True
@@ -91,8 +91,8 @@ class KISSClient(base.APRSClient):
         if ka := self._client.aprsd_keepalive:
             keepalive = timeago.format(ka)
         else:
-            keepalive = "N/A"
-        LOGU.opt(colors=True).info(f"<green>Client keepalive {keepalive}</green>")
+            keepalive = 'N/A'
+        LOGU.opt(colors=True).info(f'<green>Client keepalive {keepalive}</green>')
 
     @staticmethod
     def transport():
@@ -104,8 +104,8 @@ class KISSClient(base.APRSClient):
 
     def decode_packet(self, *args, **kwargs):
         """We get a frame, which has to be decoded."""
-        LOG.debug(f"kwargs {kwargs}")
-        frame = kwargs["frame"]
+        LOG.debug(f'kwargs {kwargs}')
+        frame = kwargs['frame']
         LOG.debug(f"Got an APRS Frame '{frame}'")
         # try and nuke the * from the fromcall sign.
         # frame.header._source._ch = False
@@ -114,20 +114,23 @@ class KISSClient(base.APRSClient):
         # msg = frame.tnc2
         # LOG.debug(f"Decoding {msg}")
 
-        raw = aprslib.parse(str(frame))
-        packet = core.factory(raw)
-        if isinstance(packet, core.ThirdPartyPacket):
-            return packet.subpacket
-        else:
-            return packet
+        try:
+            raw = aprslib.parse(str(frame))
+            packet = core.factory(raw)
+            if isinstance(packet, core.ThirdPartyPacket):
+                return packet.subpacket
+            else:
+                return packet
+        except Exception as ex:
+            LOG.error(f'Error decoding packet: {ex}')
 
     def setup_connection(self):
         try:
             self._client = kiss.KISS3Client()
-            self.connected = self.login_status["success"] = True
+            self.connected = self.login_status['success'] = True
         except Exception as ex:
-            self.connected = self.login_status["success"] = False
-            self.login_status["message"] = str(ex)
+            self.connected = self.login_status['success'] = False
+            self.login_status['message'] = str(ex)
         return self._client
 
     def consumer(self, callback, blocking=False, immortal=False, raw=False):
@@ -135,5 +138,6 @@ class KISSClient(base.APRSClient):
             self._client.consumer(callback)
             self.keepalive = datetime.datetime.now()
         except Exception as ex:
-            LOG.error(f"Consumer failed {ex}")
+            LOG.error(f'Consumer failed {ex}')
             LOG.error(ex)
+            raise ex