aprsd 4.1.1__py3-none-any.whl → 4.2.0__py3-none-any.whl

aprsd/client/drivers/fake.py

@@ -2,6 +2,7 @@ import datetime
 import logging
 import threading
 import time
+from typing import Callable
 
 import aprslib
 import wrapt
@@ -15,7 +16,7 @@ CONF = cfg.CONF
 LOG = logging.getLogger('APRSD')
 
 
-class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
+class APRSDFakeDriver(metaclass=trace.TraceWrapperMetaclass):
     """Fake client for testing."""
 
     # flag to tell us to stop
@@ -28,17 +29,40 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
     path = []
 
     def __init__(self):
-        LOG.info('Starting APRSDFakeClient client.')
+        LOG.info('Starting APRSDFakeDriver driver.')
         self.path = ['WIDE1-1', 'WIDE2-1']
 
-    def stop(self):
-        self.thread_stop = True
-        LOG.info('Shutdown APRSDFakeClient client.')
+    @staticmethod
+    def is_enabled():
+        if CONF.fake_client.enabled:
+            return True
+        return False
+
+    @staticmethod
+    def is_configured():
+        return APRSDFakeDriver.is_enabled
 
     def is_alive(self):
         """If the connection is alive or not."""
         return not self.thread_stop
 
+    def close(self):
+        self.thread_stop = True
+        LOG.info('Shutdown APRSDFakeDriver driver.')
+
+    def setup_connection(self):
+        # It's fake....
+        pass
+
+    def set_filter(self, filter: str) -> None:
+        pass
+
+    def login_success(self) -> bool:
+        return True
+
+    def login_failure(self) -> str:
+        return None
+
     @wrapt.synchronized(lock)
     def send(self, packet: core.Packet):
         """Send an APRS Message object."""
@@ -61,13 +85,37 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
             f'\'{packet.from_call}\' with PATH "{self.path}"',
         )
 
-    def consumer(self, callback, blocking=False, immortal=False, raw=False):
+    def consumer(self, callback: Callable, raw: bool = False):
         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'
-        pkt_raw = aprslib.parse(raw)
-        pkt = core.factory(pkt_raw)
+        raw_str = 'GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW   :KM6LYW: 19 Miles SW'
         self.aprsd_keepalive = datetime.datetime.now()
-        callback(packet=pkt)
+        if raw:
+            callback(raw=raw_str)
+        else:
+            pkt_raw = aprslib.parse(raw_str)
+            pkt = core.factory(pkt_raw)
+            callback(packet=pkt)
+
         LOG.debug(f'END blocking FAKE consumer {self}')
-        time.sleep(8)
+        time.sleep(1)
+
+    def decode_packet(self, *args, **kwargs):
+        """APRS lib already decodes this."""
+        if not kwargs:
+            return None
+
+        if kwargs.get('packet'):
+            return kwargs.get('packet')
+
+        if kwargs.get('raw'):
+            pkt_raw = aprslib.parse(kwargs.get('raw'))
+            pkt = core.factory(pkt_raw)
+            return pkt
+
+    def stats(self, serializable: bool = False) -> dict:
+        return {
+            'driver': self.__class__.__name__,
+            'is_alive': self.is_alive(),
+            'transport': 'fake',
+        }

aprsd/client/drivers/lib/aprslib.py

@@ -0,0 +1,296 @@
+import datetime
+import logging
+import select
+import socket
+import threading
+
+import aprslib
+import wrapt
+from aprslib import is_py3
+from aprslib.exceptions import (
+    ConnectionDrop,
+    ConnectionError,
+    GenericError,
+    LoginError,
+    ParseError,
+    UnknownFormat,
+)
+
+import aprsd
+from aprsd.packets import core
+
+LOG = logging.getLogger('APRSD')
+
+
+class APRSLibClient(aprslib.IS):
+    """Extend the aprslib class so we can exit properly.
+
+    This is a modified version of the aprslib.IS class that adds a stop method to
+    allow the client to exit cleanly.
+
+    The aprsis driver uses this class to connect to the APRS-IS server.
+    """
+
+    # flag to tell us to stop
+    thread_stop = False
+
+    # 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()
+
+    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]
+        )
+
+        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
+
+        while not self.thread_stop:
+            short_buf = b''
+            newline = b'\r\n'
+
+            # 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
+
+            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')
+
+            if self.passwd == '-1':
+                self.logger.info('Login successful (receive only)')
+            else:
+                self.logger.info('Login successful')
+
+            self.logger.info(f'Connected to {server_string}')
+            self.server_string = server_string
+
+        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 consumer(self, callback, blocking=True, immortal=False, raw=False):
+        """
+        When a position sentence is received, it will be passed to the callback function
+
+        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
+
+        immortal: When true, consumer will try to reconnect and stop propagation of Parse exceptions
+                  if false (default), consumer will return
+
+        raw: when true, raw packet is passed to callback, otherwise the result from aprs.parse()
+        """
+
+        if not self._connected:
+            raise ConnectionError('not connected to a server')
+
+        line = b''
+
+        while not self.thread_stop:
+            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,
+                )
+            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 IOError:
+                if not self.thread_stop:
+                    self.logger.error('IOError')
+                break
+            except Exception:
+                self.logger.error('APRS Packet: %s', line)
+                raise
+
+            if not blocking:
+                break

aprsd/client/drivers/registry.py

@@ -0,0 +1,86 @@
+from typing import Callable, Protocol, runtime_checkable
+
+from aprsd.packets import core
+from aprsd.utils import singleton, trace
+
+
+@runtime_checkable
+class ClientDriver(Protocol):
+    """Protocol for APRSD client drivers.
+
+    This protocol defines the methods that must be
+    implemented by APRSD client drivers.
+    """
+
+    @staticmethod
+    def is_enabled(self) -> bool:
+        pass
+
+    @staticmethod
+    def is_configured(self) -> bool:
+        pass
+
+    def is_alive(self) -> bool:
+        pass
+
+    def close(self) -> None:
+        pass
+
+    def send(self, packet: core.Packet) -> bool:
+        pass
+
+    def setup_connection(self) -> None:
+        pass
+
+    def set_filter(self, filter: str) -> None:
+        pass
+
+    def login_success(self) -> bool:
+        pass
+
+    def login_failure(self) -> str:
+        pass
+
+    def consumer(self, callback: Callable, raw: bool = False) -> None:
+        pass
+
+    def decode_packet(self, *args, **kwargs) -> core.Packet:
+        pass
+
+    def stats(self, serializable: bool = False) -> dict:
+        pass
+
+
+@singleton
+class DriverRegistry(metaclass=trace.TraceWrapperMetaclass):
+    """Registry for APRSD client drivers.
+
+    This registry is used to register and unregister APRSD client drivers.
+
+    This allows us to dynamically load the configured driver at runtime.
+
+    All drivers are registered, then when aprsd needs the client, the
+    registry provides the configured driver for the single instance of the
+    single APRSD client.
+    """
+
+    def __init__(self):
+        self.drivers = []
+
+    def register(self, driver: Callable):
+        if not isinstance(driver, ClientDriver):
+            raise ValueError('Driver must be of ClientDriver type')
+        self.drivers.append(driver)
+
+    def unregister(self, driver: Callable):
+        if driver in self.drivers:
+            self.drivers.remove(driver)
+        else:
+            raise ValueError(f'Driver {driver} not found')
+
+    def get_driver(self) -> ClientDriver:
+        """Get the first enabled driver."""
+        for driver in self.drivers:
+            if driver.is_enabled() and driver.is_configured():
+                return driver()
+        raise ValueError('No enabled driver found')