aprsd 3.3.4__py2.py3-none-any.whl → 3.4.0__py2.py3-none-any.whl

aprsd/packets/log.py

@@ -0,0 +1,143 @@
+import logging
+from typing import Optional
+
+from loguru import logger
+from oslo_config import cfg
+
+from aprsd.packets.core import AckPacket, RejectPacket
+
+
+LOG = logging.getLogger()
+LOGU = logger
+CONF = cfg.CONF
+
+FROM_COLOR = "fg #C70039"
+TO_COLOR = "fg #D033FF"
+TX_COLOR = "red"
+RX_COLOR = "green"
+PACKET_COLOR = "cyan"
+
+
+def log_multiline(packet, tx: Optional[bool] = False, header: Optional[bool] = True) -> None:
+    """LOG a packet to the logfile."""
+    if not CONF.enable_packet_logging:
+        return
+    if CONF.log_packet_format == "compact":
+        return
+
+    # asdict(packet)
+    logit = ["\n"]
+    name = packet.__class__.__name__
+
+    if isinstance(packet, AckPacket):
+        pkt_max_send_count = CONF.default_ack_send_count
+    else:
+        pkt_max_send_count = CONF.default_packet_send_count
+
+    if header:
+        if tx:
+            header_str = f"<{TX_COLOR}>TX</{TX_COLOR}>"
+            logit.append(
+                f"{header_str}________(<{PACKET_COLOR}>{name}</{PACKET_COLOR}>  "
+                f"TX:{packet.send_count + 1} of {pkt_max_send_count}",
+            )
+        else:
+            header_str = f"<{RX_COLOR}>RX</{RX_COLOR}>"
+            logit.append(
+                f"{header_str}________(<{PACKET_COLOR}>{name}</{PACKET_COLOR}>)",
+            )
+
+    else:
+        header_str = ""
+        logit.append(f"__________(<{PACKET_COLOR}>{name}</{PACKET_COLOR}>)")
+    # log_list.append(f"  Packet  : {packet.__class__.__name__}")
+    if packet.msgNo:
+        logit.append(f"  Msg #   : {packet.msgNo}")
+    if packet.from_call:
+        logit.append(f"  From    : <{FROM_COLOR}>{packet.from_call}</{FROM_COLOR}>")
+    if packet.to_call:
+        logit.append(f"  To      : <{TO_COLOR}>{packet.to_call}</{TO_COLOR}>")
+    if hasattr(packet, "path") and packet.path:
+        logit.append(f"  Path    : {'=>'.join(packet.path)}")
+    if hasattr(packet, "via") and packet.via:
+        logit.append(f"  VIA     : {packet.via}")
+
+    if not isinstance(packet, AckPacket) and not isinstance(packet, RejectPacket):
+        msg = packet.human_info
+
+        if msg:
+            msg = msg.replace("<", "\\<")
+            logit.append(f"  Info    : <light-yellow><b>{msg}</b></light-yellow>")
+
+    if hasattr(packet, "comment") and packet.comment:
+        logit.append(f"  Comment : {packet.comment}")
+
+    raw = packet.raw.replace("<", "\\<")
+    logit.append(f"  Raw     : <fg #828282>{raw}</fg #828282>")
+    logit.append(f"{header_str}________(<{PACKET_COLOR}>{name}</{PACKET_COLOR}>)")
+
+    LOGU.opt(colors=True).info("\n".join(logit))
+    LOG.debug(repr(packet))
+
+
+def log(packet, tx: Optional[bool] = False, header: Optional[bool] = True) -> None:
+    if not CONF.enable_packet_logging:
+        return
+    if CONF.log_packet_format == "multiline":
+        log_multiline(packet, tx, header)
+        return
+
+    logit = []
+    name = packet.__class__.__name__
+    if isinstance(packet, AckPacket):
+        pkt_max_send_count = CONF.default_ack_send_count
+    else:
+        pkt_max_send_count = CONF.default_packet_send_count
+
+    if header:
+        if tx:
+            via_color = "red"
+            arrow = f"<{via_color}>-></{via_color}>"
+            logit.append(
+                f"<red>TX {arrow}</red> "
+                f"<cyan>{name}</cyan>"
+                f":{packet.msgNo}"
+                f" ({packet.send_count + 1} of {pkt_max_send_count})",
+            )
+        else:
+            via_color = "fg #828282"
+            arrow = f"<{via_color}>-></{via_color}>"
+            left_arrow = f"<{via_color}><-</{via_color}>"
+            logit.append(
+                f"<fg #1AA730>RX</fg #1AA730> {left_arrow} "
+                f"<cyan>{name}</cyan>"
+                f":{packet.msgNo}",
+            )
+    else:
+        via_color = "green"
+        arrow = f"<{via_color}>-></{via_color}>"
+        logit.append(
+            f"<cyan>{name}</cyan>"
+            f":{packet.msgNo}",
+        )
+
+    tmp = None
+    if packet.path:
+        tmp = f"{arrow}".join(packet.path) + f"{arrow} "
+
+    logit.append(
+        f"<{FROM_COLOR}>{packet.from_call}</{FROM_COLOR}> {arrow}"
+        f"{tmp if tmp else ' '}"
+        f"<{TO_COLOR}>{packet.to_call}</{TO_COLOR}>",
+    )
+
+    if not isinstance(packet, AckPacket) and not isinstance(packet, RejectPacket):
+        logit.append(":")
+        msg = packet.human_info
+
+        if msg:
+            msg = msg.replace("<", "\\<")
+            logit.append(f"<light-yellow><b>{msg}</b></light-yellow>")
+
+    LOGU.opt(colors=True).info(" ".join(logit))
+    log_multiline(packet, tx, header)

aprsd/packets/packet_list.py

@@ -1,99 +1,116 @@
 from collections import OrderedDict
-from collections.abc import MutableMapping
 import logging
-import threading
 
 from oslo_config import cfg
-import wrapt
 
-from aprsd import stats
-from aprsd.packets import seen_list
+from aprsd.packets import collector, core
+from aprsd.utils import objectstore
 
 
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
-class PacketList(MutableMapping):
+class PacketList(objectstore.ObjectStoreMixin):
+    """Class to keep track of the packets we tx/rx."""
     _instance = None
-    lock = threading.Lock()
     _total_rx: int = 0
     _total_tx: int = 0
-    types = {}
+    maxlen: int = 100
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
-            cls._maxlen = 100
-            cls.d = OrderedDict()
+            cls._instance.maxlen = CONF.packet_list_maxlen
+            cls._instance._init_data()
         return cls._instance
 
-    @wrapt.synchronized(lock)
-    def rx(self, packet):
+    def _init_data(self):
+        self.data = {
+            "types": {},
+            "packets": OrderedDict(),
+        }
+
+    def rx(self, packet: type[core.Packet]):
         """Add a packet that was received."""
-        self._total_rx += 1
-        self._add(packet)
-        ptype = packet.__class__.__name__
-        if not ptype in self.types:
-            self.types[ptype] = {"tx": 0, "rx": 0}
-        self.types[ptype]["rx"] += 1
-        seen_list.SeenList().update_seen(packet)
-        stats.APRSDStats().rx(packet)
-
-    @wrapt.synchronized(lock)
-    def tx(self, packet):
+        with self.lock:
+            self._total_rx += 1
+            self._add(packet)
+            ptype = packet.__class__.__name__
+            if not ptype in self.data["types"]:
+                self.data["types"][ptype] = {"tx": 0, "rx": 0}
+            self.data["types"][ptype]["rx"] += 1
+
+    def tx(self, packet: type[core.Packet]):
         """Add a packet that was received."""
-        self._total_tx += 1
-        self._add(packet)
-        ptype = packet.__class__.__name__
-        if not ptype in self.types:
-            self.types[ptype] = {"tx": 0, "rx": 0}
-        self.types[ptype]["tx"] += 1
-        seen_list.SeenList().update_seen(packet)
-        stats.APRSDStats().tx(packet)
-
-    @wrapt.synchronized(lock)
+        with self.lock:
+            self._total_tx += 1
+            self._add(packet)
+            ptype = packet.__class__.__name__
+            if not ptype in self.data["types"]:
+                self.data["types"][ptype] = {"tx": 0, "rx": 0}
+            self.data["types"][ptype]["tx"] += 1
+
     def add(self, packet):
-        self._add(packet)
+        with self.lock:
+            self._add(packet)
 
     def _add(self, packet):
-        self[packet.key] = packet
-
-    def copy(self):
-        return self.d.copy()
-
-    @property
-    def maxlen(self):
-        return self._maxlen
+        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
 
-    @wrapt.synchronized(lock)
     def find(self, packet):
-        return self.get(packet.key)
-
-    def __getitem__(self, key):
-        # self.d.move_to_end(key)
-        return self.d[key]
-
-    def __setitem__(self, key, value):
-        if key in self.d:
-            self.d.move_to_end(key)
-        elif len(self.d) == self.maxlen:
-            self.d.popitem(last=False)
-        self.d[key] = value
-
-    def __delitem__(self, key):
-        del self.d[key]
-
-    def __iter__(self):
-        return self.d.__iter__()
+        with self.lock:
+            return self.data["packets"][packet.key]
 
     def __len__(self):
-        return len(self.d)
+        with self.lock:
+            return len(self.data["packets"])
 
-    @wrapt.synchronized(lock)
     def total_rx(self):
-        return self._total_rx
+        with self.lock:
+            return self._total_rx
 
-    @wrapt.synchronized(lock)
     def total_tx(self):
-        return self._total_tx
+        with self.lock:
+            return self._total_tx
+
+    def stats(self, serializable=False) -> dict:
+        # limit the number of packets to return to 50
+        with self.lock:
+            tmp = OrderedDict(
+                reversed(
+                    list(
+                        self.data.get("packets", OrderedDict()).items(),
+                    ),
+                ),
+            )
+            pkts = []
+            count = 1
+            for packet in tmp:
+                pkts.append(tmp[packet])
+                count += 1
+                if count > CONF.packet_list_stats_maxlen:
+                    break
+
+            stats = {
+                "total_tracked": self._total_rx + self._total_rx,
+                "rx": self._total_rx,
+                "tx": self._total_tx,
+                "types": self.data.get("types", []),
+                "packet_count": len(self.data.get("packets", [])),
+                "maxlen": self.maxlen,
+                "packets": pkts,
+            }
+            return stats
+
+
+# Now register the PacketList with the collector
+# every packet we RX and TX goes through the collector
+# for processing for whatever reason is needed.
+collector.PacketCollector().register(PacketList)

aprsd/packets/seen_list.py

@@ -1,10 +1,9 @@
 import datetime
 import logging
-import threading
 
 from oslo_config import cfg
-import wrapt
 
+from aprsd.packets import collector, core
 from aprsd.utils import objectstore
 
 
@@ -16,28 +15,40 @@ class SeenList(objectstore.ObjectStoreMixin):
     """Global callsign seen list."""
 
     _instance = None
-    lock = threading.Lock()
     data: dict = {}
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
-            cls._instance._init_store()
             cls._instance.data = {}
         return cls._instance
 
-    @wrapt.synchronized(lock)
-    def update_seen(self, packet):
-        callsign = None
-        if packet.from_call:
-            callsign = packet.from_call
-        else:
-            LOG.warning(f"Can't find FROM in packet {packet}")
-            return
-        if callsign not in self.data:
-            self.data[callsign] = {
-                "last": None,
-                "count": 0,
-            }
-        self.data[callsign]["last"] = str(datetime.datetime.now())
-        self.data[callsign]["count"] += 1
+    def stats(self, serializable=False):
+        """Return the stats for the PacketTrack class."""
+        with self.lock:
+            return self.data
+
+    def rx(self, packet: type[core.Packet]):
+        """When we get a packet from the network, update the seen list."""
+        with self.lock:
+            callsign = None
+            if packet.from_call:
+                callsign = packet.from_call
+            else:
+                LOG.warning(f"Can't find FROM in packet {packet}")
+                return
+            if callsign not in self.data:
+                self.data[callsign] = {
+                    "last": None,
+                    "count": 0,
+                }
+            self.data[callsign]["last"] = datetime.datetime.now()
+            self.data[callsign]["count"] += 1
+
+    def tx(self, packet: type[core.Packet]):
+        """We don't care about TX packets."""
+
+
+# Register with the packet collector so we can process the packet
+# when we get it off the client (network)
+collector.PacketCollector().register(SeenList)

aprsd/packets/tracker.py

@@ -1,14 +1,14 @@
 import datetime
-import threading
+import logging
 
 from oslo_config import cfg
-import wrapt
 
-from aprsd.threads import tx
+from aprsd.packets import collector, core
 from aprsd.utils import objectstore
 
 
 CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
 
 
 class PacketTrack(objectstore.ObjectStoreMixin):
@@ -26,7 +26,6 @@ class PacketTrack(objectstore.ObjectStoreMixin):
 
     _instance = None
     _start_time = None
-    lock = threading.Lock()
 
     data: dict = {}
     total_tracked: int = 0
@@ -38,74 +37,73 @@ class PacketTrack(objectstore.ObjectStoreMixin):
             cls._instance._init_store()
         return cls._instance
 
-    @wrapt.synchronized(lock)
     def __getitem__(self, name):
-        return self.data[name]
+        with self.lock:
+            return self.data[name]
 
-    @wrapt.synchronized(lock)
     def __iter__(self):
-        return iter(self.data)
+        with self.lock:
+            return iter(self.data)
 
-    @wrapt.synchronized(lock)
     def keys(self):
-        return self.data.keys()
+        with self.lock:
+            return self.data.keys()
 
-    @wrapt.synchronized(lock)
     def items(self):
-        return self.data.items()
+        with self.lock:
+            return self.data.items()
 
-    @wrapt.synchronized(lock)
     def values(self):
-        return self.data.values()
+        with self.lock:
+            return self.data.values()
+
+    def stats(self, serializable=False):
+        with self.lock:
+            stats = {
+                "total_tracked": self.total_tracked,
+            }
+            pkts = {}
+            for key in self.data:
+                last_send_time = self.data[key].last_send_time
+                pkts[key] = {
+                    "last_send_time": last_send_time,
+                    "send_count": self.data[key].send_count,
+                    "retry_count": self.data[key].retry_count,
+                    "message": self.data[key].raw,
+                }
+            stats["packets"] = pkts
+        return stats
+
+    def rx(self, packet: type[core.Packet]) -> None:
+        """When we get a packet from the network, check if we should remove it."""
+        if isinstance(packet, core.AckPacket):
+            self._remove(packet.msgNo)
+        elif isinstance(packet, core.RejectPacket):
+            self._remove(packet.msgNo)
+        elif hasattr(packet, "ackMsgNo"):
+            # Got a piggyback ack, so remove the original message
+            self._remove(packet.ackMsgNo)
+
+    def tx(self, packet: type[core.Packet]) -> None:
+        """Add a packet that was sent."""
+        with self.lock:
+            key = packet.msgNo
+            packet.send_count = 0
+            self.data[key] = packet
+            self.total_tracked += 1
 
-    @wrapt.synchronized(lock)
-    def __len__(self):
-        return len(self.data)
+    def remove(self, key):
+        self._remove(key)
 
-    @wrapt.synchronized(lock)
-    def add(self, packet):
-        key = packet.msgNo
-        packet._last_send_attempt = 0
-        self.data[key] = packet
-        self.total_tracked += 1
+    def _remove(self, key):
+        with self.lock:
+            try:
+                del self.data[key]
+            except KeyError:
+                pass
 
-    @wrapt.synchronized(lock)
-    def get(self, key):
-        return self.data.get(key, None)
 
-    @wrapt.synchronized(lock)
-    def remove(self, key):
-        try:
-            del self.data[key]
-        except KeyError:
-            pass
-
-    def restart(self):
-        """Walk the list of messages and restart them if any."""
-        for key in self.data.keys():
-            pkt = self.data[key]
-            if pkt._last_send_attempt < pkt.retry_count:
-                tx.send(pkt)
-
-    def _resend(self, packet):
-        packet._last_send_attempt = 0
-        tx.send(packet)
-
-    def restart_delayed(self, count=None, most_recent=True):
-        """Walk the list of delayed messages and restart them if any."""
-        if not count:
-            # Send all the delayed messages
-            for key in self.data.keys():
-                pkt = self.data[key]
-                if pkt._last_send_attempt == pkt._retry_count:
-                    self._resend(pkt)
-        else:
-            # They want to resend <count> delayed messages
-            tmp = sorted(
-                self.data.items(),
-                reverse=most_recent,
-                key=lambda x: x[1].last_send_time,
-            )
-            pkt_list = tmp[:count]
-            for (_key, pkt) in pkt_list:
-                self._resend(pkt)
+# Now register the PacketList with the collector
+# every packet we RX and TX goes through the collector
+# for processing for whatever reason is needed.
+collector.PacketCollector().register(PacketTrack)