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

aprsd/client/base.py

@@ -1,156 +0,0 @@
-import abc
-import logging
-import threading
-
-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')
-
-
-class APRSClient:
-    """Singleton client class that constructs the aprslib connection."""
-
-    _instance = None
-    _client = None
-
-    connected = False
-    login_status = {
-        'success': False,
-        'message': None,
-    }
-    filter = None
-    lock = threading.Lock()
-
-    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)
-            # Put any initialization here.
-            cls._instance._create_client()
-        return cls._instance
-
-    @abc.abstractmethod
-    def stats(self) -> dict:
-        """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
-        if self._client:
-            self._client.set_filter(filter)
-
-    def get_filter(self):
-        return self.filter
-
-    @property
-    def client(self):
-        if not self._client:
-            self._create_client()
-        return self._client
-
-    def _create_client(self):
-        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) -> None:
-        """Send a packet to the network.
-
-        Args:
-            packet: The APRS packet to send
-        """
-        self.client.send(packet)
-
-    @wrapt.synchronized(lock)
-    def reset(self) -> None:
-        """Call this to force a rebuild/reconnect."""
-        LOG.info('Resetting client connection.')
-        if self._client:
-            self._client.close()
-            del self._client
-            self._create_client()
-        else:
-            LOG.warning('Client not initialized, nothing to reset.')
-
-        # Recreate the client
-        LOG.info(f'Creating new client {self.client}')
-
-    @abc.abstractmethod
-    def setup_connection(self):
-        """Initialize and return the underlying APRS connection.
-
-        Returns:
-            object: The initialized connection object
-        """
-
-    @staticmethod
-    @abc.abstractmethod
-    def is_enabled():
-        pass
-
-    @staticmethod
-    @abc.abstractmethod
-    def transport():
-        pass
-
-    @abc.abstractmethod
-    def decode_packet(self, *args, **kwargs):
-        """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):
-        pass
-
-    @abc.abstractmethod
-    def is_alive(self):
-        pass
-
-    @abc.abstractmethod
-    def close(self):
-        pass

aprsd/client/drivers/kiss.py

@@ -1,144 +0,0 @@
-import datetime
-import logging
-
-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')
-
-
-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 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.__version__,
-                    CONF.kiss_serial.device,
-                ),
-            )
-            self.kiss = kiss.SerialKISS(
-                port=CONF.kiss_serial.device,
-                speed=CONF.kiss_serial.baudrate,
-                strip_df_start=True,
-            )
-            self.path = CONF.kiss_serial.path
-        elif CONF.kiss_tcp.enabled:
-            LOG.debug(
-                'KISS({}) TCP Connection to {}:{}'.format(
-                    kiss.__version__,
-                    CONF.kiss_tcp.host,
-                    CONF.kiss_tcp.port,
-                ),
-            )
-            self.kiss = kiss.TCPKISS(
-                host=CONF.kiss_tcp.host,
-                port=CONF.kiss_tcp.port,
-                strip_df_start=True,
-            )
-            self.path = CONF.kiss_tcp.path
-
-        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:
-            LOG.error('Failed to stop KISS interface.')
-
-    def close(self):
-        self.stop()
-
-    def set_filter(self, filter):
-        # This does nothing right now.
-        pass
-
-    def parse_frame(self, frame_bytes):
-        try:
-            frame = Frame.from_bytes(frame_bytes)
-            # Now parse it with aprslib
-            kwargs = {
-                '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.exception(ex)
-
-    def consumer(self, callback):
-        if not self._connected:
-            raise Exception('KISS transport is not connected')
-
-        self._parse_callback = callback
-        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."""
-
-        payload = None
-        path = self.path
-        if isinstance(packet, core.Packet):
-            packet.prepare()
-            payload = packet.payload.encode('US-ASCII')
-            if packet.path:
-                path = packet.path
-        else:
-            msg_payload = f'{packet.raw}{{{str(packet.msgNo)}'
-            payload = (
-                ':{:<9}:{}'.format(
-                    packet.to_call,
-                    msg_payload,
-                )
-            ).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',
-            source=packet.from_call,
-            path=path,
-            info=payload,
-        )
-        self.kiss.write(frame)

aprsd/client/factory.py

@@ -1,91 +0,0 @@
-import logging
-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
-
-    def connect(self) -> bool:
-        pass
-
-    def disconnect(self) -> bool:
-        pass
-
-    def decode_packet(self, *args, **kwargs) -> type[core.Packet]:
-        pass
-
-    def is_enabled(self) -> bool:
-        pass
-
-    def is_configured(self) -> bool:
-        pass
-
-    def transport(self) -> str:
-        pass
-
-    def send(self, message: str) -> bool:
-        pass
-
-    def setup_connection(self) -> None:
-        pass
-
-
-class ClientFactory:
-    _instance = None
-    clients = []
-    client = None
-
-    def __new__(cls, *args, **kwargs):
-        """This magic turns this into a singleton."""
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            # Put any initialization here.
-        return cls._instance
-
-    def __init__(self):
-        self.clients: list[Callable] = []
-
-    def register(self, aprsd_client: Callable):
-        if isinstance(aprsd_client, Client):
-            raise ValueError("Client must be a subclass of Client protocol")
-
-        self.clients.append(aprsd_client)
-
-    def create(self, key=None):
-        for client in self.clients:
-            if client.is_enabled():
-                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
-        for client in self.clients:
-            if client.is_enabled():
-                enabled = True
-        return enabled
-
-    def is_client_configured(self):
-        enabled = False
-        for client in self.clients:
-            try:
-                if client.is_configured():
-                    enabled = True
-            except exception.MissingConfigOptionException as ex:
-                LOG.error(ex.message)
-                return False
-            except exception.ConfigOptionBogusDefaultException as ex:
-                LOG.error(ex.message)
-                return False
-        return enabled

aprsd/client/fake.py

@@ -1,49 +0,0 @@
-import logging
-
-from oslo_config import cfg
-
-from aprsd import client
-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, serializable=False) -> dict:
-        return {
-            "transport": "Fake",
-            "connected": True,
-        }
-
-    @staticmethod
-    def is_enabled():
-        if CONF.fake_client.enabled:
-            return True
-        return False
-
-    @staticmethod
-    def is_configured():
-        return APRSDFakeClient.is_enabled()
-
-    def is_alive(self):
-        return True
-
-    def close(self):
-        pass
-
-    def setup_connection(self):
-        self.connected = True
-        return fake_driver.APRSDFakeClient()
-
-    @staticmethod
-    def transport():
-        return client.TRANSPORT_FAKE
-
-    def decode_packet(self, *args, **kwargs):
-        LOG.debug(f"kwargs {kwargs}")
-        pkt = kwargs["packet"]
-        LOG.debug(f"Got an APRS Fake Packet '{pkt}'")
-        return pkt

aprsd/client/kiss.py

@@ -1,143 +0,0 @@
-import datetime
-import logging
-
-import aprslib
-import timeago
-from loguru import logger
-from oslo_config import cfg
-
-from aprsd import client, exception
-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, serializable=False) -> dict:
-        stats = {}
-        if self.is_configured():
-            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
-    def is_enabled():
-        """Return if tcp or serial KISS is enabled."""
-        if CONF.kiss_serial.enabled:
-            return True
-
-        if CONF.kiss_tcp.enabled:
-            return True
-
-        return False
-
-    @staticmethod
-    def is_configured():
-        # Ensure that the config vars are correctly set
-        if KISSClient.is_enabled():
-            transport = KISSClient.transport()
-            if transport == client.TRANSPORT_SERIALKISS:
-                if not CONF.kiss_serial.device:
-                    LOG.error('KISS serial enabled, but no device is set.')
-                    raise exception.MissingConfigOptionException(
-                        '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.')
-                    raise exception.MissingConfigOptionException(
-                        'kiss_tcp.host is not set.',
-                    )
-
-            return True
-        return False
-
-    def is_alive(self):
-        if self._client:
-            return self._client.is_alive()
-        else:
-            return False
-
-    def close(self):
-        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:
-            return client.TRANSPORT_SERIALKISS
-
-        if CONF.kiss_tcp.enabled:
-            return client.TRANSPORT_TCPKISS
-
-    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"Got an APRS Frame '{frame}'")
-        # try and nuke the * from the fromcall sign.
-        # frame.header._source._ch = False
-        # payload = str(frame.payload.decode())
-        # msg = f"{str(frame.header)}:{payload}"
-        # msg = frame.tnc2
-        # LOG.debug(f"Decoding {msg}")
-
-        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
-        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):
-        try:
-            self._client.consumer(callback)
-            self.keepalive = datetime.datetime.now()
-        except Exception as ex:
-            LOG.error(f'Consumer failed {ex}')
-            LOG.error(ex)
-            raise ex