aprsd 1.0.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

aprsd/threads/stats.py

@@ -0,0 +1,44 @@
+import logging
+import threading
+import time
+
+from oslo_config import cfg
+import wrapt
+
+from aprsd.stats import collector
+from aprsd.threads import APRSDThread
+from aprsd.utils import objectstore
+
+
+CONF = cfg.CONF
+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
+
+
+class APRSDStatsStoreThread(APRSDThread):
+    """Save APRSD Stats to disk periodically."""
+
+    # how often in seconds to write the file
+    save_interval = 10
+
+    def __init__(self):
+        super().__init__("StatsStore")
+
+    def loop(self):
+        if self.loop_count % self.save_interval == 0:
+            stats = collector.Collector().collect()
+            ss = StatsStore()
+            ss.add(stats)
+            ss.save()
+
+        time.sleep(1)
+        return True

aprsd/threads/tx.py

@@ -0,0 +1,255 @@
+import logging
+import threading
+import time
+
+from oslo_config import cfg
+from rush import quota, throttle
+from rush.contrib import decorator
+from rush.limiters import periodic
+from rush.stores import dictionary
+import wrapt
+
+from aprsd import conf  # noqa
+from aprsd import threads as aprsd_threads
+from aprsd.client import client_factory
+from aprsd.packets import collector, core
+from aprsd.packets import log as packet_log
+from aprsd.packets import tracker
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+msg_t = throttle.Throttle(
+    limiter=periodic.PeriodicLimiter(
+        store=dictionary.DictionaryStore(),
+    ),
+    rate=quota.Quota.per_second(
+        count=CONF.msg_rate_limit_period,
+    ),
+)
+ack_t = throttle.Throttle(
+    limiter=periodic.PeriodicLimiter(
+        store=dictionary.DictionaryStore(),
+    ),
+    rate=quota.Quota.per_second(
+        count=CONF.ack_rate_limit_period,
+    ),
+)
+
+msg_throttle_decorator = decorator.ThrottleDecorator(throttle=msg_t)
+ack_throttle_decorator = decorator.ThrottleDecorator(throttle=ack_t)
+s_lock = threading.Lock()
+
+
+@wrapt.synchronized(s_lock)
+@msg_throttle_decorator.sleep_and_retry
+def send(packet: core.Packet, direct=False, aprs_client=None):
+    """Send a packet either in a thread or directly to the client."""
+    # prepare the packet for sending.
+    # This constructs the packet.raw
+    packet.prepare()
+    # Have to call the collector to track the packet
+    # After prepare, as prepare assigns the msgNo
+    collector.PacketCollector().tx(packet)
+    if isinstance(packet, core.AckPacket):
+        _send_ack(packet, direct=direct, aprs_client=aprs_client)
+    else:
+        _send_packet(packet, direct=direct, aprs_client=aprs_client)
+
+
+@msg_throttle_decorator.sleep_and_retry
+def _send_packet(packet: core.Packet, direct=False, aprs_client=None):
+    if not direct:
+        thread = SendPacketThread(packet=packet)
+        thread.start()
+    else:
+        _send_direct(packet, aprs_client=aprs_client)
+
+
+@ack_throttle_decorator.sleep_and_retry
+def _send_ack(packet: core.AckPacket, direct=False, aprs_client=None):
+    if not direct:
+        thread = SendAckThread(packet=packet)
+        thread.start()
+    else:
+        _send_direct(packet, aprs_client=aprs_client)
+
+
+def _send_direct(packet, aprs_client=None):
+    if aprs_client:
+        cl = aprs_client
+    else:
+        cl = client_factory.create()
+
+    packet.update_timestamp()
+    packet_log.log(packet, tx=True)
+    try:
+        cl.send(packet)
+    except Exception as e:
+        LOG.error(f"Failed to send packet: {packet}")
+        LOG.error(e)
+
+
+class SendPacketThread(aprsd_threads.APRSDThread):
+    loop_count: int = 1
+
+    def __init__(self, packet):
+        self.packet = packet
+        super().__init__(f"TX-{packet.to_call}-{self.packet.msgNo}")
+
+    def loop(self):
+        """Loop until a message is acked or it gets delayed.
+
+        We only sleep for 5 seconds between each loop run, so
+        that CTRL-C can exit the app in a short period.  Each sleep
+        means the app quitting is blocked until sleep is done.
+        So we keep track of the last send attempt and only send if the
+        last send attempt is old enough.
+
+        """
+        pkt_tracker = tracker.PacketTrack()
+        # lets see if the message is still in the tracking queue
+        packet = pkt_tracker.get(self.packet.msgNo)
+        if not packet:
+            # The message has been removed from the tracking queue
+            # So it got acked and we are done.
+            LOG.info(
+                f"{self.packet.__class__.__name__}"
+                f"({self.packet.msgNo}) "
+                "Message Send Complete via Ack.",
+            )
+            return False
+        else:
+            send_now = False
+            if packet.send_count >= packet.retry_count:
+                # we reached the send limit, don't send again
+                # TODO(hemna) - Need to put this in a delayed queue?
+                LOG.info(
+                    f"{packet.__class__.__name__} "
+                    f"({packet.msgNo}) "
+                    "Message Send Complete. Max attempts reached"
+                    f" {packet.retry_count}",
+                )
+                pkt_tracker.remove(packet.msgNo)
+                return False
+
+            # Message is still outstanding and needs to be acked.
+            if packet.last_send_time:
+                # Message has a last send time tracking
+                now = int(round(time.time()))
+                sleeptime = (packet.send_count + 1) * 31
+                delta = now - packet.last_send_time
+                if delta > sleeptime:
+                    # It's time to try to send it again
+                    send_now = True
+            else:
+                send_now = True
+
+            if send_now:
+                # no attempt time, so lets send it, and start
+                # tracking the time.
+                packet.last_send_time = int(round(time.time()))
+                _send_direct(packet)
+                packet.send_count += 1
+
+            time.sleep(1)
+            # Make sure we get called again.
+            self.loop_count += 1
+            return True
+
+
+class SendAckThread(aprsd_threads.APRSDThread):
+    loop_count: int = 1
+    max_retries = 3
+
+    def __init__(self, packet):
+        self.packet = packet
+        super().__init__(f"TXAck-{packet.to_call}-{self.packet.msgNo}")
+        self.max_retries = CONF.default_ack_send_count
+
+    def loop(self):
+        """Separate thread to send acks with retries."""
+        send_now = False
+        if self.packet.send_count == self.max_retries:
+            # we reached the send limit, don't send again
+            # TODO(hemna) - Need to put this in a delayed queue?
+            LOG.debug(
+                f"{self.packet.__class__.__name__}"
+                f"({self.packet.msgNo}) "
+                "Send Complete. Max attempts reached"
+                f" {self.max_retries}",
+            )
+            return False
+
+        if self.packet.last_send_time:
+            # Message has a last send time tracking
+            now = int(round(time.time()))
+
+            # aprs duplicate detection is 30 secs?
+            # (21 only sends first, 28 skips middle)
+            sleep_time = 31
+            delta = now - self.packet.last_send_time
+            if delta > sleep_time:
+                # It's time to try to send it again
+                send_now = True
+            elif self.loop_count % 10 == 0:
+                LOG.debug(f"Still wating. {delta}")
+        else:
+            send_now = True
+
+        if send_now:
+            _send_direct(self.packet)
+            self.packet.send_count += 1
+            self.packet.last_send_time = int(round(time.time()))
+
+        time.sleep(1)
+        self.loop_count += 1
+        return True
+
+
+class BeaconSendThread(aprsd_threads.APRSDThread):
+    """Thread that sends a GPS beacon packet periodically.
+
+    Settings are in the [DEFAULT] section of the config file.
+    """
+    _loop_cnt: int = 1
+
+    def __init__(self):
+        super().__init__("BeaconSendThread")
+        self._loop_cnt = 1
+        # Make sure Latitude and Longitude are set.
+        if not CONF.latitude or not CONF.longitude:
+            LOG.error(
+                "Latitude and Longitude are not set in the config file."
+                "Beacon will not be sent and thread is STOPPED.",
+            )
+            self.stop()
+        LOG.info(
+            "Beacon thread is running and will send "
+            f"beacons every {CONF.beacon_interval} seconds.",
+        )
+
+    def loop(self):
+        # Only dump out the stats every N seconds
+        if self._loop_cnt % CONF.beacon_interval == 0:
+            pkt = core.BeaconPacket(
+                from_call=CONF.callsign,
+                to_call="APRS",
+                latitude=float(CONF.latitude),
+                longitude=float(CONF.longitude),
+                comment="APRSD GPS Beacon",
+                symbol=CONF.beacon_symbol,
+            )
+            try:
+                # Only send it once
+                pkt.retry_count = 1
+                send(pkt, direct=True)
+            except Exception as e:
+                LOG.error(f"Failed to send beacon: {e}")
+                client_factory.create().reset()
+                time.sleep(5)
+
+        self._loop_cnt += 1
+        time.sleep(1)
+        return True

aprsd/utils/__init__.py

@@ -0,0 +1,218 @@
+"""Utilities and helper functions."""
+
+import errno
+import functools
+import math
+import os
+import re
+import sys
+import traceback
+
+import update_checker
+
+import aprsd
+
+from .fuzzyclock import fuzzy  # noqa: F401
+# Make these available by anyone importing
+# aprsd.utils
+from .ring_buffer import RingBuffer  # noqa: F401
+
+
+if sys.version_info.major == 3 and sys.version_info.minor >= 3:
+    from collections.abc import MutableMapping
+else:
+    from collections.abc import MutableMapping
+
+
+def singleton(cls):
+    """Make a class a Singleton class (only one instance)"""
+    @functools.wraps(cls)
+    def wrapper_singleton(*args, **kwargs):
+        if wrapper_singleton.instance is None:
+            wrapper_singleton.instance = cls(*args, **kwargs)
+        return wrapper_singleton.instance
+    wrapper_singleton.instance = None
+    return wrapper_singleton
+
+
+def env(*vars, **kwargs):
+    """This returns the first environment variable set.
+    if none are non-empty, defaults to '' or keyword arg default
+    """
+    for v in vars:
+        value = os.environ.get(v, None)
+        if value:
+            return value
+    return kwargs.get("default", "")
+
+
+def mkdir_p(path):
+    """Make directory and have it work in py2 and py3."""
+    try:
+        os.makedirs(path)
+    except OSError as exc:  # Python >= 2.5
+        if exc.errno == errno.EEXIST and os.path.isdir(path):
+            pass
+        else:
+            raise
+
+
+def insert_str(string, str_to_insert, index):
+    return string[:index] + str_to_insert + string[index:]
+
+
+def end_substr(original, substr):
+    """Get the index of the end of the <substr>.
+
+    So you can insert a string after <substr>
+    """
+    idx = original.find(substr)
+    if idx != -1:
+        idx += len(substr)
+    return idx
+
+
+def rgb_from_name(name):
+    """Create an rgb tuple from a string."""
+    hash = 0
+    for char in name:
+        hash = ord(char) + ((hash << 5) - hash)
+    red = hash & 255
+    green = (hash >> 8) & 255
+    blue = (hash >> 16) & 255
+    return red, green, blue
+
+
+def hextriplet(colortuple):
+    """Convert a color tuple to a hex triplet."""
+    return "#" + "".join(f"{i:02X}" for i in colortuple)
+
+
+def hex_from_name(name):
+    """Create a hex color from a string."""
+    return hextriplet(rgb_from_name(name))
+
+
+def human_size(bytes, units=None):
+    """Returns a human readable string representation of bytes"""
+    if not units:
+        units = [" bytes", "KB", "MB", "GB", "TB", "PB", "EB"]
+    return str(bytes) + units[0] if bytes < 1024 else human_size(bytes >> 10, units[1:])
+
+
+def strfdelta(tdelta, fmt="{hours:{width}}:{minutes:{width}}:{seconds:{width}}"):
+    d = {
+        "days": tdelta.days,
+        "width": "02",
+    }
+    if tdelta.days > 0:
+        fmt = "{days} days " + fmt
+
+    d["hours"], rem = divmod(tdelta.seconds, 3600)
+    d["minutes"], d["seconds"] = divmod(rem, 60)
+    return fmt.format(**d)
+
+
+def _check_version():
+    # check for a newer version
+    try:
+        check = update_checker.UpdateChecker()
+        result = check.check("aprsd", aprsd.__version__)
+        if result:
+            # Looks like there is an updated version.
+            return 1, result
+        else:
+            return 0, "APRSD is up to date"
+    except Exception:
+        # probably can't get in touch with pypi for some reason
+        # Lets put up an error and move on.  We might not
+        # have internet in this aprsd deployment.
+        return 1, "Couldn't check for new version of APRSD"
+
+
+def flatten_dict(d, parent_key="", sep="."):
+    """Flatten a dict to key.key.key = value."""
+    items = []
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, MutableMapping):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def parse_delta_str(s):
+    if "day" in s:
+        m = re.match(
+            r"(?P<days>[-\d]+) day[s]*, (?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d[\.\d+]*)",
+            s,
+        )
+    else:
+        m = re.match(r"(?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d[\.\d+]*)", s)
+
+    if m:
+        return {key: float(val) for key, val in m.groupdict().items()}
+    else:
+        return {}
+
+
+def load_entry_points(group):
+    """Load all extensions registered to the given entry point group"""
+    try:
+        import importlib_metadata
+    except ImportError:
+        # For python 3.10 and later
+        import importlib.metadata as importlib_metadata
+
+    eps = importlib_metadata.entry_points(group=group)
+    for ep in eps:
+        try:
+            ep.load()
+        except Exception as e:
+            print(f"Extension {ep.name} of group {group} failed to load with {e}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+
+
+def calculate_initial_compass_bearing(start, end):
+    if (type(start) != tuple) or (type(end) != tuple):  # noqa: E721
+        raise TypeError("Only tuples are supported as arguments")
+
+    lat1 = math.radians(float(start[0]))
+    lat2 = math.radians(float(end[0]))
+
+    diff_long = math.radians(float(end[1]) - float(start[1]))
+
+    x = math.sin(diff_long) * math.cos(lat2)
+    y = math.cos(lat1) * math.sin(lat2) - (
+        math.sin(lat1)
+        * math.cos(lat2) * math.cos(diff_long)
+    )
+
+    initial_bearing = math.atan2(x, y)
+
+    # Now we have the initial bearing but math.atan2 return values
+    # from -180° to + 180° which is not what we want for a compass bearing
+    # The solution is to normalize the initial bearing as shown below
+    initial_bearing = math.degrees(initial_bearing)
+    compass_bearing = (initial_bearing + 360) % 360
+
+    return compass_bearing
+
+
+def degrees_to_cardinal(bearing, full_string=False):
+    if full_string:
+        directions = [
+            "North", "North-Northeast", "Northeast", "East-Northeast", "East", "East-Southeast",
+            "Southeast", "South-Southeast", "South", "South-Southwest", "Southwest", "West-Southwest",
+            "West", "West-Northwest", "Northwest", "North-Northwest", "North",
+        ]
+    else:
+        directions = [
+            "N", "NNE", "NE", "ENE", "E", "ESE",
+            "SE", "SSE", "S", "SSW", "SW", "WSW",
+            "W", "WNW", "NW", "NNW", "N",
+        ]
+
+    cardinal = directions[round(bearing / 22.5)]
+    return cardinal

aprsd/utils/counter.py

@@ -0,0 +1,51 @@
+from multiprocessing import RawValue
+import random
+import threading
+
+import wrapt
+
+
+MAX_PACKET_ID = 9999
+
+
+class PacketCounter:
+    """
+    Global Packet id counter class.
+
+    This is a singleton based class that keeps
+    an incrementing counter for all packets to
+    be sent.  All new Packet objects gets a new
+    message id, which is the next number available
+    from the PacketCounter.
+
+    """
+
+    _instance = None
+    lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        """Make this a singleton class."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls, *args, **kwargs)
+            cls._instance.val = RawValue("i", random.randint(1, MAX_PACKET_ID))
+        return cls._instance
+
+    @wrapt.synchronized(lock)
+    def increment(self):
+        if self.val.value == MAX_PACKET_ID:
+            self.val.value = 1
+        else:
+            self.val.value += 1
+
+    @property
+    @wrapt.synchronized(lock)
+    def value(self):
+        return str(self.val.value)
+
+    @wrapt.synchronized(lock)
+    def __repr__(self):
+        return str(self.val.value)
+
+    @wrapt.synchronized(lock)
+    def __str__(self):
+        return str(self.val.value)

aprsd/utils/json.py

@@ -0,0 +1,80 @@
+import datetime
+import decimal
+import json
+import sys
+
+from aprsd.packets import core
+
+
+class EnhancedJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime.datetime):
+            args = (
+                "year", "month", "day", "hour", "minute",
+                "second", "microsecond",
+            )
+            return {
+                "__type__": "datetime.datetime",
+                "args": [getattr(obj, a) for a in args],
+            }
+        elif isinstance(obj, datetime.date):
+            args = ("year", "month", "day")
+            return {
+                "__type__": "datetime.date",
+                "args": [getattr(obj, a) for a in args],
+            }
+        elif isinstance(obj, datetime.time):
+            args = ("hour", "minute", "second", "microsecond")
+            return {
+                "__type__": "datetime.time",
+                "args": [getattr(obj, a) for a in args],
+            }
+        elif isinstance(obj, datetime.timedelta):
+            args = ("days", "seconds", "microseconds")
+            return {
+                "__type__": "datetime.timedelta",
+                "args": [getattr(obj, a) for a in args],
+            }
+        elif isinstance(obj, decimal.Decimal):
+            return {
+                "__type__": "decimal.Decimal",
+                "args": [str(obj)],
+            }
+        else:
+            return super().default(obj)
+
+
+class SimpleJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime.datetime):
+            return obj.isoformat()
+        elif isinstance(obj, datetime.date):
+            return str(obj)
+        elif isinstance(obj, datetime.time):
+            return str(obj)
+        elif isinstance(obj, datetime.timedelta):
+            return str(obj)
+        elif isinstance(obj, decimal.Decimal):
+            return str(obj)
+        elif isinstance(obj, core.Packet):
+            return obj.to_dict()
+        else:
+            return super().default(obj)
+
+
+class EnhancedJSONDecoder(json.JSONDecoder):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args, object_hook=self.object_hook,
+            **kwargs,
+        )
+
+    def object_hook(self, d):
+        if "__type__" not in d:
+            return d
+        o = sys.modules[__name__]
+        for e in d["__type__"].split("."):
+            o = getattr(o, e)
+        args, kwargs = d.get("args", ()), d.get("kwargs", {})
+        return o(*args, **kwargs)