aprsd 1.0.0__py3-none-any.whl → 3.4.1__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

@@ -0,0 +1,116 @@
+from collections import OrderedDict
+import logging
+
+from oslo_config import cfg
+
+from aprsd.packets import collector, core
+from aprsd.utils import objectstore
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class PacketList(objectstore.ObjectStoreMixin):
+    """Class to keep track of the packets we tx/rx."""
+    _instance = None
+    _total_rx: int = 0
+    _total_tx: int = 0
+    maxlen: int = 100
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance.maxlen = CONF.packet_list_maxlen
+            cls._instance._init_data()
+        return cls._instance
+
+    def _init_data(self):
+        self.data = {
+            "types": {},
+            "packets": OrderedDict(),
+        }
+
+    def rx(self, packet: type[core.Packet]):
+        """Add a packet that was received."""
+        with self.lock:
+            self._total_rx += 1
+            self._add(packet)
+            ptype = packet.__class__.__name__
+            if ptype not 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."""
+        with self.lock:
+            self._total_tx += 1
+            self._add(packet)
+            ptype = packet.__class__.__name__
+            if ptype not in self.data["types"]:
+                self.data["types"][ptype] = {"tx": 0, "rx": 0}
+            self.data["types"][ptype]["tx"] += 1
+
+    def add(self, packet):
+        with self.lock:
+            self._add(packet)
+
+    def _add(self, packet):
+        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
+
+    def find(self, packet):
+        with self.lock:
+            return self.data["packets"][packet.key]
+
+    def __len__(self):
+        with self.lock:
+            return len(self.data["packets"])
+
+    def total_rx(self):
+        with self.lock:
+            return self._total_rx
+
+    def total_tx(self):
+        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

@@ -0,0 +1,54 @@
+import datetime
+import logging
+
+from oslo_config import cfg
+
+from aprsd.packets import collector, core
+from aprsd.utils import objectstore
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class SeenList(objectstore.ObjectStoreMixin):
+    """Global callsign seen list."""
+
+    _instance = None
+    data: dict = {}
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance.data = {}
+        return cls._instance
+
+    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

@@ -0,0 +1,109 @@
+import datetime
+import logging
+
+from oslo_config import cfg
+
+from aprsd.packets import collector, core
+from aprsd.utils import objectstore
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class PacketTrack(objectstore.ObjectStoreMixin):
+    """Class to keep track of outstanding text messages.
+
+    This is a thread safe class that keeps track of active
+    messages.
+
+    When a message is asked to be sent, it is placed into this
+    class via it's id.  The TextMessage class's send() method
+    automatically adds itself to this class.  When the ack is
+    recieved from the radio, the message object is removed from
+    this class.
+    """
+
+    _instance = None
+    _start_time = None
+
+    data: dict = {}
+    total_tracked: int = 0
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._start_time = datetime.datetime.now()
+            cls._instance._init_store()
+        return cls._instance
+
+    def __getitem__(self, name):
+        with self.lock:
+            return self.data[name]
+
+    def __iter__(self):
+        with self.lock:
+            return iter(self.data)
+
+    def keys(self):
+        with self.lock:
+            return self.data.keys()
+
+    def items(self):
+        with self.lock:
+            return self.data.items()
+
+    def values(self):
+        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
+
+    def remove(self, key):
+        self._remove(key)
+
+    def _remove(self, key):
+        with self.lock:
+            try:
+                del self.data[key]
+            except KeyError:
+                pass
+
+
+# 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)

aprsd/packets/watch_list.py

@@ -0,0 +1,122 @@
+import datetime
+import logging
+
+from oslo_config import cfg
+
+from aprsd import utils
+from aprsd.packets import collector, core
+from aprsd.utils import objectstore
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class WatchList(objectstore.ObjectStoreMixin):
+    """Global watch list and info for callsigns."""
+
+    _instance = None
+    data = {}
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        super().__init__()
+        self._update_from_conf()
+
+    def _update_from_conf(self, config=None):
+        with self.lock:
+            if CONF.watch_list.enabled and CONF.watch_list.callsigns:
+                for callsign in CONF.watch_list.callsigns:
+                    call = callsign.replace("*", "")
+                    # FIXME(waboring) - we should fetch the last time we saw
+                    # a beacon from a callsign or some other mechanism to find
+                    # last time a message was seen by aprs-is.  For now this
+                    # is all we can do.
+                    if call not in self.data:
+                        self.data[call] = {
+                            "last": None,
+                            "packet": None,
+                        }
+
+    def stats(self, serializable=False) -> dict:
+        stats = {}
+        with self.lock:
+            for callsign in self.data:
+                stats[callsign] = {
+                    "last": self.data[callsign]["last"],
+                    "packet": self.data[callsign]["packet"],
+                    "age": self.age(callsign),
+                    "old": self.is_old(callsign),
+                }
+        return stats
+
+    def is_enabled(self):
+        return CONF.watch_list.enabled
+
+    def callsign_in_watchlist(self, callsign):
+        with self.lock:
+            return callsign in self.data
+
+    def rx(self, packet: type[core.Packet]) -> None:
+        """Track when we got a packet from the network."""
+        callsign = packet.from_call
+
+        if self.callsign_in_watchlist(callsign):
+            with self.lock:
+                self.data[callsign]["last"] = datetime.datetime.now()
+                self.data[callsign]["packet"] = packet
+
+    def tx(self, packet: type[core.Packet]) -> None:
+        """We don't care about TX packets."""
+
+    def last_seen(self, callsign):
+        with self.lock:
+            if self.callsign_in_watchlist(callsign):
+                return self.data[callsign]["last"]
+
+    def age(self, callsign):
+        now = datetime.datetime.now()
+        last_seen_time = self.last_seen(callsign)
+        if last_seen_time:
+            return str(now - last_seen_time)
+        else:
+            return None
+
+    def max_delta(self, seconds=None):
+        if not seconds:
+            seconds = CONF.watch_list.alert_time_seconds
+        max_timeout = {"seconds": seconds}
+        return datetime.timedelta(**max_timeout)
+
+    def is_old(self, callsign, seconds=None):
+        """Watch list callsign last seen is old compared to now?
+
+        This tests to see if the last time we saw a callsign packet,
+        if that is older than the allowed timeout in the config.
+
+        We put this here so any notification plugin can use this
+        same test.
+        """
+        if not self.callsign_in_watchlist(callsign):
+            return False
+
+        age = self.age(callsign)
+        if age:
+            delta = utils.parse_delta_str(age)
+            d = datetime.timedelta(**delta)
+
+            max_delta = self.max_delta(seconds=seconds)
+
+            if d > max_delta:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+
+collector.PacketCollector().register(WatchList)