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

aprsd/packets/filters/packet_type.py

@@ -0,0 +1,53 @@
+import logging
+from typing import Union
+
+from oslo_config import cfg
+
+from aprsd import packets
+from aprsd.packets import core
+from aprsd.utils import singleton
+
+CONF = cfg.CONF
+LOG = logging.getLogger('APRSD')
+
+
+@singleton
+class PacketTypeFilter:
+    """This filter is used to filter out packets that don't match a specific type.
+
+    To use this, register it with the PacketFilter class,
+    then instante it and call set_allow_list() with a list of packet types
+    you want to allow to pass the filtering.  All other packets will be
+    filtered out.
+    """
+
+    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,
+    }
+
+    allow_list = ()
+
+    def set_allow_list(self, filter_list):
+        tmp_list = []
+        for filter in filter_list:
+            LOG.warning(
+                f'Setting filter {filter} : {self.filters[filter]} to tmp {tmp_list}'
+            )
+            tmp_list.append(self.filters[filter])
+        self.allow_list = tuple(tmp_list)
+
+    def filter(self, packet: type[core.Packet]) -> Union[type[core.Packet], None]:
+        """Only allow packets of certain types to filter through."""
+        if self.allow_list:
+            if isinstance(packet, self.allow_list):
+                return packet

aprsd/packets/packet_list.py

@@ -7,7 +7,7 @@ from aprsd.packets import core
 from aprsd.utils import objectstore
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class PacketList(objectstore.ObjectStoreMixin):
@@ -27,8 +27,8 @@ class PacketList(objectstore.ObjectStoreMixin):
 
     def _init_data(self):
         self.data = {
-            "types": {},
-            "packets": OrderedDict(),
+            'types': {},
+            'packets': OrderedDict(),
         }
 
     def rx(self, packet: type[core.Packet]):
@@ -37,11 +37,11 @@ class PacketList(objectstore.ObjectStoreMixin):
             self._total_rx += 1
             self._add(packet)
             ptype = packet.__class__.__name__
-            type_stats = self.data["types"].setdefault(
+            type_stats = self.data['types'].setdefault(
                 ptype,
-                {"tx": 0, "rx": 0},
+                {'tx': 0, 'rx': 0},
             )
-            type_stats["rx"] += 1
+            type_stats['rx'] += 1
 
     def tx(self, packet: type[core.Packet]):
         """Add a packet that was received."""
@@ -49,32 +49,32 @@ class PacketList(objectstore.ObjectStoreMixin):
             self._total_tx += 1
             self._add(packet)
             ptype = packet.__class__.__name__
-            type_stats = self.data["types"].setdefault(
+            type_stats = self.data['types'].setdefault(
                 ptype,
-                {"tx": 0, "rx": 0},
+                {'tx': 0, 'rx': 0},
             )
-            type_stats["tx"] += 1
+            type_stats['tx'] += 1
 
     def add(self, packet):
         with self.lock:
             self._add(packet)
 
     def _add(self, packet):
-        if not self.data.get("packets"):
+        if not self.data.get('packets'):
             self._init_data()
-        if packet.key in self.data["packets"]:
-            self.data["packets"].move_to_end(packet.key)
-        elif len(self.data["packets"]) == self.maxlen:
-            self.data["packets"].popitem(last=False)
-        self.data["packets"][packet.key] = packet
+        if packet.key in self.data['packets']:
+            self.data['packets'].move_to_end(packet.key)
+        elif len(self.data['packets']) == self.maxlen:
+            self.data['packets'].popitem(last=False)
+        self.data['packets'][packet.key] = packet
 
     def find(self, packet):
         with self.lock:
-            return self.data["packets"][packet.key]
+            return self.data['packets'][packet.key]
 
     def __len__(self):
         with self.lock:
-            return len(self.data["packets"])
+            return len(self.data['packets'])
 
     def total_rx(self):
         with self.lock:
@@ -87,17 +87,23 @@ class PacketList(objectstore.ObjectStoreMixin):
     def stats(self, serializable=False) -> dict:
         with self.lock:
             # Get last N packets directly using list slicing
-            packets_list = list(self.data.get("packets", {}).values())
-            pkts = packets_list[-CONF.packet_list_stats_maxlen :][::-1]
-
+            if CONF.packet_list_stats_maxlen >= 0:
+                packets_list = list(self.data.get('packets', {}).values())
+                pkts = packets_list[-CONF.packet_list_stats_maxlen :][::-1]
+            else:
+                # We have to copy here, because this get() results in a pointer
+                # to the packets internally here, which can change after this
+                # function returns, which would cause a problem trying to save
+                # the stats to disk.
+                pkts = self.data.get('packets', {}).copy()
             stats = {
-                "total_tracked": self._total_rx
+                'total_tracked': self._total_rx
                 + self._total_tx,  # Fixed typo: was rx + rx
-                "rx": self._total_rx,
-                "tx": self._total_tx,
-                "types": self.data.get("types", {}),  # Changed default from [] to {}
-                "packet_count": len(self.data.get("packets", [])),
-                "maxlen": self.maxlen,
-                "packets": pkts,
+                'rx': self._total_rx,
+                'tx': self._total_tx,
+                'types': self.data.get('types', {}),  # Changed default from [] to {}
+                'packet_count': len(self.data.get('packets', [])),
+                'maxlen': self.maxlen,
+                'packets': pkts,
             }
             return stats

aprsd/threads/__init__.py

@@ -4,9 +4,8 @@ import queue
 # aprsd.threads
 from .aprsd import APRSDThread, APRSDThreadList  # noqa: F401
 from .rx import (  # noqa: F401
-    APRSDDupeRXThread,
     APRSDProcessPacketThread,
     APRSDRXThread,
 )
 
-packet_queue = queue.Queue(maxsize=20)
+packet_queue = queue.Queue(maxsize=500)

aprsd/threads/rx.py

@@ -8,20 +8,32 @@ from oslo_config import cfg
 
 from aprsd import packets, plugin
 from aprsd.client import client_factory
-from aprsd.packets import collector
+from aprsd.packets import collector, filter
 from aprsd.packets import log as packet_log
 from aprsd.threads import APRSDThread, tx
-from aprsd.utils import trace
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class APRSDRXThread(APRSDThread):
+    """Main Class to connect to an APRS Client and recieve packets.
+
+    A packet is received in the main loop and then sent to the
+    process_packet method, which sends the packet through the collector
+    to track the packet for stats, and then put into the packet queue
+    for processing in a separate thread.
+    """
+
     _client = None
 
+    # This is the queue that packets are sent to for processing.
+    # We process packets in a separate thread to help prevent
+    # getting blocked by the APRS server trying to send us packets.
+    packet_queue = None
+
     def __init__(self, packet_queue):
-        super().__init__("RX_PKT")
+        super().__init__('RX_PKT')
         self.packet_queue = packet_queue
 
     def stop(self):
@@ -52,7 +64,7 @@ class APRSDRXThread(APRSDThread):
             # kwargs.  :(
             # https://github.com/rossengeorgiev/aprs-python/pull/56
             self._client.consumer(
-                self._process_packet,
+                self.process_packet,
                 raw=False,
                 blocking=False,
             )
@@ -60,7 +72,7 @@ class APRSDRXThread(APRSDThread):
             aprslib.exceptions.ConnectionDrop,
             aprslib.exceptions.ConnectionError,
         ):
-            LOG.error("Connection dropped, reconnecting")
+            LOG.error('Connection dropped, reconnecting')
             # Force the deletion of the client object connected to aprs
             # This will cause a reconnect, next time client.get_client()
             # is called
@@ -68,45 +80,18 @@ class APRSDRXThread(APRSDThread):
             time.sleep(5)
         except Exception:
             # LOG.exception(ex)
-            LOG.error("Resetting connection and trying again.")
+            LOG.error('Resetting connection and trying again.')
             self._client.reset()
             time.sleep(5)
-        # Continue to loop
-        time.sleep(1)
         return True
 
-    def _process_packet(self, *args, **kwargs):
-        """Intermediate callback so we can update the keepalive time."""
-        # Now call the 'real' packet processing for a RX'x packet
-        self.process_packet(*args, **kwargs)
-
-    @abc.abstractmethod
     def process_packet(self, *args, **kwargs):
-        pass
-
-
-class APRSDDupeRXThread(APRSDRXThread):
-    """Process received packets.
-
-    This is the main APRSD Server command thread that
-    receives packets and makes sure the packet
-    hasn't been seen previously before sending it on
-    to be processed.
-    """
-
-    @trace.trace
-    def process_packet(self, *args, **kwargs):
-        """This handles the processing of an inbound packet.
-
-        When a packet is received by the connected client object,
-        it sends the raw packet into this function.  This function then
-        decodes the packet via the client, and then processes the packet.
-        Ack Packets are sent to the PluginProcessPacketThread for processing.
-        All other packets have to be checked as a dupe, and then only after
-        we haven't seen this packet before, do we send it to the
-        PluginProcessPacketThread for processing.
-        """
         packet = self._client.decode_packet(*args, **kwargs)
+        if not packet:
+            LOG.error(
+                'No packet received from decode_packet.  Most likely a failure to parse'
+            )
+            return
         packet_log.log(packet)
         pkt_list = packets.PacketList()
 
@@ -140,26 +125,55 @@ class APRSDDupeRXThread(APRSDRXThread):
                 # If the packet came in within N seconds of the
                 # Last time seeing the packet, then we drop it as a dupe.
                 LOG.warning(
-                    f"Packet {packet.from_call}:{packet.msgNo} already tracked, dropping."
+                    f'Packet {packet.from_call}:{packet.msgNo} already tracked, dropping.'
                 )
             else:
                 LOG.warning(
-                    f"Packet {packet.from_call}:{packet.msgNo} already tracked "
-                    f"but older than {CONF.packet_dupe_timeout} seconds. processing.",
+                    f'Packet {packet.from_call}:{packet.msgNo} already tracked '
+                    f'but older than {CONF.packet_dupe_timeout} seconds. processing.',
                 )
                 collector.PacketCollector().rx(packet)
                 self.packet_queue.put(packet)
 
 
-class APRSDPluginRXThread(APRSDDupeRXThread):
-    """ "Process received packets.
+class APRSDFilterThread(APRSDThread):
+    def __init__(self, thread_name, packet_queue):
+        super().__init__(thread_name)
+        self.packet_queue = packet_queue
 
-    For backwards compatibility, we keep the APRSDPluginRXThread.
-    """
+    def filter_packet(self, packet):
+        # Do any packet filtering prior to processing
+        if not filter.PacketFilter().filter(packet):
+            return None
+        return packet
 
+    def print_packet(self, packet):
+        """Allow a child of this class to override this.
 
-class APRSDProcessPacketThread(APRSDThread):
-    """Base class for processing received packets.
+        This is helpful if for whatever reason the child class
+        doesn't want to log packets.
+
+        """
+        packet_log.log(packet)
+
+    def loop(self):
+        try:
+            packet = self.packet_queue.get(timeout=1)
+            self.print_packet(packet)
+            if packet:
+                if self.filter_packet(packet):
+                    self.process_packet(packet)
+        except queue.Empty:
+            pass
+        return True
+
+
+class APRSDProcessPacketThread(APRSDFilterThread):
+    """Base class for processing received packets after they have been filtered.
+
+    Packets are received from the client, then filtered for dupes,
+    then sent to the packet queue.  This thread pulls packets from
+    the packet queue for processing.
 
     This is the base class for processing packets coming from
     the consumer.  This base class handles sending ack packets and
@@ -167,44 +181,38 @@ class APRSDProcessPacketThread(APRSDThread):
     for processing."""
 
     def __init__(self, packet_queue):
-        self.packet_queue = packet_queue
-        super().__init__("ProcessPKT")
+        super().__init__('ProcessPKT', packet_queue=packet_queue)
         if not CONF.enable_sending_ack_packets:
             LOG.warning(
-                "Sending ack packets is disabled, messages "
-                "will not be acknowledged.",
+                'Sending ack packets is disabled, messages will not be acknowledged.',
             )
 
     def process_ack_packet(self, packet):
         """We got an ack for a message, no need to resend it."""
         ack_num = packet.msgNo
-        LOG.debug(f"Got ack for message {ack_num}")
+        LOG.debug(f'Got ack for message {ack_num}')
         collector.PacketCollector().rx(packet)
 
     def process_piggyback_ack(self, packet):
         """We got an ack embedded in a packet."""
         ack_num = packet.ackMsgNo
-        LOG.debug(f"Got PiggyBackAck for message {ack_num}")
+        LOG.debug(f'Got PiggyBackAck for message {ack_num}')
         collector.PacketCollector().rx(packet)
 
     def process_reject_packet(self, packet):
         """We got a reject message for a packet.  Stop sending the message."""
         ack_num = packet.msgNo
-        LOG.debug(f"Got REJECT for message {ack_num}")
+        LOG.debug(f'Got REJECT for message {ack_num}')
         collector.PacketCollector().rx(packet)
 
-    def loop(self):
-        try:
-            packet = self.packet_queue.get(timeout=1)
-            if packet:
-                self.process_packet(packet)
-        except queue.Empty:
-            pass
-        return True
-
     def process_packet(self, packet):
         """Process a packet received from aprs-is server."""
-        LOG.debug(f"ProcessPKT-LOOP {self.loop_count}")
+        LOG.debug(f'ProcessPKT-LOOP {self.loop_count}')
+
+        # set this now as we are going to process it.
+        # This is used during dupe checking, so set it early
+        packet.processed = True
+
         our_call = CONF.callsign.lower()
 
         from_call = packet.from_call
@@ -227,7 +235,7 @@ class APRSDProcessPacketThread(APRSDThread):
         ):
             self.process_reject_packet(packet)
         else:
-            if hasattr(packet, "ackMsgNo") and packet.ackMsgNo:
+            if hasattr(packet, 'ackMsgNo') and packet.ackMsgNo:
                 # we got an ack embedded in this packet
                 # we need to handle the ack
                 self.process_piggyback_ack(packet)
@@ -267,7 +275,7 @@ class APRSDProcessPacketThread(APRSDThread):
         if not for_us:
             LOG.info("Got a packet meant for someone else '{packet.to_call}'")
         else:
-            LOG.info("Got a non AckPacket/MessagePacket")
+            LOG.info('Got a non AckPacket/MessagePacket')
 
 
 class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
@@ -287,7 +295,7 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
                             tx.send(subreply)
                         else:
                             wl = CONF.watch_list
-                            to_call = wl["alert_callsign"]
+                            to_call = wl['alert_callsign']
                             tx.send(
                                 packets.MessagePacket(
                                     from_call=CONF.callsign,
@@ -299,7 +307,7 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
                     # We have a message based object.
                     tx.send(reply)
         except Exception as ex:
-            LOG.error("Plugin failed!!!")
+            LOG.error('Plugin failed!!!')
             LOG.exception(ex)
 
     def process_our_message_packet(self, packet):
@@ -355,11 +363,11 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
             if to_call == CONF.callsign and not replied:
                 # Tailor the messages accordingly
                 if CONF.load_help_plugin:
-                    LOG.warning("Sending help!")
+                    LOG.warning('Sending help!')
                     message_text = "Unknown command! Send 'help' message for help"
                 else:
-                    LOG.warning("Unknown command!")
-                    message_text = "Unknown command!"
+                    LOG.warning('Unknown command!')
+                    message_text = 'Unknown command!'
 
                 tx.send(
                     packets.MessagePacket(
@@ -369,11 +377,11 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
                     ),
                 )
         except Exception as ex:
-            LOG.error("Plugin failed!!!")
+            LOG.error('Plugin failed!!!')
             LOG.exception(ex)
             # Do we need to send a reply?
             if to_call == CONF.callsign:
-                reply = "A Plugin failed! try again?"
+                reply = 'A Plugin failed! try again?'
                 tx.send(
                     packets.MessagePacket(
                         from_call=CONF.callsign,
@@ -382,4 +390,4 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
                     ),
                 )
 
-        LOG.debug("Completed process_our_message_packet")
+        LOG.debug('Completed process_our_message_packet')

aprsd/threads/stats.py

@@ -1,8 +1,6 @@
 import logging
-import threading
 import time
 
-import wrapt
 from oslo_config import cfg
 
 from aprsd.stats import collector
@@ -10,18 +8,15 @@ from aprsd.threads import APRSDThread
 from aprsd.utils import objectstore
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class StatsStore(objectstore.ObjectStoreMixin):
     """Container to save the stats from the collector."""
 
-    lock = threading.Lock()
-    data = {}
-
-    @wrapt.synchronized(lock)
     def add(self, stats: dict):
-        self.data = stats
+        with self.lock:
+            self.data = stats
 
 
 class APRSDStatsStoreThread(APRSDThread):
@@ -31,7 +26,7 @@ class APRSDStatsStoreThread(APRSDThread):
     save_interval = 10
 
     def __init__(self):
-        super().__init__("StatsStore")
+        super().__init__('StatsStore')
 
     def loop(self):
         if self.loop_count % self.save_interval == 0:

aprsd/utils/objectstore.py

@@ -6,9 +6,8 @@ import threading
 
 from oslo_config import cfg
 
-
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 
 class ObjectStoreMixin:
@@ -63,7 +62,7 @@ class ObjectStoreMixin:
     def _save_filename(self):
         save_location = CONF.save_location
 
-        return "{}/{}.p".format(
+        return '{}/{}.p'.format(
             save_location,
             self.__class__.__name__.lower(),
         )
@@ -75,13 +74,13 @@ class ObjectStoreMixin:
         self._init_store()
         save_filename = self._save_filename()
         if len(self) > 0:
-            LOG.info(
-                f"{self.__class__.__name__}::Saving"
-                f" {len(self)} entries to disk at "
-                f"{save_filename}",
+            LOG.debug(
+                f'{self.__class__.__name__}::Saving'
+                f' {len(self)} entries to disk at '
+                f'{save_filename}',
             )
             with self.lock:
-                with open(save_filename, "wb+") as fp:
+                with open(save_filename, 'wb+') as fp:
                     pickle.dump(self.data, fp)
         else:
             LOG.debug(
@@ -97,21 +96,21 @@ class ObjectStoreMixin:
             return
         if os.path.exists(self._save_filename()):
             try:
-                with open(self._save_filename(), "rb") as fp:
+                with open(self._save_filename(), 'rb') as fp:
                     raw = pickle.load(fp)
                     if raw:
                         self.data = raw
                         LOG.debug(
-                            f"{self.__class__.__name__}::Loaded {len(self)} entries from disk.",
+                            f'{self.__class__.__name__}::Loaded {len(self)} entries from disk.',
                         )
                     else:
-                        LOG.debug(f"{self.__class__.__name__}::No data to load.")
+                        LOG.debug(f'{self.__class__.__name__}::No data to load.')
             except (pickle.UnpicklingError, Exception) as ex:
-                LOG.error(f"Failed to UnPickle {self._save_filename()}")
+                LOG.error(f'Failed to UnPickle {self._save_filename()}')
                 LOG.error(ex)
                 self.data = {}
         else:
-            LOG.debug(f"{self.__class__.__name__}::No save file found.")
+            LOG.debug(f'{self.__class__.__name__}::No save file found.')
 
     def flush(self):
         """Nuke the old pickle file that stored the old results from last aprsd run."""

{aprsd-4.0.2.dist-info → aprsd-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aprsd
-Version: 4.0.2
+Version: 4.1.0
 Summary: APRSd is a APRS-IS server that can be used to connect to APRS-IS and send and receive APRS packets.
 Author-email: Craig Lamparter <craig@craiger.org>, "Walter A. Boring IV" <waboring@hemna.com>, Emre Saglam <emresaglam@gmail.com>, Jason Martin <jhmartin@toger.us>, John <johng42@users.noreply.github.com>, Martiros Shakhzadyan <vrzh@vrzh.net>, Zoe Moore <zoenb@mailbox.org>, ranguli <hello@joshmurphy.ca>
 Maintainer-email: Craig Lamparter <craig@craiger.org>, "Walter A. Boring IV" <waboring@hemna.com>