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

aprsd/packets/filter.py

@@ -0,0 +1,58 @@
+import logging
+from typing import Callable, Protocol, runtime_checkable, Union, Dict
+
+from aprsd.packets import core
+from aprsd.utils import singleton
+
+LOG = logging.getLogger("APRSD")
+
+
+@runtime_checkable
+class PacketFilterProtocol(Protocol):
+    """Protocol API for a packet filter class.
+    """
+    def filter(self, packet: type[core.Packet]) -> Union[type[core.Packet], None]:
+        """When we get a packet from the network.
+
+        Return a Packet object if the filter passes. Return None if the
+        Packet is filtered out.
+        """
+        ...
+
+
+@singleton
+class PacketFilter:
+
+    def __init__(self):
+        self.filters: Dict[str, Callable] = {}
+
+    def register(self, packet_filter: Callable) -> None:
+        if not isinstance(packet_filter, PacketFilterProtocol):
+            raise TypeError(f"class {packet_filter} is not a PacketFilterProtocol object")
+
+        if packet_filter not in self.filters:
+            self.filters[packet_filter] = packet_filter()
+
+    def unregister(self, packet_filter: Callable) -> None:
+        if not isinstance(packet_filter, PacketFilterProtocol):
+            raise TypeError(f"class {packet_filter} is not a PacketFilterProtocol object")
+        if packet_filter in self.filters:
+            del self.filters[packet_filter]
+
+    def filter(self, packet: type[core.Packet]) -> Union[type[core.Packet], None]:
+        """Run through each of the filters.
+
+        This will step through each registered filter class
+        and call filter on it.
+
+        If the filter object returns None, we are done filtering.
+        If the filter object returns the packet, we continue filtering.
+        """
+        for packet_filter in self.filters:
+            try:
+                if not self.filters[packet_filter].filter(packet):
+                    LOG.debug(f"{self.filters[packet_filter].__class__.__name__} dropped {packet.__class__.__name__}:{packet.human_info}")
+                    return None
+            except Exception as ex:
+                LOG.error(f"{packet_filter.__clas__.__name__} failed filtering packet {packet.__class__.__name__} : {ex}")
+        return packet

aprsd/packets/filters/dupe_filter.py

@@ -0,0 +1,68 @@
+import logging
+from typing import Union
+
+from oslo_config import cfg
+
+from aprsd import packets
+from aprsd.packets import core
+
+CONF = cfg.CONF
+LOG = logging.getLogger('APRSD')
+
+
+class DupePacketFilter:
+    """This is a packet filter to detect duplicate packets.
+
+    This Uses the PacketList object to see if a packet exists
+    already.  If it does exist in the PacketList, then we need to
+    check the flag on the packet to see if it's been processed before.
+    If the packet has been processed already within the allowed
+    timeframe, then it's a dupe.
+    """
+
+    def filter(self, packet: type[core.Packet]) -> Union[type[core.Packet], None]:
+        # LOG.debug(f"{self.__class__.__name__}.filter called for packet {packet}")
+        """Filter a packet out if it's already been seen and processed."""
+        if isinstance(packet, core.AckPacket):
+            # We don't need to drop AckPackets, those should be
+            # processed.
+            # Send the AckPacket to the queue for processing elsewhere.
+            return packet
+        else:
+            # Make sure we aren't re-processing the same packet
+            # For RF based APRS Clients we can get duplicate packets
+            # So we need to track them and not process the dupes.
+            pkt_list = packets.PacketList()
+            found = False
+            try:
+                # Find the packet in the list of already seen packets
+                # Based on the packet.key
+                found = pkt_list.find(packet)
+                if not packet.msgNo:
+                    # If the packet doesn't have a message id
+                    # then there is no reliable way to detect
+                    # if it's a dupe, so we just pass it on.
+                    # it shouldn't get acked either.
+                    found = False
+            except KeyError:
+                found = False
+
+            if not found:
+                # We haven't seen this packet before, so we process it.
+                return packet
+
+            if not packet.processed:
+                # We haven't processed this packet through the plugins.
+                return packet
+            elif packet.timestamp - found.timestamp < CONF.packet_dupe_timeout:
+                # 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.'
+                )
+            else:
+                LOG.warning(
+                    f'Packet {packet.from_call}:{packet.msgNo} already tracked '
+                    f'but older than {CONF.packet_dupe_timeout} seconds. processing.',
+                )
+                return packet

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

@@ -17,24 +17,24 @@ from aprsd.packets import watch_list
 
 # setup the global logger
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+LOG = logging.getLogger('APRSD')
 
 CORE_MESSAGE_PLUGINS = [
-    "aprsd.plugins.email.EmailPlugin",
-    "aprsd.plugins.fortune.FortunePlugin",
-    "aprsd.plugins.location.LocationPlugin",
-    "aprsd.plugins.ping.PingPlugin",
-    "aprsd.plugins.time.TimePlugin",
-    "aprsd.plugins.weather.USWeatherPlugin",
-    "aprsd.plugins.version.VersionPlugin",
+    'aprsd.plugins.email.EmailPlugin',
+    'aprsd.plugins.fortune.FortunePlugin',
+    'aprsd.plugins.location.LocationPlugin',
+    'aprsd.plugins.ping.PingPlugin',
+    'aprsd.plugins.time.TimePlugin',
+    'aprsd.plugins.weather.USWeatherPlugin',
+    'aprsd.plugins.version.VersionPlugin',
 ]
 
 CORE_NOTIFY_PLUGINS = [
-    "aprsd.plugins.notify.NotifySeenPlugin",
+    'aprsd.plugins.notify.NotifySeenPlugin',
 ]
 
-hookspec = pluggy.HookspecMarker("aprsd")
-hookimpl = pluggy.HookimplMarker("aprsd")
+hookspec = pluggy.HookspecMarker('aprsd')
+hookimpl = pluggy.HookimplMarker('aprsd')
 
 
 class APRSDPluginSpec:
@@ -76,14 +76,14 @@ class APRSDPluginBase(metaclass=abc.ABCMeta):
                     else:
                         LOG.error(
                             "Can't start thread {}:{}, Must be a child "
-                            "of aprsd.threads.APRSDThread".format(
+                            'of aprsd.threads.APRSDThread'.format(
                                 self,
                                 thread,
                             ),
                         )
             except Exception:
                 LOG.error(
-                    "Failed to start threads for plugin {}".format(
+                    'Failed to start threads for plugin {}'.format(
                         self,
                     ),
                 )
@@ -93,7 +93,7 @@ class APRSDPluginBase(metaclass=abc.ABCMeta):
         return self.message_counter
 
     def help(self) -> str:
-        return "Help!"
+        return 'Help!'
 
     @abc.abstractmethod
     def setup(self):
@@ -147,10 +147,10 @@ class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
             # make sure the timeout is set or this doesn't work
             if watch_list:
                 aprs_client = client.client_factory.create().client
-                filter_str = "b/{}".format("/".join(watch_list))
+                filter_str = 'b/{}'.format('/'.join(watch_list))
                 aprs_client.set_filter(filter_str)
             else:
-                LOG.warning("Watch list enabled, but no callsigns set.")
+                LOG.warning('Watch list enabled, but no callsigns set.')
 
     @hookimpl
     def filter(self, packet: type[packets.Packet]) -> str | packets.MessagePacket:
@@ -164,7 +164,7 @@ class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                     result = self.process(packet)
                 except Exception as ex:
                     LOG.error(
-                        "Plugin {} failed to process packet {}".format(
+                        'Plugin {} failed to process packet {}'.format(
                             self.__class__,
                             ex,
                         ),
@@ -172,7 +172,7 @@ class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                 if result:
                     self.tx_inc()
         else:
-            LOG.warning(f"{self.__class__} plugin is not enabled")
+            LOG.warning(f'{self.__class__} plugin is not enabled')
 
         return result
 
@@ -196,7 +196,7 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
         raise NotImplementedError
 
     def help(self):
-        return "{}: {}".format(
+        return '{}: {}'.format(
             self.command_name.lower(),
             self.command_regex,
         )
@@ -207,7 +207,7 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
 
     @hookimpl
     def filter(self, packet: packets.MessagePacket) -> str | packets.MessagePacket:
-        LOG.debug(f"{self.__class__.__name__} called")
+        LOG.debug(f'{self.__class__.__name__} called')
         if not self.enabled:
             result = f"{self.__class__.__name__} isn't enabled"
             LOG.warning(result)
@@ -215,7 +215,7 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
 
         if not isinstance(packet, packets.MessagePacket):
             LOG.warning(
-                f"{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring"
+                f'{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring'
             )
             return packets.NULL_MESSAGE
 
@@ -237,7 +237,7 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                     result = self.process(packet)
                 except Exception as ex:
                     LOG.error(
-                        "Plugin {} failed to process packet {}".format(
+                        'Plugin {} failed to process packet {}'.format(
                             self.__class__,
                             ex,
                         ),
@@ -254,7 +254,7 @@ class APRSFIKEYMixin:
 
     def ensure_aprs_fi_key(self):
         if not CONF.aprs_fi.apiKey:
-            LOG.error("Config aprs_fi.apiKey is not set")
+            LOG.error('Config aprs_fi.apiKey is not set')
             self.enabled = False
         else:
             self.enabled = True
@@ -266,25 +266,25 @@ class HelpPlugin(APRSDRegexCommandPluginBase):
     This plugin is in this file to prevent a circular import.
     """
 
-    command_regex = "^[hH]"
-    command_name = "help"
+    command_regex = '^[hH]'
+    command_name = 'help'
 
     def help(self):
-        return "Help: send APRS help or help <plugin>"
+        return 'Help: send APRS help or help <plugin>'
 
     def process(self, packet: packets.MessagePacket):
-        LOG.info("HelpPlugin")
+        LOG.info('HelpPlugin')
         # fromcall = packet.get("from")
         message = packet.message_text
         # ack = packet.get("msgNo", "0")
-        a = re.search(r"^.*\s+(.*)", message)
+        a = re.search(r'^.*\s+(.*)', message)
         command_name = None
         if a is not None:
             command_name = a.group(1).lower()
 
         pm = PluginManager()
 
-        if command_name and "?" not in command_name:
+        if command_name and '?' not in command_name:
             # user wants help for a specific plugin
             reply = None
             for p in pm.get_plugins():
@@ -303,20 +303,20 @@ class HelpPlugin(APRSDRegexCommandPluginBase):
             LOG.debug(p)
             if p.enabled and isinstance(p, APRSDRegexCommandPluginBase):
                 name = p.command_name.lower()
-                if name not in list and "help" not in name:
+                if name not in list and 'help' not in name:
                     list.append(name)
 
         list.sort()
-        reply = " ".join(list)
+        reply = ' '.join(list)
         lines = textwrap.wrap(reply, 60)
         replies = ["Send APRS MSG of 'help' or 'help <plugin>'"]
         for line in lines:
-            replies.append(f"plugins: {line}")
+            replies.append(f'plugins: {line}')
 
         for entry in replies:
-            LOG.debug(f"{len(entry)} {entry}")
+            LOG.debug(f'{len(entry)} {entry}')
 
-        LOG.debug(f"{replies}")
+        LOG.debug(f'{replies}')
         return replies
 
 
@@ -341,17 +341,17 @@ class PluginManager:
         return cls._instance
 
     def _init(self):
-        self._pluggy_pm = pluggy.PluginManager("aprsd")
+        self._pluggy_pm = pluggy.PluginManager('aprsd')
         self._pluggy_pm.add_hookspecs(APRSDPluginSpec)
         # For the watchlist plugins
-        self._watchlist_pm = pluggy.PluginManager("aprsd")
+        self._watchlist_pm = pluggy.PluginManager('aprsd')
         self._watchlist_pm.add_hookspecs(APRSDPluginSpec)
 
     def stats(self, serializable=False) -> dict:
         """Collect and return stats for all plugins."""
 
         def full_name_with_qualname(obj):
-            return "{}.{}".format(
+            return '{}.{}'.format(
                 obj.__class__.__module__,
                 obj.__class__.__qualname__,
             )
@@ -361,10 +361,10 @@ class PluginManager:
         if plugins:
             for p in plugins:
                 plugin_stats[full_name_with_qualname(p)] = {
-                    "enabled": p.enabled,
-                    "rx": p.rx_count,
-                    "tx": p.tx_count,
-                    "version": p.version,
+                    'enabled': p.enabled,
+                    'rx': p.rx_count,
+                    'tx': p.tx_count,
+                    'version': p.version,
                 }
 
         return plugin_stats
@@ -392,19 +392,19 @@ class PluginManager:
         module_name = None
         class_name = None
         try:
-            module_name, class_name = module_class_string.rsplit(".", 1)
+            module_name, class_name = module_class_string.rsplit('.', 1)
             module = importlib.import_module(module_name)
             # Commented out because the email thread starts in a different context
             # and hence gives a different singleton for the EmailStats
             # module = importlib.reload(module)
         except Exception as ex:
             if not module_name:
-                LOG.error(f"Failed to load Plugin {module_class_string}")
+                LOG.error(f'Failed to load Plugin {module_class_string}')
             else:
                 LOG.error(f"Failed to load Plugin '{module_name}' : '{ex}'")
             return
 
-        assert hasattr(module, class_name), "class {} is not in {}".format(
+        assert hasattr(module, class_name), 'class {} is not in {}'.format(
             class_name,
             module_name,
         )
@@ -412,7 +412,7 @@ class PluginManager:
         #     class_name, module_name))
         cls = getattr(module, class_name)
         if super_cls is not None:
-            assert issubclass(cls, super_cls), "class {} should inherit from {}".format(
+            assert issubclass(cls, super_cls), 'class {} should inherit from {}'.format(
                 class_name,
                 super_cls.__name__,
             )
@@ -444,7 +444,7 @@ class PluginManager:
                         self._watchlist_pm.register(plugin_obj)
                     else:
                         LOG.warning(
-                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                            f'Plugin {plugin_obj.__class__.__name__} is disabled'
                         )
                 elif isinstance(plugin_obj, APRSDRegexCommandPluginBase):
                     if plugin_obj.enabled:
@@ -458,7 +458,7 @@ class PluginManager:
                         self._pluggy_pm.register(plugin_obj)
                     else:
                         LOG.warning(
-                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                            f'Plugin {plugin_obj.__class__.__name__} is disabled'
                         )
                 elif isinstance(plugin_obj, APRSDPluginBase):
                     if plugin_obj.enabled:
@@ -471,7 +471,7 @@ class PluginManager:
                         self._pluggy_pm.register(plugin_obj)
                     else:
                         LOG.warning(
-                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                            f'Plugin {plugin_obj.__class__.__name__} is disabled'
                         )
         except Exception as ex:
             LOG.error(f"Couldn't load plugin '{plugin_name}'")
@@ -485,11 +485,11 @@ class PluginManager:
     def setup_plugins(
         self,
         load_help_plugin=True,
-        plugin_list=[],
+        plugin_list=None,
     ):
         """Create the plugin manager and register plugins."""
 
-        LOG.info("Loading APRSD Plugins")
+        LOG.info('Loading APRSD Plugins')
         # Help plugin is always enabled.
         if load_help_plugin:
             _help = HelpPlugin()
@@ -509,7 +509,7 @@ class PluginManager:
             for p_name in CORE_MESSAGE_PLUGINS:
                 self._load_plugin(p_name)
 
-        LOG.info("Completed Plugin Loading.")
+        LOG.info('Completed Plugin Loading.')
 
     def run(self, packet: packets.MessagePacket):
         """Execute all the plugins run method."""
@@ -524,7 +524,7 @@ class PluginManager:
         """Stop all threads created by all plugins."""
         with self.lock:
             for p in self.get_plugins():
-                if hasattr(p, "stop_threads"):
+                if hasattr(p, 'stop_threads'):
                     p.stop_threads()
 
     def register_msg(self, obj):