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

aprsd/client/drivers/tcpkiss.py

@@ -0,0 +1,423 @@
+"""
+APRSD KISS Client Driver using native KISS implementation.
+
+This module provides a KISS client driver for APRSD using the new
+non-asyncio KISSInterface implementation.
+"""
+
+import datetime
+import logging
+import select
+import socket
+import time
+from typing import Any, Callable, Dict
+
+import aprslib
+from ax253 import frame as ax25frame
+from kiss import constants as kiss_constants
+from kiss import util as kissutil
+from kiss.kiss import Command
+from oslo_config import cfg
+
+from aprsd import (  # noqa
+    client,
+    conf,  # noqa
+    exception,
+)
+from aprsd.packets import core
+
+CONF = cfg.CONF
+LOG = logging.getLogger('APRSD')
+
+
+def handle_fend(buffer: bytes, strip_df_start: bool = True) -> bytes:
+    """
+    Handle FEND (end of frame) encountered in a KISS data stream.
+
+    :param buffer: the buffer containing the frame
+    :param strip_df_start: remove leading null byte (DATA_FRAME opcode)
+    :return: the bytes of the frame without escape characters or frame
+             end markers (FEND)
+    """
+    frame = kissutil.recover_special_codes(kissutil.strip_nmea(bytes(buffer)))
+    if strip_df_start:
+        frame = kissutil.strip_df_start(frame)
+    LOG.warning(f'handle_fend {" ".join(f"{b:02X}" for b in bytes(frame))}')
+    return bytes(frame)
+
+
+# class TCPKISSDriver(metaclass=trace.TraceWrapperMetaclass):
+class TCPKISSDriver:
+    """APRSD client driver for TCP KISS connections."""
+
+    # Class level attributes required by Client protocol
+    packets_received = 0
+    packets_sent = 0
+    last_packet_sent = None
+    last_packet_received = None
+    keepalive = None
+    client_name = None
+    socket = None
+    # timeout in seconds
+    select_timeout = 1
+    path = None
+
+    def __init__(self):
+        """Initialize the KISS client.
+
+        Args:
+            client_name: Name of the client instance
+        """
+        super().__init__()
+        self._connected = False
+        self.keepalive = datetime.datetime.now()
+        self._running = False
+        # This is initialized in setup_connection()
+        self.socket = None
+
+    @property
+    def transport(self) -> str:
+        return client.TRANSPORT_TCPKISS
+
+    @staticmethod
+    def is_enabled() -> bool:
+        """Check if KISS is enabled in configuration.
+
+        Returns:
+            bool: True if either TCP is enabled
+        """
+        return CONF.kiss_tcp.enabled
+
+    @staticmethod
+    def is_configured():
+        # Ensure that the config vars are correctly set
+        if TCPKISSDriver.is_enabled():
+            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
+
+    @property
+    def is_alive(self) -> bool:
+        """Check if the client is connected.
+
+        Returns:
+            bool: True if connected to KISS TNC, False otherwise
+        """
+        return self._connected
+
+    def close(self):
+        """Close the connection."""
+        self.stop()
+
+    def send(self, packet: core.Packet):
+        """Send an APRS packet.
+
+        Args:
+            packet: APRS packet to send (Packet or Message object)
+
+        Raises:
+            Exception: If not connected or send fails
+        """
+        if not self.socket:
+            raise Exception('KISS interface not initialized')
+
+        payload = None
+        path = self.path
+        packet.prepare()
+        payload = packet.payload.encode('US-ASCII')
+        if packet.path:
+            path = packet.path
+
+        LOG.debug(
+            f"KISS Send '{payload}' TO '{packet.to_call}' From "
+            f"'{packet.from_call}' with PATH '{path}'",
+        )
+        frame = ax25frame.Frame.ui(
+            destination='APZ100',
+            # destination=packet.to_call,
+            source=packet.from_call,
+            path=path,
+            info=payload,
+        )
+
+        # now escape the frame special characters
+        frame_escaped = kissutil.escape_special_codes(bytes(frame))
+        # and finally wrap the frame in KISS protocol
+        command = Command.DATA_FRAME
+        frame_kiss = b''.join(
+            [kiss_constants.FEND, command.value, frame_escaped, kiss_constants.FEND]
+        )
+        self.socket.send(frame_kiss)
+        # Update last packet sent time
+        self.last_packet_sent = datetime.datetime.now()
+        # Increment packets sent counter
+        self.packets_sent += 1
+
+    def setup_connection(self):
+        """Set up the KISS interface."""
+        if not self.is_enabled():
+            LOG.error('KISS is not enabled in configuration')
+            return
+
+        try:
+            # Configure for TCP KISS
+            if self.is_enabled():
+                LOG.info(
+                    f'KISS TCP Connection to {CONF.kiss_tcp.host}:{CONF.kiss_tcp.port}'
+                )
+                self.path = CONF.kiss_tcp.path
+                self.connect()
+            if self._connected:
+                LOG.info('KISS interface initialized')
+            else:
+                LOG.error('Failed to connect to KISS interface')
+
+        except Exception as ex:
+            LOG.error('Failed to initialize KISS interface')
+            LOG.exception(ex)
+            self._connected = False
+
+    def set_filter(self, filter_text: str):
+        """Set packet filter (not implemented for KISS).
+
+        Args:
+            filter_text: Filter specification (ignored for KISS)
+        """
+        # KISS doesn't support filtering at the TNC level
+        pass
+
+    @property
+    def filter(self) -> str:
+        """Get packet filter (not implemented for KISS).
+        Returns:
+            str: Empty string (not implemented for KISS)
+        """
+        return ''
+
+    def login_success(self) -> bool:
+        """There is no login for KISS."""
+        if not self._connected:
+            return False
+        return True
+
+    def login_failure(self) -> str:
+        """There is no login for KISS."""
+        return 'Login successful'
+
+    def consumer(self, callback: Callable, raw: bool = False):
+        """Start consuming frames with the given callback.
+
+        Args:
+            callback: Function to call with received packets
+
+        Raises:
+            Exception: If not connected to KISS TNC
+        """
+        self._running = True
+        while self._running:
+            # Ensure connection
+            if not self._connected:
+                if not self.connect():
+                    time.sleep(1)
+                    continue
+
+            # Read frame
+            frame = self.read_frame()
+            if frame:
+                LOG.warning(f'GOT FRAME: {frame} calling {callback}')
+                kwargs = {
+                    'frame': frame,
+                }
+                callback(**kwargs)
+
+    def decode_packet(self, *args, **kwargs) -> core.Packet:
+        """Decode a packet from an AX.25 frame.
+
+        Args:
+            frame: Received AX.25 frame
+        """
+        frame = kwargs.get('frame')
+        if not frame:
+            LOG.warning('No frame received to decode?!?!')
+            return None
+
+        LOG.warning(f'FRAME: {str(frame)}')
+        try:
+            aprslib_frame = aprslib.parse(str(frame))
+            packet = core.factory(aprslib_frame)
+            if isinstance(packet, core.ThirdPartyPacket):
+                return packet.subpacket
+            else:
+                return packet
+        except Exception as e:
+            LOG.error(f'Error decoding packet: {e}')
+            return None
+
+    def stop(self):
+        """Stop the KISS interface."""
+        self._running = False
+        self._connected = False
+        if self.socket:
+            try:
+                self.socket.close()
+            except Exception:
+                pass
+
+    def stats(self, serializable: bool = False) -> Dict[str, Any]:
+        """Get client statistics.
+
+        Returns:
+            Dict containing client statistics
+        """
+        if serializable:
+            keepalive = self.keepalive.isoformat()
+            if self.last_packet_sent:
+                last_packet_sent = self.last_packet_sent.isoformat()
+            else:
+                last_packet_sent = 'None'
+            if self.last_packet_received:
+                last_packet_received = self.last_packet_received.isoformat()
+            else:
+                last_packet_received = 'None'
+        else:
+            keepalive = self.keepalive
+            last_packet_sent = self.last_packet_sent
+            last_packet_received = self.last_packet_received
+
+        stats = {
+            'client': self.__class__.__name__,
+            'transport': self.transport,
+            'connected': self._connected,
+            'path': self.path,
+            'packets_sent': self.packets_sent,
+            'packets_received': self.packets_received,
+            'last_packet_sent': last_packet_sent,
+            'last_packet_received': last_packet_received,
+            'connection_keepalive': keepalive,
+            'host': CONF.kiss_tcp.host,
+            'port': CONF.kiss_tcp.port,
+        }
+
+        return stats
+
+    def connect(self) -> bool:
+        """Establish TCP connection to the KISS host.
+
+        Returns:
+            bool: True if connection successful, False otherwise
+        """
+        try:
+            if self.socket:
+                try:
+                    self.socket.close()
+                except Exception:
+                    pass
+
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.settimeout(5.0)  # 5 second timeout for connection
+            self.socket.connect((CONF.kiss_tcp.host, CONF.kiss_tcp.port))
+            self.socket.settimeout(0.1)  # Reset to shorter timeout for reads
+            self._connected = True
+            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+            # MACOS doesn't have TCP_KEEPIDLE
+            if hasattr(socket, 'TCP_KEEPIDLE'):
+                self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 1)
+            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 3)
+            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
+            return True
+
+        except ConnectionError as e:
+            LOG.error(
+                f'Failed to connect to {CONF.kiss_tcp.host}:{CONF.kiss_tcp.port} - {str(e)}'
+            )
+            self._connected = False
+            return False
+
+        except Exception as e:
+            LOG.error(
+                f'Failed to connect to {CONF.kiss_tcp.host}:{CONF.kiss_tcp.port} - {str(e)}'
+            )
+            self._connected = False
+            return False
+
+    def fix_raw_frame(self, raw_frame: bytes) -> bytes:
+        """Fix the raw frame by recalculating the FCS."""
+        ax25_data = raw_frame[2:-1]  # Remove KISS markers
+        return handle_fend(ax25_data)
+
+    def read_frame(self, blocking=False):
+        """
+        Generator for complete lines, received from the server
+        """
+        try:
+            self.socket.setblocking(0)
+        except OSError as e:
+            LOG.error(f'socket error when setblocking(0): {str(e)}')
+            raise aprslib.ConnectionDrop('connection dropped') from e
+
+        while self._running:
+            short_buf = b''
+
+            try:
+                readable, _, _ = select.select(
+                    [self.socket],
+                    [],
+                    [],
+                    self.select_timeout,
+                )
+                if not readable:
+                    if not blocking:
+                        break
+                    else:
+                        continue
+            except Exception as e:
+                LOG.error(f'Error in read loop: {e}')
+                self._connected = False
+                break
+
+            try:
+                print('reading from socket')
+                short_buf = self.socket.recv(1024)
+                print(f'short_buf: {short_buf}')
+                # 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')
+
+                raw_frame = self.fix_raw_frame(short_buf)
+                return ax25frame.Frame.from_bytes(raw_frame)
+            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(short_buf) == 0:
+                            break
+            except socket.timeout:
+                continue
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except ConnectionError:
+                self.close()
+                if not self.auto_reconnect:
+                    raise
+                else:
+                    self.connect()
+                    continue
+            except StopIteration:
+                break
+            except IOError:
+                LOG.error('IOError')
+                break
+            except Exception as e:
+                LOG.error(f'Error in read loop: {e}')
+                self._connected = False
+                if not self.auto_reconnect:
+                    break

aprsd/client/stats.py

@@ -3,7 +3,7 @@ import threading
 import wrapt
 from oslo_config import cfg
 
-from aprsd import client
+from aprsd.client.client import APRSDClient
 from aprsd.utils import singleton
 
 CONF = cfg.CONF
@@ -15,4 +15,4 @@ class APRSClientStats:
 
     @wrapt.synchronized(lock)
     def stats(self, serializable=False):
-        return client.client_factory.create().stats(serializable=serializable)
+        return APRSDClient().stats(serializable=serializable)

aprsd/cmds/dev.py

@@ -4,14 +4,15 @@
 #
 # python included libs
 import logging
+import sys
 
 import click
 from oslo_config import cfg
 
-from aprsd import cli_helper, conf, packets, plugin
+import aprsd
+from aprsd import cli_helper, conf, packets, plugin, utils
 
 # local imports here
-from aprsd.client import base
 from aprsd.main import cli
 from aprsd.utils import trace
 
@@ -72,6 +73,9 @@ def test_plugin(
 ):
     """Test an individual APRSD plugin given a python path."""
 
+    LOG.info(f'Python version: {sys.version}')
+    LOG.info(f'APRSD DEV Started version: {aprsd.__version__}')
+    utils.package.log_installed_extensions_and_plugins()
     CONF.log_opt_values(LOG, logging.DEBUG)
 
     if not aprs_login:
@@ -97,8 +101,6 @@ def test_plugin(
     if CONF.trace_enabled:
         trace.setup_tracing(['method', 'api'])
 
-    base.APRSClient()
-
     pm = plugin.PluginManager()
     if load_all:
         pm.setup_plugins(load_help_plugin=CONF.load_help_plugin)

aprsd/cmds/fetch_stats.py

@@ -1,5 +1,6 @@
 # Fetch active stats from a remote running instance of aprsd admin web interface.
 import logging
+import sys
 
 import click
 import requests
@@ -38,6 +39,7 @@ CONF = cfg.CONF
 def fetch_stats(ctx, host, port):
     """Fetch stats from a APRSD admin web interface."""
     console = Console()
+    console.print(f'Python version: {sys.version}')
     console.print(f'APRSD Fetch-Stats started version: {aprsd.__version__}')
 
     CONF.log_opt_values(LOG, logging.DEBUG)

aprsd/cmds/list_plugins.py

@@ -1,119 +1,18 @@
-import fnmatch
-import importlib
 import inspect
 import logging
-import os
-import pkgutil
-import sys
-from traceback import print_tb
 
 import click
-import requests
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
-from thesmuggler import smuggle
 
 from aprsd import cli_helper
 from aprsd import plugin as aprsd_plugin
 from aprsd.main import cli
 from aprsd.plugins import fortune, notify, ping, time, version, weather
+from aprsd.utils import package as aprsd_package
 
 LOG = logging.getLogger('APRSD')
-PYPI_URL = 'https://pypi.org/search/'
-
-
-def onerror(name):
-    print(f'Error importing module {name}')
-    type, value, traceback = sys.exc_info()
-    print_tb(traceback)
-
-
-def is_plugin(obj):
-    for c in inspect.getmro(obj):
-        if issubclass(c, aprsd_plugin.APRSDPluginBase):
-            return True
-
-    return False
-
-
-def plugin_type(obj):
-    for c in inspect.getmro(obj):
-        if issubclass(c, aprsd_plugin.APRSDRegexCommandPluginBase):
-            return 'RegexCommand'
-        if issubclass(c, aprsd_plugin.APRSDWatchListPluginBase):
-            return 'WatchList'
-        if issubclass(c, aprsd_plugin.APRSDPluginBase):
-            return 'APRSDPluginBase'
-
-    return 'Unknown'
-
-
-def walk_package(package):
-    return pkgutil.walk_packages(
-        package.__path__,
-        package.__name__ + '.',
-        onerror=onerror,
-    )
-
-
-def get_module_info(package_name, module_name, module_path):
-    if not os.path.exists(module_path):
-        return None
-
-    dir_path = os.path.realpath(module_path)
-    pattern = '*.py'
-
-    obj_list = []
-
-    for path, _subdirs, files in os.walk(dir_path):
-        for name in files:
-            if fnmatch.fnmatch(name, pattern):
-                module = smuggle(f'{path}/{name}')
-                for mem_name, obj in inspect.getmembers(module):
-                    if inspect.isclass(obj) and is_plugin(obj):
-                        obj_list.append(
-                            {
-                                'package': package_name,
-                                'name': mem_name,
-                                'obj': obj,
-                                'version': obj.version,
-                                'path': f'{".".join([module_name, obj.__name__])}',
-                            },
-                        )
-
-    return obj_list
-
-
-def _get_installed_aprsd_items():
-    # installed plugins
-    plugins = {}
-    extensions = {}
-    for _finder, name, ispkg in pkgutil.iter_modules():
-        if ispkg and name.startswith('aprsd_'):
-            module = importlib.import_module(name)
-            pkgs = walk_package(module)
-            for pkg in pkgs:
-                pkg_info = get_module_info(
-                    module.__name__, pkg.name, module.__path__[0]
-                )
-                if 'plugin' in name:
-                    plugins[name] = pkg_info
-                elif 'extension' in name:
-                    extensions[name] = pkg_info
-    return plugins, extensions
-
-
-def get_installed_plugins():
-    # installed plugins
-    plugins, extensions = _get_installed_aprsd_items()
-    return plugins
-
-
-def get_installed_extensions():
-    # installed plugins
-    plugins, extensions = _get_installed_aprsd_items()
-    return extensions
 
 
 def show_built_in_plugins(console):
@@ -157,34 +56,8 @@ def show_built_in_plugins(console):
     console.print(table)
 
 
-def _get_pypi_packages():
-    if simple_r := requests.get(
-        'https://pypi.org/simple',
-        headers={'Accept': 'application/vnd.pypi.simple.v1+json'},
-    ):
-        simple_response = simple_r.json()
-    else:
-        simple_response = {}
-
-    key = 'aprsd'
-    matches = [
-        p['name'] for p in simple_response['projects'] if p['name'].startswith(key)
-    ]
-
-    packages = []
-    for pkg in matches:
-        # Get info for first match
-        if r := requests.get(
-            f'https://pypi.org/pypi/{pkg}/json',
-            headers={'Accept': 'application/json'},
-        ):
-            packages.append(r.json())
-
-    return packages
-
-
 def show_pypi_plugins(installed_plugins, console):
-    packages = _get_pypi_packages()
+    packages = aprsd_package.get_pypi_packages()
 
     title = Text.assemble(
         ('Pypi.org APRSD Installable Plugin Packages\n\n', 'bold magenta'),
@@ -225,7 +98,7 @@ def show_pypi_plugins(installed_plugins, console):
 
 
 def show_pypi_extensions(installed_extensions, console):
-    packages = _get_pypi_packages()
+    packages = aprsd_package.get_pypi_packages()
 
     title = Text.assemble(
         ('Pypi.org APRSD Installable Extension Packages\n\n', 'bold magenta'),
@@ -282,7 +155,7 @@ def show_installed_plugins(installed_plugins, console):
                 name.replace('_', '-'),
                 plugin['name'],
                 plugin['version'],
-                plugin_type(plugin['obj']),
+                aprsd_package.plugin_type(plugin['obj']),
                 plugin['path'],
             )
 
@@ -302,7 +175,7 @@ def list_plugins(ctx):
         show_built_in_plugins(console)
 
         status.update('Fetching pypi.org plugins')
-        installed_plugins = get_installed_plugins()
+        installed_plugins = aprsd_package.get_installed_plugins()
         show_pypi_plugins(installed_plugins, console)
 
         status.update('Looking for installed APRSD plugins')
@@ -321,5 +194,5 @@ def list_extensions(ctx):
         status.update('Fetching pypi.org APRSD Extensions')
 
         status.update('Looking for installed APRSD Extensions')
-        installed_extensions = get_installed_extensions()
+        installed_extensions = aprsd_package.get_installed_extensions()
         show_pypi_extensions(installed_extensions, console)