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

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/send_message.py

@@ -3,58 +3,60 @@ import sys
 import time
 
 import aprslib
-from aprslib.exceptions import LoginError
 import click
+from aprslib.exceptions import LoginError
 from oslo_config import cfg
 
 import aprsd
-from aprsd import cli_helper, packets
-from aprsd import conf  # noqa : F401
+import aprsd.packets  # noqa : F401
+from aprsd import (
+    cli_helper,
+    conf,  # noqa : F401
+    packets,
+)
 from aprsd.client import client_factory
 from aprsd.main import cli
-import aprsd.packets  # noqa : F401
 from aprsd.packets import collector
 from aprsd.packets import log as packet_log
 from aprsd.threads import tx
 
-
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 @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. Defaults to config entry.",
+    help='What callsign to send the message from. Defaults to config entry.',
 )
 @click.option(
-    "--aprs-password",
-    envvar="APRS_PASSWORD",
+    '--aprs-password',
+    envvar='APRS_PASSWORD',
     show_envvar=True,
-    help="the APRS-IS password for APRS_LOGIN. Defaults to config entry.",
+    help='the APRS-IS password for APRS_LOGIN. Defaults to config entry.',
 )
 @click.option(
-    "--no-ack",
-    "-n",
+    '--no-ack',
+    '-n',
     is_flag=True,
     show_default=True,
     default=False,
     help="Don't wait for an ack, just sent it to APRS-IS and bail.",
 )
 @click.option(
-    "--wait-response",
-    "-w",
+    '--wait-response',
+    '-w',
     is_flag=True,
     show_default=True,
     default=False,
-    help="Wait for a response to the message?",
+    help='Wait for a response to the message?',
 )
-@click.option("--raw", default=None, help="Send a raw message.  Implies --no-ack")
-@click.argument("tocallsign", required=True)
-@click.argument("command", nargs=-1, required=True)
+@click.option('--raw', default=None, help='Send a raw message.  Implies --no-ack')
+@click.argument('tocallsign', required=True)
+@click.argument('command', nargs=-1, required=True)
 @click.pass_context
 @cli_helper.process_standard_options
 def send_message(
@@ -69,11 +71,11 @@ def send_message(
 ):
     """Send a message to a callsign via APRS_IS."""
     global got_ack, got_response
-    quiet = ctx.obj["quiet"]
+    quiet = ctx.obj['quiet']
 
     if not aprs_login:
         if CONF.aprs_network.login == conf.client.DEFAULT_LOGIN:
-            click.echo("Must set --aprs_login or APRS_LOGIN")
+            click.echo('Must set --aprs_login or APRS_LOGIN')
             ctx.exit(-1)
             return
         else:
@@ -81,15 +83,15 @@ def send_message(
 
     if not aprs_password:
         if not CONF.aprs_network.password:
-            click.echo("Must set --aprs-password or APRS_PASSWORD")
+            click.echo('Must set --aprs-password or APRS_PASSWORD')
             ctx.exit(-1)
             return
         else:
             aprs_password = CONF.aprs_network.password
 
-    LOG.info(f"APRSD LISTEN Started version: {aprsd.__version__}")
+    LOG.info(f'APRSD LISTEN Started version: {aprsd.__version__}')
     if type(command) is tuple:
-        command = " ".join(command)
+        command = ' '.join(command)
     if not quiet:
         if raw:
             LOG.info(f"L'{aprs_login}' R'{raw}'")
@@ -129,7 +131,7 @@ def send_message(
                 sys.exit(0)
 
     try:
-        client_factory.create().client
+        client_factory.create().client  # noqa: B018
     except LoginError:
         sys.exit(-1)
 
@@ -140,7 +142,7 @@ def send_message(
     # message
     if raw:
         tx.send(
-            packets.Packet(from_call="", to_call="", raw=raw),
+            packets.Packet(from_call='', to_call='', raw=raw),
             direct=True,
         )
         sys.exit(0)
@@ -164,7 +166,7 @@ def send_message(
         aprs_client = client_factory.create().client
         aprs_client.consumer(rx_packet, raw=False)
     except aprslib.exceptions.ConnectionDrop:
-        LOG.error("Connection dropped, reconnecting")
+        LOG.error('Connection dropped, reconnecting')
         time.sleep(5)
         # Force the deletion of the client object connected to aprs
         # This will cause a reconnect, next time client.get_client()

aprsd/cmds/server.py

@@ -12,59 +12,24 @@ from aprsd.client import client_factory
 from aprsd.main import cli
 from aprsd.packets import collector as packet_collector
 from aprsd.packets import seen_list
-from aprsd.threads import aprsd as aprsd_threads
-from aprsd.threads import keepalive, registry, rx, tx
+from aprsd.threads import keepalive, registry, rx, service, tx
 from aprsd.threads import stats as stats_thread
-from aprsd.utils import singleton
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
-
-
-@singleton
-class ServerThreads:
-    """Registry for threads that the server command runs.
-
-    This enables extensions to register a thread to run during
-    the server command.
-
-    """
-
-    def __init__(self):
-        self.threads: list[aprsd_threads.APRSDThread] = []
-
-    def register(self, thread: aprsd_threads.APRSDThread):
-        if not isinstance(thread, aprsd_threads.APRSDThread):
-            raise TypeError(f"Thread {thread} is not an APRSDThread")
-        self.threads.append(thread)
-
-    def unregister(self, thread: aprsd_threads.APRSDThread):
-        if not isinstance(thread, aprsd_threads.APRSDThread):
-            raise TypeError(f"Thread {thread} is not an APRSDThread")
-        self.threads.remove(thread)
-
-    def start(self):
-        """Start all threads in the list."""
-        for thread in self.threads:
-            thread.start()
-
-    def join(self):
-        """Join all the threads in the list"""
-        for thread in self.threads:
-            thread.join()
+LOG = logging.getLogger('APRSD')
 
 
 # main() ###
 @cli.command()
 @cli_helper.add_options(cli_helper.common_options)
 @click.option(
-    "-f",
-    "--flush",
-    "flush",
+    '-f',
+    '--flush',
+    'flush',
     is_flag=True,
     show_default=True,
     default=False,
-    help="Flush out all old aged messages on disk.",
+    help='Flush out all old aged messages on disk.',
 )
 @click.pass_context
 @cli_helper.process_standard_options
@@ -73,37 +38,37 @@ def server(ctx, flush):
     signal.signal(signal.SIGINT, aprsd_main.signal_handler)
     signal.signal(signal.SIGTERM, aprsd_main.signal_handler)
 
-    server_threads = ServerThreads()
+    service_threads = service.ServiceThreads()
 
     level, msg = utils._check_version()
     if level:
         LOG.warning(msg)
     else:
         LOG.info(msg)
-    LOG.info(f"APRSD Started version: {aprsd.__version__}")
+    LOG.info(f'APRSD Started version: {aprsd.__version__}')
 
     # Initialize the client factory and create
     # The correct client object ready for use
     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)
 
     # 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)
 
     if not client_factory.is_client_configured():
-        LOG.error("APRS client is not properly configured in config file.")
+        LOG.error('APRS client is not properly configured in config file.')
         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)
@@ -114,7 +79,7 @@ def server(ctx, flush):
     # We register plugins first here so we can register each
     # plugins config options, so we can dump them all in the
     # log file output.
-    LOG.info("Loading Plugin Manager and registering plugins")
+    LOG.info('Loading Plugin Manager and registering plugins')
     plugin_manager = plugin.PluginManager()
     plugin_manager.setup_plugins(load_help_plugin=CONF.load_help_plugin)
 
@@ -122,10 +87,10 @@ def server(ctx, flush):
     CONF.log_opt_values(LOG, logging.DEBUG)
     message_plugins = plugin_manager.get_message_plugins()
     watchlist_plugins = plugin_manager.get_watchlist_plugins()
-    LOG.info("Message Plugins enabled and running:")
+    LOG.info('Message Plugins enabled and running:')
     for p in message_plugins:
         LOG.info(p)
-    LOG.info("Watchlist Plugins enabled and running:")
+    LOG.info('Watchlist Plugins enabled and running:')
     for p in watchlist_plugins:
         LOG.info(p)
 
@@ -135,37 +100,37 @@ def server(ctx, flush):
 
     # Now load the msgTrack from disk if any
     if flush:
-        LOG.debug("Flushing All packet tracking objects.")
+        LOG.debug('Flushing All packet tracking objects.')
         packet_collector.PacketCollector().flush()
     else:
         # Try and load saved MsgTrack list
-        LOG.debug("Loading saved packet tracking data.")
+        LOG.debug('Loading saved packet tracking data.')
         packet_collector.PacketCollector().load()
 
     # Now start all the main processing threads.
 
-    server_threads.register(keepalive.KeepAliveThread())
-    server_threads.register(stats_thread.APRSDStatsStoreThread())
-    server_threads.register(
-        rx.APRSDPluginRXThread(
+    service_threads.register(keepalive.KeepAliveThread())
+    service_threads.register(stats_thread.APRSDStatsStoreThread())
+    service_threads.register(
+        rx.APRSDRXThread(
             packet_queue=threads.packet_queue,
         ),
     )
-    server_threads.register(
+    service_threads.register(
         rx.APRSDPluginProcessPacketThread(
             packet_queue=threads.packet_queue,
         ),
     )
 
     if CONF.enable_beacon:
-        LOG.info("Beacon Enabled.  Starting Beacon thread.")
-        server_threads.register(tx.BeaconSendThread())
+        LOG.info('Beacon Enabled.  Starting Beacon thread.')
+        service_threads.register(tx.BeaconSendThread())
 
     if CONF.aprs_registry.enabled:
-        LOG.info("Registry Enabled.  Starting Registry thread.")
-        server_threads.register(registry.APRSRegistryThread())
+        LOG.info('Registry Enabled.  Starting Registry thread.')
+        service_threads.register(registry.APRSRegistryThread())
 
-    server_threads.start()
-    server_threads.join()
+    service_threads.start()
+    service_threads.join()
 
     return 0