aprsd 3.4.3__py3-none-any.whl → 4.0.0__py3-none-any.whl

aprsd/cli_helper.py

@@ -1,7 +1,7 @@
-from functools import update_wrapper
 import logging
-from pathlib import Path
 import typing as t
+from functools import update_wrapper
+from pathlib import Path
 
 import click
 from oslo_config import cfg
@@ -11,7 +11,6 @@ from aprsd import conf  # noqa: F401
 from aprsd.log import log
 from aprsd.utils import trace
 
-
 CONF = cfg.CONF
 home = str(Path.home())
 DEFAULT_CONFIG_DIR = f"{home}/.config/aprsd/"
@@ -58,6 +57,7 @@ class AliasedGroup(click.Group):
         calling into :meth:`add_command`.
         Copied from `click` and extended for `aliases`.
         """
+
         def decorator(f):
             aliases = kwargs.pop("aliases", [])
             cmd = click.decorators.command(*args, **kwargs)(f)
@@ -65,6 +65,7 @@ class AliasedGroup(click.Group):
             for alias in aliases:
                 self.add_command(cmd, name=alias)
             return cmd
+
         return decorator
 
     def group(self, *args, **kwargs):
@@ -74,6 +75,7 @@ class AliasedGroup(click.Group):
         calling into :meth:`add_command`.
         Copied from `click` and extended for `aliases`.
         """
+
         def decorator(f):
             aliases = kwargs.pop("aliases", [])
             cmd = click.decorators.group(*args, **kwargs)(f)
@@ -81,6 +83,7 @@ class AliasedGroup(click.Group):
             for alias in aliases:
                 self.add_command(cmd, name=alias)
             return cmd
+
         return decorator
 
 
@@ -89,6 +92,7 @@ def add_options(options):
         for option in reversed(options):
             func = option(func)
         return func
+
     return _add_options
 
 
@@ -103,7 +107,9 @@ def process_standard_options(f: F) -> F:
             default_config_files = None
         try:
             CONF(
-                [], project="aprsd", version=aprsd.__version__,
+                [],
+                project="aprsd",
+                version=aprsd.__version__,
                 default_config_files=default_config_files,
             )
         except cfg.ConfigFilesNotFoundError:
@@ -119,7 +125,7 @@ def process_standard_options(f: F) -> F:
             trace.setup_tracing(["method", "api"])
 
         if not config_file_found:
-            LOG = logging.getLogger("APRSD")   # noqa: N806
+            LOG = logging.getLogger("APRSD")  # noqa: N806
             LOG.error("No config file found!! run 'aprsd sample-config'")
 
         del kwargs["loglevel"]
@@ -132,6 +138,7 @@ def process_standard_options(f: F) -> F:
 
 def process_standard_options_no_config(f: F) -> F:
     """Use this as a decorator when config isn't needed."""
+
     def new_func(*args, **kwargs):
         ctx = args[0]
         ctx.ensure_object(dict)

aprsd/client/aprsis.py

@@ -2,7 +2,9 @@ import datetime
 import logging
 import time
 
+import timeago
 from aprslib.exceptions import LoginError
+from loguru import logger
 from oslo_config import cfg
 
 from aprsd import client, exception
@@ -10,30 +12,55 @@ from aprsd.client import base
 from aprsd.client.drivers import aprsis
 from aprsd.packets import core
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
+LOGU = logger
 
 
 class APRSISClient(base.APRSClient):
-
     _client = None
+    _checks = False
 
     def __init__(self):
         max_timeout = {"hours": 0.0, "minutes": 2, "seconds": 0}
         self.max_delta = datetime.timedelta(**max_timeout)
 
-    def stats(self) -> dict:
+    def stats(self, serializable=False) -> dict:
         stats = {}
         if self.is_configured():
+            if self._client:
+                keepalive = self._client.aprsd_keepalive
+                server_string = self._client.server_string
+                if serializable:
+                    keepalive = keepalive.isoformat()
+            else:
+                keepalive = "None"
+                server_string = "None"
             stats = {
-                "server_string": self._client.server_string,
-                "sever_keepalive": self._client.aprsd_keepalive,
+                "connected": self.is_connected,
                 "filter": self.filter,
+                "login_status": self.login_status,
+                "connection_keepalive": keepalive,
+                "server_string": server_string,
+                "transport": self.transport(),
             }
 
         return stats
 
+    def keepalive_check(self):
+        # Don't check the first time through.
+        if not self.is_alive() and self._checks:
+            LOG.warning("Resetting client.  It's not alive.")
+            self.reset()
+        self._checks = True
+
+    def keepalive_log(self):
+        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>")
+
     @staticmethod
     def is_enabled():
         # Defaults to True if the enabled flag is non existent
@@ -70,13 +97,13 @@ class APRSISClient(base.APRSClient):
         if delta > self.max_delta:
             LOG.error(f"Connection is stale, last heard {delta} ago.")
             return True
+        return False
 
     def is_alive(self):
-        if self._client:
-            return self._client.is_alive() and not self._is_stale_connection()
-        else:
+        if not self._client:
             LOG.warning(f"APRS_CLIENT {self._client} alive? NO!!!")
             return False
+        return self._client.is_alive() and not self._is_stale_connection()
 
     def close(self):
         if self._client:
@@ -99,22 +126,35 @@ class APRSISClient(base.APRSClient):
         self.connected = False
         backoff = 1
         aprs_client = None
+        retries = 3
+        retry_count = 0
         while not self.connected:
+            retry_count += 1
+            if retry_count >= retries:
+                break
             try:
-                LOG.info(f"Creating aprslib client({host}:{port}) and logging in {user}.")
-                aprs_client = aprsis.Aprsdis(user, passwd=password, host=host, port=port)
+                LOG.info(
+                    f"Creating aprslib client({host}:{port}) and logging in {user}."
+                )
+                aprs_client = aprsis.Aprsdis(
+                    user, passwd=password, host=host, port=port
+                )
                 # Force the log to be the same
                 aprs_client.logger = LOG
                 aprs_client.connect()
-                self.connected = True
+                self.connected = self.login_status["success"] = True
+                self.login_status["message"] = aprs_client.server_string
                 backoff = 1
             except LoginError as e:
                 LOG.error(f"Failed to login to APRS-IS Server '{e}'")
-                self.connected = False
+                self.connected = self.login_status["success"] = False
+                self.login_status["message"] = e.message
+                LOG.error(e.message)
                 time.sleep(backoff)
             except Exception as e:
                 LOG.error(f"Unable to connect to APRS-IS server. '{e}' ")
-                self.connected = False
+                self.connected = self.login_status["success"] = False
+                self.login_status["message"] = e.message
                 time.sleep(backoff)
                 # Don't allow the backoff to go to inifinity.
                 if backoff > 5:
@@ -126,7 +166,18 @@ class APRSISClient(base.APRSClient):
         return aprs_client
 
     def consumer(self, callback, blocking=False, immortal=False, raw=False):
-        self._client.consumer(
-            callback, blocking=blocking,
-            immortal=immortal, raw=raw,
-        )
+        if self._client:
+            try:
+                self._client.consumer(
+                    callback,
+                    blocking=blocking,
+                    immortal=immortal,
+                    raw=raw,
+                )
+            except Exception as e:
+                LOG.error(e)
+                LOG.info(e.__cause__)
+                raise e
+        else:
+            LOG.warning("client is None, might be resetting.")
+            self.connected = False

aprsd/client/base.py

@@ -2,11 +2,11 @@ import abc
 import logging
 import threading
 
-from oslo_config import cfg
 import wrapt
+from oslo_config import cfg
 
 from aprsd.packets import core
-
+from aprsd.utils import keepalive_collector
 
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
@@ -19,6 +19,10 @@ class APRSClient:
     _client = None
 
     connected = False
+    login_status = {
+        "success": False,
+        "message": None,
+    }
     filter = None
     lock = threading.Lock()
 
@@ -26,13 +30,40 @@ class APRSClient:
         """This magic turns this into a singleton."""
         if cls._instance is None:
             cls._instance = super().__new__(cls)
+            keepalive_collector.KeepAliveCollector().register(cls)
             # Put any initialization here.
             cls._instance._create_client()
         return cls._instance
 
     @abc.abstractmethod
     def stats(self) -> dict:
-        pass
+        """Return statistics about the client connection.
+
+        Returns:
+            dict: Statistics about the connection and packet handling
+        """
+
+    @abc.abstractmethod
+    def keepalive_check(self) -> None:
+        """Called during keepalive run to check status."""
+        ...
+
+    @abc.abstractmethod
+    def keepalive_log(self) -> None:
+        """Log any keepalive information."""
+        ...
+
+    @property
+    def is_connected(self):
+        return self.connected
+
+    @property
+    def login_success(self):
+        return self.login_status.get("success", False)
+
+    @property
+    def login_failure(self):
+        return self.login_status["message"]
 
     def set_filter(self, filter):
         self.filter = filter
@@ -46,22 +77,31 @@ class APRSClient:
         return self._client
 
     def _create_client(self):
-        self._client = self.setup_connection()
-        if self.filter:
-            LOG.info("Creating APRS client filter")
-            self._client.set_filter(self.filter)
+        try:
+            self._client = self.setup_connection()
+            if self.filter:
+                LOG.info("Creating APRS client filter")
+                self._client.set_filter(self.filter)
+        except Exception as e:
+            LOG.error(f"Failed to create APRS client: {e}")
+            self._client = None
+            raise
 
     def stop(self):
         if self._client:
             LOG.info("Stopping client connection.")
             self._client.stop()
 
-    def send(self, packet: core.Packet):
-        """Send a packet to the network."""
+    def send(self, packet: core.Packet) -> None:
+        """Send a packet to the network.
+
+        Args:
+            packet: The APRS packet to send
+        """
         self.client.send(packet)
 
     @wrapt.synchronized(lock)
-    def reset(self):
+    def reset(self) -> None:
         """Call this to force a rebuild/reconnect."""
         LOG.info("Resetting client connection.")
         if self._client:
@@ -76,7 +116,11 @@ class APRSClient:
 
     @abc.abstractmethod
     def setup_connection(self):
-        pass
+        """Initialize and return the underlying APRS connection.
+
+        Returns:
+            object: The initialized connection object
+        """
 
     @staticmethod
     @abc.abstractmethod
@@ -90,7 +134,11 @@ class APRSClient:
 
     @abc.abstractmethod
     def decode_packet(self, *args, **kwargs):
-        pass
+        """Decode raw APRS packet data into a Packet object.
+
+        Returns:
+            Packet: Decoded APRS packet
+        """
 
     @abc.abstractmethod
     def consumer(self, callback, blocking=False, immortal=False, raw=False):

aprsd/client/drivers/aprsis.py

@@ -4,17 +4,20 @@ import select
 import threading
 
 import aprslib
+import wrapt
 from aprslib import is_py3
 from aprslib.exceptions import (
-    ConnectionDrop, ConnectionError, GenericError, LoginError, ParseError,
+    ConnectionDrop,
+    ConnectionError,
+    GenericError,
+    LoginError,
+    ParseError,
     UnknownFormat,
 )
-import wrapt
 
 import aprsd
 from aprsd.packets import core
 
-
 LOG = logging.getLogger("APRSD")
 
 
@@ -27,6 +30,9 @@ class Aprsdis(aprslib.IS):
     # date for last time we heard from the server
     aprsd_keepalive = datetime.datetime.now()
 
+    # Which server we are connected to?
+    server_string = "None"
+
     # timeout in seconds
     select_timeout = 1
     lock = threading.Lock()
@@ -193,14 +199,14 @@ class Aprsdis(aprslib.IS):
             except ParseError as exp:
                 self.logger.log(
                     11,
-                    "%s\n    Packet: %s",
+                    "%s    Packet: '%s'",
                     exp,
                     exp.packet,
                 )
             except UnknownFormat as exp:
                 self.logger.log(
                     9,
-                    "%s\n    Packet: %s",
+                    "%s    Packet: '%s'",
                     exp,
                     exp.packet,
                 )

aprsd/client/drivers/fake.py

@@ -3,20 +3,19 @@ import threading
 import time
 
 import aprslib
-from oslo_config import cfg
 import wrapt
+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 APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
-    '''Fake client for testing.'''
+    """Fake client for testing."""
 
     # flag to tell us to stop
     thread_stop = False
@@ -25,12 +24,12 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
     path = []
 
     def __init__(self):
-        LOG.info("Starting APRSDFakeClient client.")
-        self.path = ["WIDE1-1", "WIDE2-1"]
+        LOG.info('Starting APRSDFakeClient client.')
+        self.path = ['WIDE1-1', 'WIDE2-1']
 
     def stop(self):
         self.thread_stop = True
-        LOG.info("Shutdown APRSDFakeClient client.")
+        LOG.info('Shutdown APRSDFakeClient client.')
 
     def is_alive(self):
         """If the connection is alive or not."""
@@ -39,35 +38,31 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
     @wrapt.synchronized(lock)
     def send(self, packet: core.Packet):
         """Send an APRS Message object."""
-        LOG.info(f"Sending packet: {packet}")
+        LOG.info(f'Sending packet: {packet}')
         payload = None
         if isinstance(packet, core.Packet):
             packet.prepare()
-            payload = packet.payload.encode("US-ASCII")
-            if packet.path:
-                packet.path
-            else:
-                self.path
+            payload = packet.payload.encode('US-ASCII')
         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"FAKE::Send '{payload}' TO '{packet.to_call}' From "
-            f"'{packet.from_call}' with PATH \"{self.path}\"",
+            f'\'{packet.from_call}\' with PATH "{self.path}"',
         )
 
     def consumer(self, callback, blocking=False, immortal=False, raw=False):
-        LOG.debug("Start non blocking FAKE consumer")
+        LOG.debug('Start non blocking FAKE consumer')
         # Generate packets here?
-        raw = "GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW   :KM6LYW: 19 Miles SW"
+        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)
         callback(packet=pkt)
-        LOG.debug(f"END blocking FAKE consumer {self}")
+        LOG.debug(f'END blocking FAKE consumer {self}')
         time.sleep(8)

aprsd/client/factory.py

@@ -4,13 +4,11 @@ from typing import Callable, Protocol, runtime_checkable
 from aprsd import exception
 from aprsd.packets import core
 
-
 LOG = logging.getLogger("APRSD")
 
 
 @runtime_checkable
 class Client(Protocol):
-
     def __init__(self):
         pass
 
@@ -42,6 +40,7 @@ class Client(Protocol):
 class ClientFactory:
     _instance = None
     clients = []
+    client = None
 
     def __new__(cls, *args, **kwargs):
         """This magic turns this into a singleton."""
@@ -62,9 +61,13 @@ class ClientFactory:
     def create(self, key=None):
         for client in self.clients:
             if client.is_enabled():
-                return client()
+                self.client = client()
+                return self.client
         raise Exception("No client is configured!!")
 
+    def client_exists(self):
+        return bool(self.client)
+
     def is_client_enabled(self):
         """Make sure at least one client is enabled."""
         enabled = False

aprsd/client/fake.py

@@ -7,15 +7,16 @@ from aprsd.client import base
 from aprsd.client.drivers import fake as fake_driver
 from aprsd.utils import trace
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
 class APRSDFakeClient(base.APRSClient, metaclass=trace.TraceWrapperMetaclass):
-
-    def stats(self) -> dict:
-        return {}
+    def stats(self, serializable=False) -> dict:
+        return {
+            "transport": "Fake",
+            "connected": True,
+        }
 
     @staticmethod
     def is_enabled():

aprsd/client/kiss.py

@@ -1,6 +1,9 @@
+import datetime
 import logging
 
 import aprslib
+import timeago
+from loguru import logger
 from oslo_config import cfg
 
 from aprsd import client, exception
@@ -8,21 +11,31 @@ from aprsd.client import base
 from aprsd.client.drivers import kiss
 from aprsd.packets import core
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
+LOGU = logger
 
 
 class KISSClient(base.APRSClient):
-
     _client = None
+    keepalive = datetime.datetime.now()
 
-    def stats(self) -> dict:
+    def stats(self, serializable=False) -> dict:
         stats = {}
         if self.is_configured():
-            return {
+            keepalive = self.keepalive
+            if serializable:
+                keepalive = keepalive.isoformat()
+            stats = {
+                "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
+            elif self.transport() == client.TRANSPORT_SERIALKISS:
+                stats["device"] = CONF.kiss_serial.device
         return stats
 
     @staticmethod
@@ -67,6 +80,20 @@ class KISSClient(base.APRSClient):
         if self._client:
             self._client.stop()
 
+    def keepalive_check(self):
+        # Don't check the first time through.
+        if not self.is_alive() and self._checks:
+            LOG.warning("Resetting client.  It's not alive.")
+            self.reset()
+        self._checks = True
+
+    def keepalive_log(self):
+        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>")
+
     @staticmethod
     def transport():
         if CONF.kiss_serial.enabled:
@@ -95,9 +122,18 @@ class KISSClient(base.APRSClient):
             return packet
 
     def setup_connection(self):
-        self._client = kiss.KISS3Client()
-        self.connected = True
+        try:
+            self._client = kiss.KISS3Client()
+            self.connected = self.login_status["success"] = True
+        except Exception as 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):
-        self._client.consumer(callback)
+        try:
+            self._client.consumer(callback)
+            self.keepalive = datetime.datetime.now()
+        except Exception as ex:
+            LOG.error(f"Consumer failed {ex}")
+            LOG.error(ex)

aprsd/client/stats.py

@@ -1,38 +1,18 @@
 import threading
 
-from oslo_config import cfg
 import wrapt
+from oslo_config import cfg
 
 from aprsd import client
 from aprsd.utils import singleton
 
-
 CONF = cfg.CONF
 
 
 @singleton
 class APRSClientStats:
-
     lock = threading.Lock()
 
     @wrapt.synchronized(lock)
     def stats(self, serializable=False):
-        cl = client.client_factory.create()
-        stats = {
-            "transport": cl.transport(),
-            "filter": cl.filter,
-            "connected": cl.connected,
-        }
-
-        if cl.transport() == client.TRANSPORT_APRSIS:
-            stats["server_string"] = cl.client.server_string
-            keepalive = cl.client.aprsd_keepalive
-            if serializable:
-                keepalive = keepalive.isoformat()
-            stats["server_keepalive"] = keepalive
-        elif cl.transport() == client.TRANSPORT_TCPKISS:
-            stats["host"] = CONF.kiss_tcp.host
-            stats["port"] = CONF.kiss_tcp.port
-        elif cl.transport() == client.TRANSPORT_SERIALKISS:
-            stats["device"] = CONF.kiss_serial.device
-        return stats
+        return client.client_factory.create().stats(serializable=serializable)