aprsd 4.1.2__py3-none-any.whl → 4.2.1__py3-none-any.whl

aprsd/client/__init__.py

@@ -1,13 +1,5 @@
-from aprsd.client import aprsis, factory, fake, kiss
-
-
-TRANSPORT_APRSIS = "aprsis"
-TRANSPORT_TCPKISS = "tcpkiss"
-TRANSPORT_SERIALKISS = "serialkiss"
-TRANSPORT_FAKE = "fake"
-
-
-client_factory = factory.ClientFactory()
-client_factory.register(aprsis.APRSISClient)
-client_factory.register(kiss.KISSClient)
-client_factory.register(fake.APRSDFakeClient)
+# define the client transports here
+TRANSPORT_APRSIS = 'aprsis'
+TRANSPORT_TCPKISS = 'tcpkiss'
+TRANSPORT_SERIALKISS = 'serialkiss'
+TRANSPORT_FAKE = 'fake'

aprsd/client/client.py

@@ -0,0 +1,156 @@
+import logging
+import threading
+from typing import Callable
+
+import timeago
+import wrapt
+from loguru import logger
+from oslo_config import cfg
+
+from aprsd.client import drivers  # noqa - ensure drivers are registered
+from aprsd.client.drivers.registry import DriverRegistry
+from aprsd.packets import core
+from aprsd.utils import keepalive_collector
+
+CONF = cfg.CONF
+LOG = logging.getLogger('APRSD')
+LOGU = logger
+
+
+class APRSDClient:
+    """APRSD client class.
+
+    This is a singleton class that provides a single instance of the APRSD client.
+    It is responsible for connecting to the appropriate APRSD client driver based on
+    the configuration.
+
+    """
+
+    _instance = None
+    driver = None
+    lock = threading.Lock()
+    filter = None
+
+    def __new__(cls, *args, **kwargs):
+        """This magic turns this into a singleton."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            keepalive_collector.KeepAliveCollector().register(cls)
+        return cls._instance
+
+    def __init__(self, auto_connect: bool = True):
+        self.auto_connect = auto_connect
+        self.connected = False
+        self.login_status = {
+            'success': False,
+            'message': None,
+        }
+        self.driver = DriverRegistry().get_driver()
+        if self.auto_connect:
+            self.connect()
+
+    def stats(self, serializable=False) -> dict:
+        stats = {}
+        if self.driver:
+            stats = self.driver.stats(serializable=serializable)
+        return stats
+
+    @staticmethod
+    def is_enabled():
+        for driver in DriverRegistry().drivers:
+            if driver.is_enabled():
+                return True
+        return False
+
+    @staticmethod
+    def is_configured():
+        """Check if ANY driver is configured."""
+        for driver in DriverRegistry().drivers:
+            if driver.is_configured():
+                return True
+        return False
+
+    # @property
+    # def is_connected(self):
+    #     if not self.driver:
+    #         return False
+    #     return self.driver.is_connected()
+
+    @property
+    def login_success(self):
+        if not self.driver:
+            return False
+        return self.driver.login_success
+
+    @property
+    def login_failure(self):
+        if not self.driver:
+            return None
+        return self.driver.login_failure
+
+    def set_filter(self, filter):
+        self.filter = filter
+        if not self.driver:
+            return
+        self.driver.set_filter(filter)
+
+    def get_filter(self):
+        if not self.driver:
+            return None
+        return self.driver.filter
+
+    def is_alive(self):
+        return self.driver.is_alive()
+
+    def connect(self):
+        if not self.driver:
+            self.driver = DriverRegistry().get_driver()
+        self.driver.setup_connection()
+
+    def close(self):
+        if not self.driver:
+            return
+        self.driver.close()
+
+    @wrapt.synchronized(lock)
+    def reset(self):
+        """Call this to force a rebuild/reconnect."""
+        LOG.info('Resetting client connection.')
+        if self.driver:
+            self.driver.close()
+            if not self.delay_connect:
+                self.driver.setup_connection()
+            if self.filter:
+                self.driver.set_filter(self.filter)
+        else:
+            LOG.warning('Client not initialized, nothing to reset.')
+
+    def send(self, packet: core.Packet) -> bool:
+        return self.driver.send(packet)
+
+    # For the keepalive collector
+    def keepalive_check(self):
+        # Don't check the first time through.
+        if not self.driver.is_alive and self._checks:
+            LOG.warning("Resetting client.  It's not alive.")
+            self.reset()
+        self._checks = True
+
+    # For the keepalive collector
+    def keepalive_log(self):
+        if ka := self.driver.keepalive:
+            keepalive = timeago.format(ka)
+        else:
+            keepalive = 'N/A'
+        LOGU.opt(colors=True).info(f'<green>Client keepalive {keepalive}</green>')
+
+    def consumer(self, callback: Callable, raw: bool = False):
+        return self.driver.consumer(callback=callback, raw=raw)
+
+    def decode_packet(self, *args, **kwargs) -> core.Packet:
+        try:
+            packet = self.driver.decode_packet(*args, **kwargs)
+        except Exception as e:
+            LOG.error(f'Error decoding packet: {e}')
+            return None
+        return packet

aprsd/client/drivers/__init__.py

@@ -0,0 +1,10 @@
+# All client drivers must be registered here
+from aprsd.client.drivers.aprsis import APRSISDriver
+from aprsd.client.drivers.fake import APRSDFakeDriver
+from aprsd.client.drivers.registry import DriverRegistry
+from aprsd.client.drivers.tcpkiss import TCPKISSDriver
+
+driver_registry = DriverRegistry()
+driver_registry.register(APRSDFakeDriver)
+driver_registry.register(APRSISDriver)
+driver_registry.register(TCPKISSDriver)

aprsd/client/drivers/aprsis.py

@@ -1,286 +1,205 @@
 import datetime
 import logging
-import select
-import socket
-import threading
+import time
+from typing import Callable
 
-import aprslib
-import wrapt
-from aprslib import is_py3
-from aprslib.exceptions import (
-    ConnectionDrop,
-    ConnectionError,
-    GenericError,
-    LoginError,
-    ParseError,
-    UnknownFormat,
-)
+from aprslib.exceptions import LoginError
+from loguru import logger
+from oslo_config import cfg
 
-import aprsd
+from aprsd import client, exception
+from aprsd.client.drivers.lib.aprslib import APRSLibClient
 from aprsd.packets import core
 
+CONF = cfg.CONF
 LOG = logging.getLogger('APRSD')
+LOGU = logger
 
 
-class Aprsdis(aprslib.IS):
-    """Extend the aprslib class so we can exit properly."""
+# class APRSISDriver(metaclass=trace.TraceWrapperMetaclass):
+class APRSISDriver:
+    """This is the APRS-IS driver for the APRSD client.
 
-    # flag to tell us to stop
-    thread_stop = False
+    This driver uses our modified aprslib.IS class to connect to the APRS-IS server.
 
-    # date for last time we heard from the server
-    aprsd_keepalive = datetime.datetime.now()
+    """
 
-    # Which server we are connected to?
-    server_string = 'None'
+    _client = None
+    _checks = False
+    connected = False
 
-    # timeout in seconds
-    select_timeout = 1
-    lock = threading.Lock()
-
-    def stop(self):
-        self.thread_stop = True
-        LOG.warning('Shutdown Aprsdis client.')
-
-    def close(self):
-        LOG.warning('Closing Aprsdis client.')
-        super().close()
-
-    @wrapt.synchronized(lock)
-    def send(self, packet: core.Packet):
-        """Send an APRS Message object."""
-        self.sendall(packet.raw)
-
-    def is_alive(self):
-        """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]
-        )
+    def __init__(self):
+        max_timeout = {'hours': 0.0, 'minutes': 2, 'seconds': 0}
+        self.max_delta = datetime.timedelta(**max_timeout)
+        self.login_status = {
+            'success': False,
+            'message': None,
+        }
 
+    @staticmethod
+    def is_enabled():
+        # Defaults to True if the enabled flag is non existent
         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
-        """
-        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') from e
+            return CONF.aprs_network.enabled
+        except KeyError:
+            return False
+
+    @staticmethod
+    def is_configured():
+        if APRSISDriver.is_enabled():
+            # Ensure that the config vars are correctly set
+            if not CONF.aprs_network.login:
+                LOG.error('Config aprs_network.login not set.')
+                raise exception.MissingConfigOptionException(
+                    'aprs_network.login is not set.',
+                )
+            if not CONF.aprs_network.password:
+                LOG.error('Config aprs_network.password not set.')
+                raise exception.MissingConfigOptionException(
+                    'aprs_network.password is not set.',
+                )
+            if not CONF.aprs_network.host:
+                LOG.error('Config aprs_network.host not set.')
+                raise exception.MissingConfigOptionException(
+                    'aprs_network.host is not set.',
+                )
 
-        while not self.thread_stop:
-            short_buf = b''
-            newline = b'\r\n'
+            return True
+        return True
 
-            # set a select timeout, so we get a chance to exit
-            # when user hits CTRL-C
-            readable, writable, exceptional = select.select(
-                [self.sock],
-                [],
-                [],
-                self.select_timeout,
-            )
-            if not readable:
-                if not blocking:
-                    break
-                else:
-                    continue
+    @property
+    def is_alive(self):
+        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:
+            self._client.stop()
+            self._client.close()
+
+    def send(self, packet: core.Packet) -> bool:
+        return self._client.send(packet)
+
+    def setup_connection(self):
+        user = CONF.aprs_network.login
+        password = CONF.aprs_network.password
+        host = CONF.aprs_network.host
+        port = CONF.aprs_network.port
+        self.connected = False
+        backoff = 1
+        retries = 3
+        retry_count = 0
+        while not self.connected:
+            retry_count += 1
+            if retry_count >= retries:
+                break
             try:
-                short_buf = self.sock.recv(4096)
-
-                # sock.recv returns empty if the connection drops
-                if not short_buf:
-                    if not blocking:
-                        # We could just not be blocking, so empty is expected
-                        continue
-                    else:
-                        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 not blocking:
-                        if len(self.buf) == 0:
-                            break
-
-            self.buf += short_buf
-
-            while newline in self.buf:
-                line, self.buf = self.buf.split(newline, 1)
-
-                yield line
-
-    def _send_login(self):
-        """
-        Sends login string to server
-        """
-        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 '',
-            aprsd.__version__,
-        )
-
-        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.rstrip()
-
-            self.logger.debug("Server: '%s'", test)
-
-            if not test:
-                raise LoginError(f"Server Response Empty: '{test}'")
-
-            _, _, callsign, status, e = test.split(' ', 4)
-            s = e.split(',')
-            if len(s):
-                server_string = s[0].replace('server ', '')
-            else:
-                server_string = e.replace('server ', '')
-
-            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')
+                LOG.info(
+                    f'Creating aprslib client({host}:{port}) and logging in {user}.'
+                )
+                self._client = APRSLibClient(
+                    user, passwd=password, host=host, port=port
+                )
+                # Force the log to be the same
+                self._client.logger = LOG
+                self._client.connect()
+                self.connected = self.login_status['success'] = True
+                self.login_status['message'] = self._client.server_string
+                backoff = 1
+            except LoginError as e:
+                LOG.error(f"Failed to login to APRS-IS Server '{e}'")
+                self.connected = self.login_status['success'] = False
+                self.login_status['message'] = (
+                    e.message if hasattr(e, 'message') else str(e)
+                )
+                LOG.error(self.login_status['message'])
+                time.sleep(backoff)
+            except Exception as e:
+                LOG.error(f"Unable to connect to APRS-IS server. '{e}' ")
+                self.connected = self.login_status['success'] = False
+                self.login_status['message'] = getattr(e, 'message', str(e))
+                time.sleep(backoff)
+                # Don't allow the backoff to go to inifinity.
+                if backoff > 5:
+                    backoff = 5
+                else:
+                    backoff += 1
+                continue
 
-            if self.passwd == '-1':
-                self.logger.info('Login successful (receive only)')
-            else:
-                self.logger.info('Login successful')
+    def set_filter(self, filter):
+        self._client.set_filter(filter)
 
-            self.logger.info(f'Connected to {server_string}')
-            self.server_string = server_string
+    def login_success(self) -> bool:
+        return self.login_status.get('success', False)
 
-        except LoginError as e:
-            self.logger.error(str(e))
-            self.close()
-            raise
-        except Exception as e:
-            self.close()
-            self.logger.error(f"Failed to login '{e}'")
-            self.logger.exception(e)
-            raise LoginError('Failed to login') from e
+    def login_failure(self) -> str:
+        return self.login_status.get('message', None)
 
-    def consumer(self, callback, blocking=True, immortal=False, raw=False):
-        """
-        When a position sentence is received, it will be passed to the callback function
+    @property
+    def filter(self):
+        return self._client.filter
 
-        blocking: if true (default), runs forever, otherwise will return after one sentence
-                  You can still exit the loop, by raising StopIteration in the callback function
+    @property
+    def server_string(self):
+        return self._client.server_string
 
-        immortal: When true, consumer will try to reconnect and stop propagation of Parse exceptions
-                  if false (default), consumer will return
+    @property
+    def keepalive(self):
+        return self._client.aprsd_keepalive
 
-        raw: when true, raw packet is passed to callback, otherwise the result from aprs.parse()
-        """
+    def _is_stale_connection(self):
+        delta = datetime.datetime.now() - self._client.aprsd_keepalive
+        if delta > self.max_delta:
+            LOG.error(f'Connection is stale, last heard {delta} ago.')
+            return True
+        return False
 
-        if not self._connected:
-            raise ConnectionError('not connected to a server')
+    @staticmethod
+    def transport():
+        return client.TRANSPORT_APRSIS
 
-        line = b''
+    def decode_packet(self, *args, **kwargs):
+        """APRS lib already decodes this."""
+        return core.factory(args[0])
 
-        while True and not self.thread_stop:
+    def consumer(self, callback: Callable, raw: bool = False):
+        if self._client and self.connected:
             try:
-                for line in self._socket_readlines(blocking):
-                    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.aprsd_keepalive = datetime.datetime.now()
-            except ParseError as exp:
-                self.logger.log(
-                    11,
-                    "%s    Packet: '%s'",
-                    exp,
-                    exp.packet,
-                )
-            except UnknownFormat as exp:
-                self.logger.log(
-                    9,
-                    "%s    Packet: '%s'",
-                    exp,
-                    exp.packet,
+                self._client.consumer(
+                    callback,
+                    blocking=False,
+                    immortal=False,
+                    raw=raw,
                 )
-            except LoginError as exp:
-                self.logger.error('%s: %s', exp.__class__.__name__, exp)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except (ConnectionDrop, ConnectionError):
-                self.close()
-
-                if not immortal:
-                    raise
-                else:
-                    self.connect(blocking=blocking)
-                    continue
-            except GenericError:
-                pass
-            except StopIteration:
-                break
-            except Exception:
-                self.logger.error('APRS Packet: %s', line)
-                raise
-
-            if not blocking:
-                break
+            except Exception as e:
+                LOG.error(e)
+                LOG.info(e.__cause__)
+                raise e
+        else:
+            self.connected = False
+
+    def stats(self, serializable: bool = 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()
+                filter = self.filter
+            else:
+                keepalive = 'None'
+                server_string = 'None'
+                filter = 'None'
+            stats = {
+                'connected': self.is_alive,
+                'filter': filter,
+                'login_status': self.login_status,
+                'connection_keepalive': keepalive,
+                'server_string': server_string,
+                'transport': self.transport(),
+            }
+
+        return stats