aprsd 3.2.2__py2.py3-none-any.whl → 3.3.1__py2.py3-none-any.whl

aprsd/cmds/webchat.py

@@ -1,7 +1,7 @@
 import datetime
 import json
 import logging
-from logging.handlers import RotatingFileHandler
+import math
 import signal
 import sys
 import threading
@@ -11,17 +11,20 @@ from aprslib import util as aprslib_util
 import click
 import flask
 from flask import request
-from flask.logging import default_handler
 from flask_httpauth import HTTPBasicAuth
 from flask_socketio import Namespace, SocketIO
+from geopy.distance import geodesic
 from oslo_config import cfg
 from werkzeug.security import check_password_hash, generate_password_hash
 import wrapt
 
 import aprsd
-from aprsd import cli_helper, client, conf, packets, stats, threads, utils
-from aprsd.log import rich as aprsd_logging
+from aprsd import (
+    cli_helper, client, packets, plugin_utils, stats, threads, utils,
+)
+from aprsd.log import log
 from aprsd.main import cli
+from aprsd.threads import aprsd as aprsd_threads
 from aprsd.threads import rx, tx
 from aprsd.utils import trace
 
@@ -32,6 +35,16 @@ auth = HTTPBasicAuth()
 users = {}
 socketio = None
 
+# List of callsigns that we don't want to track/fetch their location
+callsign_no_track = [
+    "REPEAT", "WB4BOR-11", "APDW16", "WXNOW", "WXBOT", "BLN0", "BLN1", "BLN2",
+    "BLN3", "BLN4", "BLN5", "BLN6", "BLN7", "BLN8", "BLN9",
+]
+
+# Callsign location information
+# callsign: {lat: 0.0, long: 0.0, last_update: datetime}
+callsign_locations = {}
+
 flask_app = flask.Flask(
     "aprsd",
     static_url_path="/static",
@@ -121,8 +134,188 @@ def verify_password(username, password):
         return username
 
 
+def calculate_initial_compass_bearing(point_a, point_b):
+    """
+    Calculates the bearing between two points.
+    The formulae used is the following:
+        θ = atan2(sin(Δlong).cos(lat2),
+                  cos(lat1).sin(lat2) − sin(lat1).cos(lat2).cos(Δlong))
+    :Parameters:
+      - `pointA: The tuple representing the latitude/longitude for the
+        first point. Latitude and longitude must be in decimal degrees
+      - `pointB: The tuple representing the latitude/longitude for the
+        second point. Latitude and longitude must be in decimal degrees
+    :Returns:
+      The bearing in degrees
+    :Returns Type:
+      float
+    """
+    if (type(point_a) is not tuple) or (type(point_b) is not tuple):
+        raise TypeError("Only tuples are supported as arguments")
+
+    lat1 = math.radians(point_a[0])
+    lat2 = math.radians(point_b[0])
+
+    diff_long = math.radians(point_b[1] - point_a[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 _build_location_from_repeat(message):
+    # This is a location message Format is
+    # ^ld^callsign:latitude,longitude,altitude,course,speed,timestamp
+    a = message.split(":")
+    LOG.warning(a)
+    if len(a) == 2:
+        callsign = a[0].replace("^ld^", "")
+        b = a[1].split(",")
+        LOG.warning(b)
+        if len(b) == 6:
+            lat = float(b[0])
+            lon = float(b[1])
+            alt = float(b[2])
+            course = float(b[3])
+            speed = float(b[4])
+            time = int(b[5])
+            data = {
+                "callsign": callsign,
+                "lat": lat,
+                "lon": lon,
+                "altitude": alt,
+                "course": course,
+                "speed": speed,
+                "lasttime": time,
+            }
+            LOG.warning(f"Location data from REPEAT {data}")
+            return data
+
+
+def _calculate_location_data(location_data):
+    """Calculate all of the location data from data from aprs.fi or REPEAT."""
+    lat = location_data["lat"]
+    lon = location_data["lon"]
+    alt = location_data["altitude"]
+    speed = location_data["speed"]
+    lasttime = location_data["lasttime"]
+    # now calculate distance from our own location
+    distance = 0
+    if CONF.webchat.latitude and CONF.webchat.longitude:
+        our_lat = float(CONF.webchat.latitude)
+        our_lon = float(CONF.webchat.longitude)
+        distance = geodesic((our_lat, our_lon), (lat, lon)).kilometers
+        bearing = calculate_initial_compass_bearing(
+            (our_lat, our_lon),
+            (lat, lon),
+        )
+    return {
+        "callsign": location_data["callsign"],
+        "lat": lat,
+        "lon": lon,
+        "altitude": alt,
+        "course": f"{bearing:0.1f}",
+        "speed": speed,
+        "lasttime": lasttime,
+        "distance": f"{distance:0.3f}",
+    }
+
+
+def send_location_data_to_browser(location_data):
+    global socketio
+    callsign = location_data["callsign"]
+    LOG.info(f"Got location for {callsign} {callsign_locations[callsign]}")
+    socketio.emit(
+        "callsign_location", callsign_locations[callsign],
+        namespace="/sendmsg",
+    )
+
+
+def populate_callsign_location(callsign, data=None):
+    """Populate the location for the callsign.
+
+       if data is passed in, then we have the location already from
+       an APRS packet.  If data is None, then we need to fetch the
+       location from aprs.fi or REPEAT.
+    """
+    global socketio
+    """Fetch the location for the callsign."""
+    LOG.debug(f"populate_callsign_location {callsign}")
+    if data:
+        location_data = _calculate_location_data(data)
+        callsign_locations[callsign] = location_data
+        send_location_data_to_browser(location_data)
+        return
+
+    # First we are going to try to get the location from aprs.fi
+    # if there is no internets, then this will fail and we will
+    # fallback to calling REPEAT for the location for the callsign.
+    fallback = False
+    if not CONF.aprs_fi.apiKey:
+        LOG.warning(
+            "Config aprs_fi.apiKey is not set. Can't get location from aprs.fi "
+            " falling back to sending REPEAT to get location.",
+        )
+        fallback = True
+    else:
+        try:
+            aprs_data = plugin_utils.get_aprs_fi(CONF.aprs_fi.apiKey, callsign)
+            if not len(aprs_data["entries"]):
+                LOG.error("Didn't get any entries from aprs.fi")
+                return
+            lat = float(aprs_data["entries"][0]["lat"])
+            lon = float(aprs_data["entries"][0]["lng"])
+            try:  # altitude not always provided
+                alt = float(aprs_data["entries"][0]["altitude"])
+            except Exception:
+                alt = 0
+            location_data = {
+                "callsign": callsign,
+                "lat": lat,
+                "lon": lon,
+                "altitude": alt,
+                "lasttime": int(aprs_data["entries"][0]["lasttime"]),
+                "course": float(aprs_data["entries"][0].get("course", 0)),
+                "speed": float(aprs_data["entries"][0].get("speed", 0)),
+            }
+            location_data = _calculate_location_data(location_data)
+            callsign_locations[callsign] = location_data
+            send_location_data_to_browser(location_data)
+            return
+        except Exception as ex:
+            LOG.error(f"Failed to fetch aprs.fi '{ex}'")
+            LOG.error(ex)
+            fallback = True
+
+    if fallback:
+        # We don't have the location data
+        # and we can't get it from aprs.fi
+        # Send a special message to REPEAT to get the location data
+        LOG.info(f"Sending REPEAT to get location for callsign {callsign}.")
+        tx.send(
+            packets.MessagePacket(
+                from_call=CONF.callsign,
+                to_call="REPEAT",
+                message_text=f"ld {callsign}",
+            ),
+        )
+
+
 class WebChatProcessPacketThread(rx.APRSDProcessPacketThread):
     """Class that handles packets being sent to us."""
+
     def __init__(self, packet_queue, socketio):
         self.socketio = socketio
         self.connected = False
@@ -132,20 +325,53 @@ class WebChatProcessPacketThread(rx.APRSDProcessPacketThread):
         super().process_ack_packet(packet)
         ack_num = packet.get("msgNo")
         SentMessages().ack(ack_num)
-        self.socketio.emit(
-            "ack", SentMessages().get(ack_num),
-            namespace="/sendmsg",
-        )
+        msg = SentMessages().get(ack_num)
+        if msg:
+            self.socketio.emit(
+                "ack", msg,
+                namespace="/sendmsg",
+            )
         self.got_ack = True
 
     def process_our_message_packet(self, packet: packets.MessagePacket):
+        global callsign_locations
         LOG.info(f"process MessagePacket {repr(packet)}")
+        # ok lets see if we have the location for the
+        # person we just sent a message to.
+        from_call = packet.get("from_call").upper()
+        if from_call == "REPEAT":
+            # We got a message from REPEAT.  Is this a location message?
+            message = packet.get("message_text")
+            if message.startswith("^ld^"):
+                location_data = _build_location_from_repeat(message)
+                callsign = location_data["callsign"]
+                location_data = _calculate_location_data(location_data)
+                callsign_locations[callsign] = location_data
+                send_location_data_to_browser(location_data)
+                return
+        elif (
+            from_call not in callsign_locations
+            and from_call not in callsign_no_track
+        ):
+            # We have to ask aprs for the location for the callsign
+            # We send a message packet to wb4bor-11 asking for location.
+            populate_callsign_location(from_call)
+        # Send the packet to the browser.
         self.socketio.emit(
             "new", packet.__dict__,
             namespace="/sendmsg",
         )
 
 
+class LocationProcessingThread(aprsd_threads.APRSDThread):
+    """Class to handle the location processing."""
+    def __init__(self):
+        super().__init__("LocationProcessingThread")
+
+    def loop(self):
+        pass
+
+
 def set_config():
     global users
 
@@ -181,6 +407,12 @@ def _get_transport(stats):
     return transport, aprs_connection
 
 
+@flask_app.route("/location/<callsign>", methods=["POST"])
+def location(callsign):
+    LOG.debug(f"Fetch location for callsign {callsign}")
+    populate_callsign_location(callsign)
+
+
 @auth.login_required
 @flask_app.route("/")
 def index():
@@ -216,7 +448,7 @@ def index():
 
 
 @auth.login_required
-@flask_app.route("//send-message-status")
+@flask_app.route("/send-message-status")
 def send_message_status():
     LOG.debug(request)
     msgs = SentMessages()
@@ -331,53 +563,21 @@ class SendMessageNamespace(Namespace):
     def handle_json(self, data):
         LOG.debug(f"WS json {data}")
 
-
-def setup_logging(flask_app, loglevel, quiet):
-    flask_log = logging.getLogger("werkzeug")
-    flask_app.logger.removeHandler(default_handler)
-    flask_log.removeHandler(default_handler)
-
-    log_level = conf.log.LOG_LEVELS[loglevel]
-    flask_log.setLevel(log_level)
-    date_format = CONF.logging.date_format
-
-    if CONF.logging.rich_logging and not quiet:
-        log_format = "%(message)s"
-        log_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
-        rh = aprsd_logging.APRSDRichHandler(
-            show_thread=True, thread_width=15,
-            rich_tracebacks=True, omit_repeated_times=False,
-        )
-        rh.setFormatter(log_formatter)
-        flask_log.addHandler(rh)
-
-    log_file = CONF.logging.logfile
-
-    if log_file:
-        log_format = CONF.logging.logformat
-        log_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
-        fh = RotatingFileHandler(
-            log_file, maxBytes=(10248576 * 5),
-            backupCount=4,
-        )
-        fh.setFormatter(log_formatter)
-        flask_log.addHandler(fh)
+    def on_get_callsign_location(self, data):
+        LOG.debug(f"on_callsign_location {data}")
+        populate_callsign_location(data["callsign"])
 
 
 @trace.trace
 def init_flask(loglevel, quiet):
     global socketio, flask_app
 
-    setup_logging(flask_app, loglevel, quiet)
+    log.setup_logging(loglevel, quiet)
 
     socketio = SocketIO(
         flask_app, logger=False, engineio_logger=False,
         async_mode="threading",
     )
-    # async_mode="gevent",
-    # async_mode="eventlet",
-    #    import eventlet
-    #    eventlet.monkey_patch()
 
     socketio.on_namespace(
         SendMessageNamespace(

aprsd/conf/common.py

@@ -24,6 +24,11 @@ webchat_group = cfg.OptGroup(
     title="Settings specific to the webchat command",
 )
 
+registry_group = cfg.OptGroup(
+    name="aprs_registry",
+    title="APRS Registry settings",
+)
+
 
 aprsd_opts = [
     cfg.StrOpt(
@@ -67,9 +72,35 @@ aprsd_opts = [
     ),
     cfg.IntOpt(
         "packet_dupe_timeout",
-        default=60,
+        default=300,
         help="The number of seconds before a packet is not considered a duplicate.",
     ),
+    cfg.BoolOpt(
+        "enable_beacon",
+        default=False,
+        help="Enable sending of a GPS Beacon packet to locate this service. "
+             "Requires latitude and longitude to be set.",
+    ),
+    cfg.IntOpt(
+        "beacon_interval",
+        default=1800,
+        help="The number of seconds between beacon packets.",
+    ),
+    cfg.StrOpt(
+        "beacon_symbol",
+        default="/",
+        help="The symbol to use for the GPS Beacon packet. See: http://www.aprs.net/vm/DOS/SYMBOLS.HTM",
+    ),
+    cfg.StrOpt(
+        "latitude",
+        default=None,
+        help="Latitude for the GPS Beacon button.  If not set, the button will not be enabled.",
+    ),
+    cfg.StrOpt(
+        "longitude",
+        default=None,
+        help="Longitude for the GPS Beacon button.  If not set, the button will not be enabled.",
+    ),
 ]
 
 watch_list_opts = [
@@ -196,6 +227,39 @@ webchat_opts = [
     ),
 ]
 
+registry_opts = [
+    cfg.StrOpt(
+        "enabled",
+        default=False,
+        help="Enable sending aprs registry information.  This will let the "
+             "APRS registry know about your service and it's uptime.  "
+             "No personal information is sent, just the callsign, uptime and description. "
+             "The service callsign is the callsign set in [DEFAULT] section.",
+    ),
+    cfg.StrOpt(
+        "description",
+        default=None,
+        help="Description of the service to send to the APRS registry. "
+             "This is what will show up in the APRS registry."
+             "If not set, the description will be the same as the callsign.",
+    ),
+    cfg.StrOpt(
+        "registry_url",
+        default="https://aprs.hemna.com/api/v1/registry",
+        help="The APRS registry domain name to send the information to.",
+    ),
+    cfg.StrOpt(
+        "service_website",
+        default=None,
+        help="The website for your APRS service to send to the APRS registry.",
+    ),
+    cfg.IntOpt(
+        "frequency_seconds",
+        default=3600,
+        help="The frequency in seconds to send the APRS registry information.",
+    ),
+]
+
 
 def register_opts(config):
     config.register_opts(aprsd_opts)
@@ -208,6 +272,8 @@ def register_opts(config):
     config.register_opts(rpc_opts, group=rpc_group)
     config.register_group(webchat_group)
     config.register_opts(webchat_opts, group=webchat_group)
+    config.register_group(registry_group)
+    config.register_opts(registry_opts, group=registry_group)
 
 
 def list_opts():
@@ -217,4 +283,5 @@ def list_opts():
         watch_list_group.name: watch_list_opts,
         rpc_group.name: rpc_opts,
         webchat_group.name: webchat_opts,
+        registry_group.name: registry_opts,
     }

aprsd/conf/log.py

@@ -20,21 +20,19 @@ DEFAULT_LOG_FORMAT = (
     " %(message)s - [%(pathname)s:%(lineno)d]"
 )
 
+DEFAULT_LOG_FORMAT = (
+    "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+    "<yellow>{thread.name: <18}</yellow> | "
+    "<level>{level: <8}</level> | "
+    "<level>{message}</level> | "
+    "<cyan>{name}</cyan>:<cyan>{function:}</cyan>:<magenta>{line:}</magenta>"
+)
+
 logging_group = cfg.OptGroup(
     name="logging",
     title="Logging options",
 )
 logging_opts = [
-    cfg.StrOpt(
-        "date_format",
-        default=DEFAULT_DATE_FORMAT,
-        help="Date format for log entries",
-    ),
-    cfg.BoolOpt(
-        "rich_logging",
-        default=True,
-        help="Enable Rich log",
-    ),
     cfg.StrOpt(
         "logfile",
         default=None,

aprsd/conf/plugin_common.py

@@ -18,6 +18,11 @@ owm_wx_group = cfg.OptGroup(
     title="Options for the OWMWeatherPlugin",
 )
 
+location_group = cfg.OptGroup(
+    name="location_plugin",
+    title="Options for the LocationPlugin",
+)
+
 aprsfi_opts = [
     cfg.StrOpt(
         "apiKey",
@@ -62,6 +67,106 @@ avwx_opts = [
     ),
 ]
 
+location_opts = [
+    cfg.StrOpt(
+        "geopy_geocoder",
+        choices=[
+            "ArcGIS", "AzureMaps", "Baidu", "Bing", "GoogleV3", "HERE",
+            "Nominatim", "OpenCage", "TomTom", "USGov", "What3Words", "Woosmap",
+        ],
+        default="Nominatim",
+        help="The geopy geocoder to use.  Default is Nominatim."
+             "See https://geopy.readthedocs.io/en/stable/#module-geopy.geocoders"
+             "for more information.",
+    ),
+    cfg.StrOpt(
+        "user_agent",
+        default="APRSD",
+        help="The user agent to use for the Nominatim geocoder."
+             "See https://geopy.readthedocs.io/en/stable/#module-geopy.geocoders"
+             "for more information.",
+    ),
+    cfg.StrOpt(
+        "arcgis_username",
+        default=None,
+        help="The username to use for the ArcGIS geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#arcgis"
+             "for more information."
+             "Only used for the ArcGIS geocoder.",
+    ),
+    cfg.StrOpt(
+        "arcgis_password",
+        default=None,
+        help="The password to use for the ArcGIS geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#arcgis"
+             "for more information."
+             "Only used for the ArcGIS geocoder.",
+    ),
+    cfg.StrOpt(
+        "azuremaps_subscription_key",
+        help="The subscription key to use for the AzureMaps geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#azuremaps"
+             "for more information."
+             "Only used for the AzureMaps geocoder.",
+    ),
+    cfg.StrOpt(
+        "baidu_api_key",
+        help="The API key to use for the Baidu geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#baidu"
+             "for more information."
+             "Only used for the Baidu geocoder.",
+    ),
+    cfg.StrOpt(
+        "bing_api_key",
+        help="The API key to use for the Bing geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#bing"
+             "for more information."
+             "Only used for the Bing geocoder.",
+    ),
+    cfg.StrOpt(
+        "google_api_key",
+        help="The API key to use for the Google geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#googlev3"
+             "for more information."
+             "Only used for the Google geocoder.",
+    ),
+    cfg.StrOpt(
+        "here_api_key",
+        help="The API key to use for the HERE geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#here"
+             "for more information."
+             "Only used for the HERE geocoder.",
+    ),
+    cfg.StrOpt(
+        "opencage_api_key",
+        help="The API key to use for the OpenCage geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#opencage"
+             "for more information."
+             "Only used for the OpenCage geocoder.",
+    ),
+    cfg.StrOpt(
+        "tomtom_api_key",
+        help="The API key to use for the TomTom geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#tomtom"
+             "for more information."
+             "Only used for the TomTom geocoder.",
+    ),
+    cfg.StrOpt(
+        "what3words_api_key",
+        help="The API key to use for the What3Words geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#what3words"
+             "for more information."
+             "Only used for the What3Words geocoder.",
+    ),
+    cfg.StrOpt(
+        "woosmap_api_key",
+        help="The API key to use for the Woosmap geocoder."
+             "See https://geopy.readthedocs.io/en/latest/#woosmap"
+             "for more information."
+             "Only used for the Woosmap geocoder.",
+    ),
+]
+
 
 def register_opts(config):
     config.register_group(aprsfi_group)
@@ -72,6 +177,8 @@ def register_opts(config):
     config.register_opts(owm_wx_opts, group=owm_wx_group)
     config.register_group(avwx_group)
     config.register_opts(avwx_opts, group=avwx_group)
+    config.register_group(location_group)
+    config.register_opts(location_opts, group=location_group)
 
 
 def list_opts():
@@ -80,4 +187,5 @@ def list_opts():
         query_group.name: query_plugin_opts,
         owm_wx_group.name: owm_wx_opts,
         avwx_group.name: avwx_opts,
+        location_group.name: location_opts,
     }