aprsd 4.0.2__py3-none-any.whl → 4.1.0__py3-none-any.whl

aprsd/client/drivers/aprsis.py

@@ -1,6 +1,7 @@
 import datetime
 import logging
 import select
+import socket
 import threading
 
 import aprslib
@@ -18,7 +19,7 @@ from aprslib.exceptions import (
 import aprsd
 from aprsd.packets import core
 
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class Aprsdis(aprslib.IS):
@@ -31,7 +32,7 @@ class Aprsdis(aprslib.IS):
     aprsd_keepalive = datetime.datetime.now()
 
     # Which server we are connected to?
-    server_string = "None"
+    server_string = 'None'
 
     # timeout in seconds
     select_timeout = 1
@@ -39,10 +40,10 @@ class Aprsdis(aprslib.IS):
 
     def stop(self):
         self.thread_stop = True
-        LOG.warning("Shutdown Aprsdis client.")
+        LOG.warning('Shutdown Aprsdis client.')
 
     def close(self):
-        LOG.warning("Closing Aprsdis client.")
+        LOG.warning('Closing Aprsdis client.')
         super().close()
 
     @wrapt.synchronized(lock)
@@ -54,6 +55,57 @@ class Aprsdis(aprslib.IS):
         """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
@@ -61,12 +113,12 @@ class Aprsdis(aprslib.IS):
         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")
+            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"
+            short_buf = b''
+            newline = b'\r\n'
 
             # set a select timeout, so we get a chance to exit
             # when user hits CTRL-C
@@ -91,11 +143,11 @@ class Aprsdis(aprslib.IS):
                         # We could just not be blocking, so empty is expected
                         continue
                     else:
-                        self.logger.error("socket.recv(): returned empty")
-                        raise aprslib.ConnectionDrop("connection dropped")
+                        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 'Resource temporarily unavailable' in str(e):
                     if not blocking:
                         if len(self.buf) == 0:
                             break
@@ -111,22 +163,22 @@ class Aprsdis(aprslib.IS):
         """
         Sends login string to server
         """
-        login_str = "user {0} pass {1} vers github.com/craigerl/aprsd {3}{2}\r\n"
+        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 "",
+            (' filter ' + self.filter) if self.filter != '' else '',
             aprsd.__version__,
         )
 
-        self.logger.debug("Sending login information")
+        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.decode('latin-1')
             test = test.rstrip()
 
             self.logger.debug("Server: '%s'", test)
@@ -134,26 +186,26 @@ class Aprsdis(aprslib.IS):
             if not test:
                 raise LoginError(f"Server Response Empty: '{test}'")
 
-            _, _, callsign, status, e = test.split(" ", 4)
-            s = e.split(",")
+            _, _, callsign, status, e = test.split(' ', 4)
+            s = e.split(',')
             if len(s):
-                server_string = s[0].replace("server ", "")
+                server_string = s[0].replace('server ', '')
             else:
-                server_string = e.replace("server ", "")
+                server_string = e.replace('server ', '')
 
-            if callsign == "":
-                raise LoginError("Server responded with empty callsign???")
+            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")
+                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)")
+            if self.passwd == '-1':
+                self.logger.info('Login successful (receive only)')
             else:
-                self.logger.info("Login successful")
+                self.logger.info('Login successful')
 
-            self.logger.info(f"Connected to {server_string}")
+            self.logger.info(f'Connected to {server_string}')
             self.server_string = server_string
 
         except LoginError as e:
@@ -164,7 +216,7 @@ class Aprsdis(aprslib.IS):
             self.close()
             self.logger.error(f"Failed to login '{e}'")
             self.logger.exception(e)
-            raise LoginError("Failed to login")
+            raise LoginError('Failed to login') from e
 
     def consumer(self, callback, blocking=True, immortal=False, raw=False):
         """
@@ -180,21 +232,21 @@ class Aprsdis(aprslib.IS):
         """
 
         if not self._connected:
-            raise ConnectionError("not connected to a server")
+            raise ConnectionError('not connected to a server')
 
-        line = b""
+        line = b''
 
         while True and not self.thread_stop:
             try:
                 for line in self._socket_readlines(blocking):
-                    if line[0:1] != b"#":
+                    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.logger.debug('Server: %s', line.decode('utf8'))
                         self.aprsd_keepalive = datetime.datetime.now()
             except ParseError as exp:
                 self.logger.log(
@@ -211,7 +263,7 @@ class Aprsdis(aprslib.IS):
                     exp.packet,
                 )
             except LoginError as exp:
-                self.logger.error("%s: %s", exp.__class__.__name__, exp)
+                self.logger.error('%s: %s', exp.__class__.__name__, exp)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except (ConnectionDrop, ConnectionError):
@@ -227,7 +279,7 @@ class Aprsdis(aprslib.IS):
             except StopIteration:
                 break
             except Exception:
-                self.logger.error("APRS Packet: %s", line)
+                self.logger.error('APRS Packet: %s', line)
                 raise
 
             if not blocking:

aprsd/client/drivers/kiss.py

@@ -18,12 +18,13 @@ class KISS3Client:
 
     # 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 True
+        return self._connected
 
     def setup(self):
         # we can be TCP kiss or Serial kiss
@@ -56,17 +57,33 @@ class KISS3Client:
             self.path = CONF.kiss_tcp.path
 
         LOG.debug('Starting KISS interface connection')
-        self.kiss.start()
+        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 as ex:
-            LOG.exception(ex)
+        except Exception:
+            LOG.error('Failed to stop KISS interface.')
+
+    def close(self):
+        self.stop()
 
     def set_filter(self, filter):
         # This does nothing right now.
@@ -86,8 +103,14 @@ class KISS3Client:
             LOG.exception(ex)
 
     def consumer(self, callback):
+        if not self._connected:
+            raise Exception('KISS transport is not connected')
+
         self._parse_callback = callback
-        self.kiss.read(callback=self.parse_frame, min_frames=None)
+        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."""

aprsd/client/kiss.py

@@ -140,3 +140,4 @@ class KISSClient(base.APRSClient):
         except Exception as ex:
             LOG.error(f'Consumer failed {ex}')
             LOG.error(ex)
+            raise ex

aprsd/cmds/listen.py

@@ -20,8 +20,10 @@ from aprsd import cli_helper, packets, plugin, threads, utils
 from aprsd.client import client_factory
 from aprsd.main import cli
 from aprsd.packets import collector as packet_collector
+from aprsd.packets import core, seen_list
 from aprsd.packets import log as packet_log
-from aprsd.packets import seen_list
+from aprsd.packets.filter import PacketFilter
+from aprsd.packets.filters import dupe_filter, packet_type
 from aprsd.stats import collector
 from aprsd.threads import keepalive, rx
 from aprsd.threads import stats as stats_thread
@@ -29,7 +31,7 @@ from aprsd.threads.aprsd import APRSDThread
 
 # setup the global logger
 # log.basicConfig(level=log.DEBUG) # level=10
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 CONF = cfg.CONF
 LOGU = logger
 console = Console()
@@ -37,9 +39,9 @@ console = Console()
 
 def signal_handler(sig, frame):
     threads.APRSDThreadList().stop_all()
-    if "subprocess" not in str(frame):
+    if 'subprocess' not in str(frame):
         LOG.info(
-            "Ctrl+C, Sending all threads exit! Can take up to 10 seconds {}".format(
+            'Ctrl+C, Sending all threads exit! Can take up to 10 seconds {}'.format(
                 datetime.datetime.now(),
             ),
         )
@@ -48,90 +50,66 @@ def signal_handler(sig, frame):
         collector.Collector().collect()
 
 
-class APRSDListenThread(rx.APRSDRXThread):
+class APRSDListenProcessThread(rx.APRSDFilterThread):
     def __init__(
         self,
         packet_queue,
         packet_filter=None,
         plugin_manager=None,
-        enabled_plugins=[],
+        enabled_plugins=None,
         log_packets=False,
     ):
-        super().__init__(packet_queue)
+        super().__init__('ListenProcThread', packet_queue)
         self.packet_filter = packet_filter
         self.plugin_manager = plugin_manager
         if self.plugin_manager:
-            LOG.info(f"Plugins {self.plugin_manager.get_message_plugins()}")
+            LOG.info(f'Plugins {self.plugin_manager.get_message_plugins()}')
         self.log_packets = log_packets
 
-    def process_packet(self, *args, **kwargs):
-        packet = self._client.decode_packet(*args, **kwargs)
-        filters = {
-            packets.Packet.__name__: packets.Packet,
-            packets.AckPacket.__name__: packets.AckPacket,
-            packets.BeaconPacket.__name__: packets.BeaconPacket,
-            packets.GPSPacket.__name__: packets.GPSPacket,
-            packets.MessagePacket.__name__: packets.MessagePacket,
-            packets.MicEPacket.__name__: packets.MicEPacket,
-            packets.ObjectPacket.__name__: packets.ObjectPacket,
-            packets.StatusPacket.__name__: packets.StatusPacket,
-            packets.ThirdPartyPacket.__name__: packets.ThirdPartyPacket,
-            packets.WeatherPacket.__name__: packets.WeatherPacket,
-            packets.UnknownPacket.__name__: packets.UnknownPacket,
-        }
-
-        if self.packet_filter:
-            filter_class = filters[self.packet_filter]
-            if isinstance(packet, filter_class):
-                if self.log_packets:
-                    packet_log.log(packet)
-                if self.plugin_manager:
-                    # Don't do anything with the reply
-                    # This is the listen only command.
-                    self.plugin_manager.run(packet)
-        else:
-            if self.log_packets:
-                packet_log.log(packet)
-            if self.plugin_manager:
-                # Don't do anything with the reply.
-                # This is the listen only command.
-                self.plugin_manager.run(packet)
-
-        packet_collector.PacketCollector().rx(packet)
+    def print_packet(self, packet):
+        if self.log_packets:
+            packet_log.log(packet)
+
+    def process_packet(self, packet: type[core.Packet]):
+        if self.plugin_manager:
+            # Don't do anything with the reply.
+            # This is the listen only command.
+            self.plugin_manager.run(packet)
 
 
 class ListenStatsThread(APRSDThread):
     """Log the stats from the PacketList."""
 
     def __init__(self):
-        super().__init__("PacketStatsLog")
+        super().__init__('PacketStatsLog')
         self._last_total_rx = 0
+        self.period = 31
 
     def loop(self):
-        if self.loop_count % 10 == 0:
+        if self.loop_count % self.period == 0:
             # log the stats every 10 seconds
             stats_json = collector.Collector().collect()
-            stats = stats_json["PacketList"]
-            total_rx = stats["rx"]
-            packet_count = len(stats["packets"])
+            stats = stats_json['PacketList']
+            total_rx = stats['rx']
+            packet_count = len(stats['packets'])
             rx_delta = total_rx - self._last_total_rx
-            rate = rx_delta / 10
+            rate = rx_delta / self.period
 
             # Log summary stats
             LOGU.opt(colors=True).info(
-                f"<green>RX Rate: {rate} pps</green>  "
-                f"<yellow>Total RX: {total_rx}</yellow> "
-                f"<red>RX Last 10 secs: {rx_delta}</red> "
-                f"<white>Packets in PacketList: {packet_count}</white>",
+                f'<green>RX Rate: {rate:.2f} pps</green>  '
+                f'<yellow>Total RX: {total_rx}</yellow> '
+                f'<red>RX Last {self.period} secs: {rx_delta}</red> '
+                f'<white>Packets in PacketListStats: {packet_count}</white>',
             )
             self._last_total_rx = total_rx
 
             # Log individual type stats
-            for k, v in stats["types"].items():
-                thread_hex = f"fg {utils.hex_from_name(k)}"
+            for k, v in stats['types'].items():
+                thread_hex = f'fg {utils.hex_from_name(k)}'
                 LOGU.opt(colors=True).info(
-                    f"<{thread_hex}>{k:<15}</{thread_hex}> "
-                    f"<blue>RX: {v['rx']}</blue> <red>TX: {v['tx']}</red>",
+                    f'<{thread_hex}>{k:<15}</{thread_hex}> '
+                    f'<blue>RX: {v["rx"]}</blue> <red>TX: {v["tx"]}</red>',
                 )
 
         time.sleep(1)
@@ -141,19 +119,19 @@ class ListenStatsThread(APRSDThread):
 @cli.command()
 @cli_helper.add_options(cli_helper.common_options)
 @click.option(
-    "--aprs-login",
-    envvar="APRS_LOGIN",
+    '--aprs-login',
+    envvar='APRS_LOGIN',
     show_envvar=True,
-    help="What callsign to send the message from.",
+    help='What callsign to send the message from.',
 )
 @click.option(
-    "--aprs-password",
-    envvar="APRS_PASSWORD",
+    '--aprs-password',
+    envvar='APRS_PASSWORD',
     show_envvar=True,
-    help="the APRS-IS password for APRS_LOGIN",
+    help='the APRS-IS password for APRS_LOGIN',
 )
 @click.option(
-    "--packet-filter",
+    '--packet-filter',
     type=click.Choice(
         [
             packets.AckPacket.__name__,
@@ -170,35 +148,37 @@ class ListenStatsThread(APRSDThread):
         ],
         case_sensitive=False,
     ),
-    help="Filter by packet type",
+    multiple=True,
+    default=[],
+    help='Filter by packet type',
 )
 @click.option(
-    "--enable-plugin",
+    '--enable-plugin',
     multiple=True,
-    help="Enable a plugin.  This is the name of the file in the plugins directory.",
+    help='Enable a plugin.  This is the name of the file in the plugins directory.',
 )
 @click.option(
-    "--load-plugins",
+    '--load-plugins',
     default=False,
     is_flag=True,
-    help="Load plugins as enabled in aprsd.conf ?",
+    help='Load plugins as enabled in aprsd.conf ?',
 )
 @click.argument(
-    "filter",
+    'filter',
     nargs=-1,
     required=True,
 )
 @click.option(
-    "--log-packets",
+    '--log-packets',
     default=False,
     is_flag=True,
-    help="Log incoming packets.",
+    help='Log incoming packets.',
 )
 @click.option(
-    "--enable-packet-stats",
+    '--enable-packet-stats',
     default=False,
     is_flag=True,
-    help="Enable packet stats periodic logging.",
+    help='Enable packet stats periodic logging.',
 )
 @click.pass_context
 @cli_helper.process_standard_options
@@ -228,46 +208,46 @@ def listen(
 
     if not aprs_login:
         click.echo(ctx.get_help())
-        click.echo("")
-        ctx.fail("Must set --aprs-login or APRS_LOGIN")
+        click.echo('')
+        ctx.fail('Must set --aprs-login or APRS_LOGIN')
         ctx.exit()
 
     if not aprs_password:
         click.echo(ctx.get_help())
-        click.echo("")
-        ctx.fail("Must set --aprs-password or APRS_PASSWORD")
+        click.echo('')
+        ctx.fail('Must set --aprs-password or APRS_PASSWORD')
         ctx.exit()
 
     # CONF.aprs_network.login = aprs_login
     # config["aprs"]["password"] = aprs_password
 
-    LOG.info(f"APRSD Listen Started version: {aprsd.__version__}")
+    LOG.info(f'APRSD Listen Started version: {aprsd.__version__}')
 
     CONF.log_opt_values(LOG, logging.DEBUG)
     collector.Collector()
 
     # Try and load saved MsgTrack list
-    LOG.debug("Loading saved MsgTrack object.")
+    LOG.debug('Loading saved MsgTrack object.')
 
     # Initialize the client factory and create
     # The correct client object ready for use
     # Make sure we have 1 client transport enabled
     if not client_factory.is_client_enabled():
-        LOG.error("No Clients are enabled in config.")
+        LOG.error('No Clients are enabled in config.')
         sys.exit(-1)
 
     # Creates the client object
-    LOG.info("Creating client connection")
+    LOG.info('Creating client connection')
     aprs_client = client_factory.create()
     LOG.info(aprs_client)
     if not aprs_client.login_success:
         # We failed to login, will just quit!
-        msg = f"Login Failure: {aprs_client.login_failure}"
+        msg = f'Login Failure: {aprs_client.login_failure}'
         LOG.error(msg)
         print(msg)
         sys.exit(-1)
 
-    LOG.debug(f"Filter by '{filter}'")
+    LOG.debug(f"Filter messages on aprsis server by '{filter}'")
     aprs_client.set_filter(filter)
 
     keepalive_thread = keepalive.KeepAliveThread()
@@ -276,10 +256,19 @@ def listen(
         # just deregister the class from the packet collector
         packet_collector.PacketCollector().unregister(seen_list.SeenList)
 
+    # we don't want the dupe filter to run here.
+    PacketFilter().unregister(dupe_filter.DupePacketFilter)
+    if packet_filter:
+        LOG.info('Enabling packet filtering for {packet_filter}')
+        packet_type.PacketTypeFilter().set_allow_list(packet_filter)
+        PacketFilter().register(packet_type.PacketTypeFilter)
+    else:
+        LOG.info('No packet filtering enabled.')
+
     pm = None
     if load_plugins:
         pm = plugin.PluginManager()
-        LOG.info("Loading plugins")
+        LOG.info('Loading plugins')
         pm.setup_plugins(load_help_plugin=False)
     elif enable_plugin:
         pm = plugin.PluginManager()
@@ -290,33 +279,37 @@ def listen(
     else:
         LOG.warning(
             "Not Loading any plugins use --load-plugins to load what's "
-            "defined in the config file.",
+            'defined in the config file.',
         )
 
     if pm:
         for p in pm.get_plugins():
-            LOG.info("Loaded plugin %s", p.__class__.__name__)
+            LOG.info('Loaded plugin %s', p.__class__.__name__)
 
     stats = stats_thread.APRSDStatsStoreThread()
     stats.start()
 
-    LOG.debug("Create APRSDListenThread")
-    listen_thread = APRSDListenThread(
+    LOG.debug('Start APRSDRxThread')
+    rx_thread = rx.APRSDRXThread(packet_queue=threads.packet_queue)
+    rx_thread.start()
+
+    LOG.debug('Create APRSDListenProcessThread')
+    listen_thread = APRSDListenProcessThread(
         packet_queue=threads.packet_queue,
         packet_filter=packet_filter,
         plugin_manager=pm,
         enabled_plugins=enable_plugin,
         log_packets=log_packets,
     )
-    LOG.debug("Start APRSDListenThread")
+    LOG.debug('Start APRSDListenProcessThread')
     listen_thread.start()
     if enable_packet_stats:
         listen_stats = ListenStatsThread()
         listen_stats.start()
 
     keepalive_thread.start()
-    LOG.debug("keepalive Join")
+    LOG.debug('keepalive Join')
     keepalive_thread.join()
-    LOG.debug("listen_thread Join")
+    rx_thread.join()
     listen_thread.join()
     stats.join()

aprsd/cmds/server.py

@@ -147,7 +147,7 @@ def server(ctx, flush):
     server_threads.register(keepalive.KeepAliveThread())
     server_threads.register(stats_thread.APRSDStatsStoreThread())
     server_threads.register(
-        rx.APRSDPluginRXThread(
+        rx.APRSDRXThread(
             packet_queue=threads.packet_queue,
         ),
     )