Fix some IDE warnings

README.md

@@ -22,9 +22,11 @@ You can access the public version's web interface at [https://spothole.app](http
 
 This is a Progressive Web App, so you can also "install" it to your Android or iOS device by accessing it in Chrome or Safari respectively, and following the menu-driven process for installing PWAs.
 
+You are more than welcome to use the data and the API that Spothole provides to power your own software. There are many ways to do this; see below. 
+
 ## Embedding Spothole in another website
 
-You can embed Spothole in another website, e.g. for use as part of a ham radio custom dashboard.
+You can embed Spothole's web interface in another website, e.g. for use as part of a ham radio custom dashboard.
 
 URL parameters can be used to trigger an "embedded" mode which hides the headers, footers and settings. In this mode, you provide configuration for the various filter and display options via additional URL parameters. Any settings that the user has set for Spothole are ignored. This is so that the embedding site can select, for example, their choice of dark mode or SIG filters, which will not impact how Spothole appears when the user accesses it directly. Effectively, it becomes separate to their normal Spothole settings.
 
@@ -90,11 +92,9 @@ Then edit `config.yml` in your text editor of choice to set up the software as y
 
 By default, all outdoor programme providers are enabled, as is one cluster node and the NG3K DXpedition data. The RBN spot providers are turned off by default due to the volume of traffic from CW/RTTY/FT8 skimmers, and the APRS and Packet spot providers are off by default on the assumption that Spothole users want a spot with a human at the other end of it, but all can be easily re-enabled.
 
-`config.yml` has some entries for QRZ.com username & password, and Clublog API keys. If provided, these allow Spothole to retrieve more information about DX spots, such as the country their callsign corresponds to. The software will work just fine without them, but you may find a few country flags etc. are less accurate or missing.
+Other parameters you will want to update include the base URL to your instance, and whether you want to serve a full web-based DX cluster interface or just the API endpoints for client software to use.
 
-Clublog API keys are free, but you'll need to get your own by submitting a helpdesk ticket and explaining what you'll use it for. The admin team are happy with the rate of requests made by my Spothole server, so unless you change the source code of yours to radically increase the rate of querying Clublog, I'm sure they will be fine with your server too.
+`config.yml` has an entry for a Clublog API key. If provided, this will allow Spothole to retrieve some more information about DX spots. The software will work just fine without it, but you may find a few country flags etc. are less accurate or missing. Clublog API keys are free, but you'll need to get your own by submitting a helpdesk ticket and explaining what you'll use it for. The admin team are happy with the rate of requests made by my Spothole server, so unless you change the source code of yours to radically increase the rate of querying Clublog, I'm sure they will be fine with your server too.
-
-Free QRZ.com accounts offer only limited access to the site's data via their API. You'll have to sign up for one of their "XML Data Subscriber" plans to gain access to the full data, but if you're on a free account then the software will get what information it can.
 
 Once you're happy with the content of `config.yml`, you can proceed to running the software.
 
@@ -246,10 +246,6 @@ To set up nginx as a reverse proxy that sits in front of Spothole, first ensure
 Create a file at `/etc/nginx/sites-available/` called `spothole`. Give it the following contents, replacing `spothole.app` with the domain name on which you want to run Spothole. If you changed the port on which Spothole runs, update that on the "proxy_pass" line too.
 
 ```nginx
-map $request_uri $xssorigin {
-    ~^/api   *;
-}
-
 server {
     server_name spothole.app;
 
@@ -258,21 +254,55 @@ server {
         alias /var/www/html/.well-known/;
     }
     
+    # SSE endpoints
+    location ~ ^/api/v1/(spots|alerts)/stream {
+        proxy_http_version 1.1;
+        proxy_set_header Connection "";
+        proxy_pass http://127.0.0.1:8080;
+        proxy_buffering off;
+        proxy_cache off;
+        proxy_read_timeout 24h;
+        proxy_connect_timeout 10s;
+        proxy_send_timeout 24h;
+        proxy_set_header X-Accel-Buffering no;
+        proxy_hide_header Access-Control-Allow-Origin;
+        add_header Access-Control-Allow-Origin * always;
+        add_header Cache-Control no-store always;
+        add_header Content-Type text/event-stream always;
+    }
+
+    # Other API endpoints
+    location /api/ {
+        proxy_http_version 1.1;
+        proxy_set_header Connection "";
+        proxy_pass http://127.0.0.1:8080;
+        proxy_buffering on;
+        proxy_cache off;
+        proxy_read_timeout 30s;
+        proxy_connect_timeout 10s;
+        proxy_hide_header Access-Control-Allow-Origin;
+        add_header Access-Control-Allow-Origin * always;
+        add_header Cache-Control no-store always;
+    }
+
+    # Static assets
     location / {
         proxy_http_version 1.1;
         proxy_set_header Connection "";
         proxy_pass http://127.0.0.1:8080;
-        proxy_hide_header Access-Control-Allow-Origin;
+        proxy_buffering on;
-        add_header Access-Control-Allow-Origin $xssorigin;
+        proxy_read_timeout 30s;
+        proxy_connect_timeout 10s;
+        add_header Cache-Control "public, max-age=3600, must-revalidate" always;
     }
 }
 ```
 
-One further change you might want to make to the file above is the `add_header Access-Control-Allow-Origin` statement. This is what's used on
+One further change you might want to make to the file above is the `add_header Access-Control-Allow-Origin` statements. These are what's used on
 my own Spothole server to make sure that other third-party web-based software can get the data from my instance, and applies to any endpoint underneath `/api`. If you want
 *your* Spothole instance to be set up the same way, so that others can write software in JavaScript that can access it,
 leave this intact. But if you want your Spothole instance to only be usable by scripts running on the web server you write,
-you can remove this line. (Note that this doesn't stop other people writing *non-web-based* software that accesses your
+you can remove these lines. (Note that this doesn't stop other people writing *non-web-based* software that accesses your
 Spothole API—the enforcement of cross-origin headers only happens within the user's browser. If you need to lock your
 instance down so that no-one else can access it with *any* software, that's an aspect of nginx or firewall config that you will need
 to find help with elsewhere.)

alertproviders/parksnpeaks.py

@@ -12,7 +12,7 @@ class ParksNPeaks(HTTPAlertProvider):
     """Alert provider for Parks n Peaks"""
 
     POLL_INTERVAL_SEC = 1800
-    ALERTS_URL = "http://parksnpeaks.org/api/ALERTS/"
+    ALERTS_URL = "https://parksnpeaks.org/api/ALERTS/"
 
     def __init__(self, provider_config):
         super().__init__(provider_config, self.ALERTS_URL, self.POLL_INTERVAL_SEC)

config-example.yml

@@ -6,6 +6,14 @@
 # this as "N0CALL" and it shouldn't do any harm, as we're not sending anything to the various networks, only receiving.
 server-owner-callsign: "N0CALL"
 
+# Port to open the local web server on
+web-server-port: 8080
+
+# Run in API-only mode? When enabled, the web UI is not served, only the API endpoints and the OpenAPI documentation
+# page. If you are running your own Spothole instance purely to serve client software, and not wanting visitors to
+# discover a full web-based cluster UI, enable this flag.
+api-only-mode: false
+
 # The base URL at which the software runs.
 base-url: "http://localhost:8080"
 
@@ -187,9 +195,10 @@ solar-condition-providers:
     class: "GIROIonosonde"
     name: "GIRO Ionosonde Data"
     enabled: true
-
+  -
-# Port to open the local web server on
+    class: "KC2GProp"
-web-server-port: 8080
+    name: "KC2G Propagation Data"
+    enabled: true
 
 # Maximum time to keep spots and alerts in the system before deleting them. By default, one hour for spots and one week
 # for alerts.

core/config.py

@@ -21,6 +21,7 @@ SERVER_OWNER_CALLSIGN = config["server-owner-callsign"]
 WEB_SERVER_PORT = config["web-server-port"]
 ALLOW_SPOTTING = config["allow-spotting"]
 WEB_UI_OPTIONS = config["web-ui-options"]
+API_ONLY_MODE = config.get("api-only-mode", False)
 
 # For ease of config, each spot provider owns its own config about whether it should be enabled by default in the web UI
 # but for consistency we provide this to the front-end in web-ui-options because it has no impact outside of the web UI.

core/constants.py

@@ -3,12 +3,11 @@ from data.band import Band
 from data.sig import SIG
 
 # General software
-SOFTWARE_NAME = "Spothole by M0TRT"
+SOFTWARE_VERSION = "1.4-pre"
-SOFTWARE_VERSION = "1.3"
 
 # HTTP headers used for spot providers that use HTTP
-HTTP_HEADERS = {"User-Agent": SOFTWARE_NAME + ", v" + SOFTWARE_VERSION + " (operated by " + SERVER_OWNER_CALLSIGN + ")"}
+HTTP_HEADERS = {"User-Agent": "Spothole v" + SOFTWARE_VERSION + " (operated by " + SERVER_OWNER_CALLSIGN + ")"}
-HAMQTH_PRG = (SOFTWARE_NAME + " v" + SOFTWARE_VERSION + " operated by " + SERVER_OWNER_CALLSIGN).replace(" ", "_")
+HAMQTH_PRG = ("Spothole v" + SOFTWARE_VERSION + " operated by " + SERVER_OWNER_CALLSIGN).replace(" ", "_")
 
 # Special Interest Groups
 SIGS = [

core/lookup_helper.py

@@ -18,7 +18,6 @@ from core.cache_utils import SEMI_STATIC_URL_DATA_CACHE
 from core.config import config
 from core.constants import BANDS, UNKNOWN_BAND, CW_MODES, PHONE_MODES, DATA_MODES, ALL_MODES, \
     HTTP_HEADERS, HAMQTH_PRG, MODE_ALIASES
-from data.lookup_credentials import LookupCredentials
 
 # QRZ XML field names differ from pyhamtools' normalised names; map them here.
 _QRZ_FIELD_MAP = {
@@ -363,8 +362,12 @@ class LookupHelper:
         """Infer an operator name from a callsign (requires QRZ.com/HamQTH)"""
 
         data = self._get_qrz_data_for_callsign(call, credentials)
+        if data and "name_fmt" in data:
+            return data["name_fmt"]
         if data and "fname" in data:
             name = data["fname"]
+            if "nick" in data:
+                name = name + " \"" + data["nick"] + "\""
             if "name" in data:
                 name = name + " " + data["name"]
             return name

data/solar_conditions.py

@@ -161,8 +161,8 @@ class SolarConditions:
     blackout_forecast_r1r2: dict = None
     # NOAA Radio Blackout (R3 or greater) probability forecast, keyed by UNIX timestamp of start of day UTC
     blackout_forecast_r3_or_greater: dict = None
-    # Ionosonde measurements from LGDC, dict keyed by URSI code, values are dicts with keys: ursi, name, fof2, muf, luf,
+    # Ionosonde measurements, dict keyed by URSI code, values are dicts with keys: ursi, name, fof2, muf, luf,
-    # band_states
+    # band_states. Populated by GIROIonosonde or KC2GProp providers.
     ionosonde_data: dict = None
 
     # Derived values (populated by infer_descriptions())

data/spot.py

@@ -14,7 +14,6 @@ from core.constants import MODE_ALIASES
 from core.geo_utils import lat_lon_to_cq_zone, lat_lon_to_itu_zone
 from core.lookup_helper import lookup_helper, infer_band_from_freq, infer_mode_from_comment, \
     infer_mode_from_frequency, infer_mode_type_from_mode
-from data.lookup_credentials import LookupCredentials
 from core.sig_utils import populate_sig_ref_info, ANY_SIG_REGEX, get_ref_regex_for_sig
 from data.sig_ref import SIGRef
 

server/handlers/api/alerts.py

@@ -98,8 +98,12 @@ class APIAlertsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
             self._heartbeat = tornado.ioloop.PeriodicCallback(self._callback, SSE_HANDLER_QUEUE_CHECK_INTERVAL)
             self._heartbeat.start()
 
+            # Flush headers immediately so nginx doesn't time out waiting for a response
+            self.write_message("keepalive", "")
+
         except Exception as e:
-            logging.warning("Exception when serving SSE socket", e)
+            logging.warning("Exception when serving SSE socket: %s", e, exc_info=True)
+            self.close()
 
     def close(self):
         """When the user closes the socket, empty our queue and remove it from the list so the server no longer fills it"""
@@ -122,6 +126,7 @@ class APIAlertsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
 
         try:
             if self._alert_queue:
+                if not self._alert_queue.empty():
                     while not self._alert_queue.empty():
                         alert = self._alert_queue.get()
                         # If the new alert matches our param filters, send it to the client. If not, ignore it.
@@ -131,11 +136,15 @@ class APIAlertsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
                                 alert.infer_missing(self._credentials)
                             self.write_message(msg=json.dumps(alert, default=serialize_everything))
 
+                else:
+                    # Send a keepalive comment if the queue was empty
+                    self.write_message("keepalive", "")
+
                 if self._alert_queue not in self._sse_alert_queues:
                     logging.error("Web server cleared up a queue of an active connection!")
                     self.close()
-        except:
+        except Exception as e:
-            logging.warning("Exception in SSE callback, connection will be closed.")
+            logging.warning("Exception in SSE callback, connection will be closed: %s", e, exc_info=True)
             self.close()
 
 

server/handlers/api/solar_conditions.py

@@ -1,11 +1,9 @@
-import json
 from datetime import datetime
 
 import pytz
 import tornado
 
 from core.prometheus_metrics_handler import api_requests_counter
-from core.utils import serialize_everything
 
 
 class APISolarConditionsHandler(tornado.web.RequestHandler):

server/handlers/api/spots.py

@@ -100,8 +100,12 @@ class APISpotsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
             self._heartbeat = tornado.ioloop.PeriodicCallback(self._callback, SSE_HANDLER_QUEUE_CHECK_INTERVAL)
             self._heartbeat.start()
 
+            # Flush headers immediately so nginx doesn't time out waiting for a response
+            self.write_message("keepalive", "")
+
         except Exception as e:
-            logging.warning("Exception when serving SSE socket", e)
+            logging.warning("Exception when serving SSE socket: %s", e, exc_info=True)
+            self.close()
 
     def close(self):
         """When the user closes the socket, empty our queue and remove it from the list so the server no longer fills it"""
@@ -124,6 +128,7 @@ class APISpotsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
 
         try:
             if self._spot_queue:
+                if not self._spot_queue.empty():
                     while not self._spot_queue.empty():
                         spot = self._spot_queue.get()
                         # If the new spot matches our param filters, send it to the client. If not, ignore it.
@@ -133,11 +138,15 @@ class APISpotsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
                                 spot.infer_missing(self._credentials)
                             self.write_message(msg=json.dumps(spot, default=serialize_everything))
 
+                else:
+                    # Send a keepalive comment if the queue was empty
+                    self.write_message("keepalive", "")
+
                 if self._spot_queue not in self._sse_spot_queues:
                     logging.error("Web server cleared up a queue of an active connection!")
                     self.close()
-        except:
+        except Exception as e:
-            logging.warning("Exception in SSE callback, connection will be closed.")
+            logging.warning("Exception in SSE callback, connection will be closed: %s", e, exc_info=True)
             self.close()
 
 

server/handlers/pagetemplate.py

@@ -3,7 +3,7 @@ from datetime import datetime
 import pytz
 import tornado
 
-from core.config import ALLOW_SPOTTING, WEB_UI_OPTIONS, BASE_URL
+from core.config import ALLOW_SPOTTING, WEB_UI_OPTIONS, BASE_URL, SERVER_OWNER_CALLSIGN
 from core.constants import SOFTWARE_VERSION
 from core.prometheus_metrics_handler import page_requests_counter
 
@@ -11,12 +11,9 @@ from core.prometheus_metrics_handler import page_requests_counter
 class PageTemplateHandler(tornado.web.RequestHandler):
     """Handler for all HTML pages generated from templates"""
 
-    def initialize(self, template_name, web_server_metrics, has_hamqsl=False, has_noaa_forecast=False, has_giro_ionosonde=False):
+    def initialize(self, template_name, web_server_metrics):
         self._template_name = template_name
         self._web_server_metrics = web_server_metrics
-        self._has_hamqsl = has_hamqsl
-        self._has_noaa_forecast = has_noaa_forecast
-        self._has_giro_ionosonde = has_giro_ionosonde
 
     def get(self):
         # Metrics
@@ -26,7 +23,6 @@ class PageTemplateHandler(tornado.web.RequestHandler):
         page_requests_counter.inc()
 
         # Load named template, and provide variables used in templates
-        self.render(self._template_name + ".html", software_version=SOFTWARE_VERSION, allow_spotting=ALLOW_SPOTTING,
+        self.render(self._template_name + ".html", software_version=SOFTWARE_VERSION,
-                    web_ui_options=WEB_UI_OPTIONS, baseurl=BASE_URL, current_path=self.request.path,
+                    server_owner_callsign=SERVER_OWNER_CALLSIGN, allow_spotting=ALLOW_SPOTTING,
-                    has_hamqsl=self._has_hamqsl, has_noaa_forecast=self._has_noaa_forecast,
+                    web_ui_options=WEB_UI_OPTIONS, baseurl=BASE_URL, current_path=self.request.path)
-                    has_giro_ionosonde=self._has_giro_ionosonde)

server/webserver.py

@@ -5,10 +5,11 @@ import os
 import tornado
 from tornado.web import StaticFileHandler
 
+from core.config import ALLOW_SPOTTING, WEB_SERVER_PORT, API_ONLY_MODE
 from core.utils import empty_queue
 from server.handlers.api.addspot import APISpotHandler
-from server.handlers.api.dxstats import APIDxStatsHandler
 from server.handlers.api.alerts import APIAlertsHandler, APIAlertsStreamHandler
+from server.handlers.api.dxstats import APIDxStatsHandler
 from server.handlers.api.lookups import APILookupCallHandler, APILookupSIGRefHandler, APILookupGridHandler
 from server.handlers.api.options import APIOptionsHandler
 from server.handlers.api.solar_conditions import APISolarConditionsHandler
@@ -21,7 +22,7 @@ from server.handlers.pagetemplate import PageTemplateHandler
 class WebServer:
     """Provides the public-facing web server."""
 
-    def __init__(self, spots, alerts, solar_conditions, status_data, solar_condition_providers, port):
+    def __init__(self, spots, alerts, solar_conditions, status_data):
         """Constructor"""
 
         self._spots = spots
@@ -30,8 +31,8 @@ class WebServer:
         self._sse_spot_queues = []
         self._sse_alert_queues = []
         self._status_data = status_data
-        self._solar_condition_providers = solar_condition_providers
+        self._port = WEB_SERVER_PORT
-        self._port = port
+        self._api_only_mode = API_ONLY_MODE
         self._shutdown_event = asyncio.Event()
         self.web_server_metrics = {
             "last_page_access_time": None,
@@ -54,51 +55,60 @@ class WebServer:
     async def _start_inner(self):
         """Start method (async). Sets up the Tornado application."""
 
-        provider_classes = [type(p).__name__ for p in self._solar_condition_providers if p.enabled]
+        # Prepare a list of common arguments that are passed in to every API & page handler. This is just a basic thing
-        has_hamqsl = "HamQSL" in provider_classes
+        # to avoid copy-pasting the same thing to every route declaration below.
-        has_noaa_forecast = "NOAA3dayForecast" in provider_classes
+        handler_opts = {"web_server_metrics": self.web_server_metrics}
-        has_giro_ionosonde = "GIROIonosonde" in provider_classes
-        page_opts = {"web_server_metrics": self.web_server_metrics, "has_hamqsl": has_hamqsl,
-                     "has_noaa_forecast": has_noaa_forecast, "has_giro_ionosonde": has_giro_ionosonde}
 
-        app = tornado.web.Application([
+        # API endpoints are always enabled
-            # Routes for API calls
+        api_routes = [
-            (r"/api/v1/spots", APISpotsHandler, {"spots": self._spots, "web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/spots", APISpotsHandler, {"spots": self._spots, **handler_opts}),
-            (r"/api/v1/alerts", APIAlertsHandler,
+            (r"/api/v1/alerts", APIAlertsHandler, {"alerts": self._alerts, **handler_opts}),
-             {"alerts": self._alerts, "web_server_metrics": self.web_server_metrics}),
             (r"/api/v1/spots/stream", APISpotsStreamHandler,
-             {"sse_spot_queues": self._sse_spot_queues, "web_server_metrics": self.web_server_metrics}),
+             {"sse_spot_queues": self._sse_spot_queues, **handler_opts}),
             (r"/api/v1/alerts/stream", APIAlertsStreamHandler,
-             {"sse_alert_queues": self._sse_alert_queues, "web_server_metrics": self.web_server_metrics}),
+             {"sse_alert_queues": self._sse_alert_queues, **handler_opts}),
-            (r"/api/v1/solar", APISolarConditionsHandler,
+            (r"/api/v1/solar", APISolarConditionsHandler, {"solar_conditions": self._solar_conditions, **handler_opts}),
-             {"solar_conditions": self._solar_conditions, "web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/dxstats", APIDxStatsHandler, {"spots": self._spots, **handler_opts}),
-            (r"/api/v1/dxstats", APIDxStatsHandler, {"spots": self._spots, "web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/options", APIOptionsHandler, {"status_data": self._status_data, **handler_opts}),
-            (r"/api/v1/options", APIOptionsHandler,
+            (r"/api/v1/status", APIStatusHandler, {"status_data": self._status_data, **handler_opts}),
-             {"status_data": self._status_data, "web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/lookup/call", APILookupCallHandler, {**handler_opts}),
-            (r"/api/v1/status", APIStatusHandler,
+            (r"/api/v1/lookup/sigref", APILookupSIGRefHandler, {**handler_opts}),
-             {"status_data": self._status_data, "web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/lookup/grid", APILookupGridHandler, {**handler_opts}),
-            (r"/api/v1/lookup/call", APILookupCallHandler, {"web_server_metrics": self.web_server_metrics}),
+            (r"/api/v1/spot", APISpotHandler, {"spots": self._spots, **handler_opts}),
-            (r"/api/v1/lookup/sigref", APILookupSIGRefHandler, {"web_server_metrics": self.web_server_metrics}),
+        ]
-            (r"/api/v1/lookup/grid", APILookupGridHandler, {"web_server_metrics": self.web_server_metrics}),
+
-            (r"/api/v1/spot", APISpotHandler, {"spots": self._spots, "web_server_metrics": self.web_server_metrics}),
+        # If in API-only mode, serve a basic homepage; in normal mode, serve the usual UI routes
-            # Routes for templated pages
+        if self._api_only_mode:
-            (r"/", PageTemplateHandler, {"template_name": "spots", **page_opts}),
+            logging.info("API-only mode is enabled. Web UI will not be served.")
-            (r"/map", PageTemplateHandler, {"template_name": "map", **page_opts}),
+            ui_routes = [
-            (r"/bands", PageTemplateHandler, {"template_name": "bands", **page_opts}),
+                (r"/", PageTemplateHandler, {"template_name": "api_only_home", **handler_opts})
-            (r"/alerts", PageTemplateHandler, {"template_name": "alerts", **page_opts}),
+            ]
-            (r"/add-spot", PageTemplateHandler, {"template_name": "add_spot", **page_opts}),
+        else:
-            (r"/conditions", PageTemplateHandler, {"template_name": "conditions", **page_opts}),
+            ui_routes = [
-            (r"/status", PageTemplateHandler, {"template_name": "status", **page_opts}),
+                (r"/", PageTemplateHandler, {"template_name": "spots", **handler_opts}),
-            (r"/about", PageTemplateHandler, {"template_name": "about", **page_opts}),
+                (r"/map", PageTemplateHandler, {"template_name": "map", **handler_opts}),
-            (r"/apidocs", PageTemplateHandler, {"template_name": "apidocs", **page_opts}),
+                (r"/bands", PageTemplateHandler, {"template_name": "bands", **handler_opts}),
-            # Route for Prometheus metrics
+                (r"/alerts", PageTemplateHandler, {"template_name": "alerts", **handler_opts}),
+                (r"/conditions", PageTemplateHandler, {"template_name": "conditions", **handler_opts}),
+                (r"/status", PageTemplateHandler, {"template_name": "status", **handler_opts}),
+                (r"/about", PageTemplateHandler, {"template_name": "about", **handler_opts})
+            ]
+            # Only allow the Add Spot page if spotting is allowed
+            if ALLOW_SPOTTING:
+                ui_routes += [(r"/add-spot", PageTemplateHandler, {"template_name": "add_spot", **handler_opts})]
+
+        # API docs, Prometheus metrics, and finally static assets are always available regardless of API-only mode.
+        misc_routes = [
+            (r"/apidocs", PageTemplateHandler, {"template_name": "apidocs", **handler_opts}),
             (r"/metrics", PrometheusMetricsHandler),
-            # Default route to serve from "webassets"
+            (r"/(.*)", StaticFileHandler, {"path": os.path.join(os.path.dirname(__file__), "../webassets")})
-            (r"/(.*)", StaticFileHandler, {"path": os.path.join(os.path.dirname(__file__), "../webassets")}),
+        ]
-        ],
+
+        app = tornado.web.Application(api_routes + ui_routes + misc_routes,
                                       template_path=os.path.join(os.path.dirname(__file__), "../templates"),
                                       debug=False)
         app.listen(self._port)
+        logging.info("Web server running on port " + str(WEB_SERVER_PORT))
         await self._shutdown_event.wait()
 
     def notify_new_spot(self, spot):

solarconditionsproviders/giroionosonde.py

@@ -6,19 +6,21 @@ from threading import Thread, Event
 import pytz
 import requests
 
-from core.constants import HTTP_HEADERS, BANDS
+from core.constants import HTTP_HEADERS
+from solarconditionsproviders.ionosonde_utils import compute_band_states
 from solarconditionsproviders.solar_conditions_provider import SolarConditionsProvider
 
 POLL_INTERVAL = 3600  # 1 hour
 STATIONS_INDEX = "datafiles/didbase-stations.csv"
 LGDC_URL = "https://lgdc.uml.edu/common/DIDBGetValues"
 HISTORY_HOURS = 24
-HF_BANDS = [b for b in BANDS if b.is_ham_hf]
 
 
 class GIROIonosonde(SolarConditionsProvider):
     """Solar conditions provider using ionosonde data from the GIRO Data Center.
-    Queries foF2, MUF, and LUF measurements for all stations in datafiles/didbase-stations.csv."""
+    Queries foF2, MUF, and LUF measurements for all stations in datafiles/didbase-stations.csv.
+    Can run alongside KC2GProp: GIRO supplements KC2G's foF2/MUF data with LUF readings, and
+    stations from each source that the other does not cover are preserved."""
 
     def __init__(self, provider_config):
         super().__init__(provider_config)
@@ -27,8 +29,6 @@ class GIROIonosonde(SolarConditionsProvider):
         self._stop_event = Event()
 
     def _load_stations(self):
-        """Load the CSV file containing the list of URSIs and Station Names for currently active ionosondes."""
-
         stations = []
         with open(STATIONS_INDEX, newline='') as f:
             for row in csv.reader(f):
@@ -37,15 +37,19 @@ class GIROIonosonde(SolarConditionsProvider):
         return stations
 
     def setup(self, solar_conditions, solar_conditions_cache):
-        """Prepopulate the ionosonde_data map with known URSI and station names, so that the API exposes this structure
+        """Pre-populate ionosonde_data with known station names for stations not already present,
-        even before we actually have any data in it."""
+        so the station dropdown is available before the first poll. Does not overwrite existing
+        entries so KC2G cache data is preserved."""
 
         super().setup(solar_conditions, solar_conditions_cache)
-        self.update_data({"ionosonde_data": {
+        existing = solar_conditions.ionosonde_data or {}
-            s["ursi"]: {"ursi": s["ursi"], "name": s["name"], "fof2": None, "muf": None, "luf": None,
+        new_entries = {
-                        "band_states": None}
+            s["ursi"]: {"ursi": s["ursi"], "name": s["name"], "fof2": None, "muf": None,
-            for s in self._stations
+                        "luf": None, "band_states": None}
-        }})
+            for s in self._stations if s["ursi"] not in existing
+        }
+        if new_entries:
+            self.update_data({"ionosonde_data": {**existing, **new_entries}})
 
     def start(self):
         logging.info(f"Set up query of GIRO ionosonde data API every {POLL_INTERVAL} seconds.")
@@ -63,9 +67,13 @@ class GIROIonosonde(SolarConditionsProvider):
 
     def _poll(self):
         try:
-            logging.debug(f"Polling GIRO ionosonde data...")
+            logging.debug("Polling GIRO ionosonde data...")
             now = datetime.now(timezone.utc)
             from_time = now - timedelta(hours=HISTORY_HOURS)
+            cutoff_ts = from_time.timestamp()
+
+            # Start from the existing ionosonde_data so stations provided by other providers
+            # (e.g. KC2GProp) are preserved for stations GIRO does not cover.
             ionosonde_data = dict(self._solar_conditions.ionosonde_data or {})
             updated_count = 0
 
@@ -76,10 +84,27 @@ class GIROIonosonde(SolarConditionsProvider):
                 name = station["name"]
                 try:
                     fof2, muf, luf = self._fetch_station_data(ursi, from_time, now)
-                    if fof2 and muf:
+                    if not fof2 or not muf:
-                        band_states = self._compute_band_statess(fof2, muf, luf or {})
+                        continue
-                        ionosonde_data[ursi] = {"ursi": ursi, "name": name, "fof2": fof2, "muf": muf,
+
-                                                "luf": luf or None, "band_states": band_states}
+                    # Merge GIRO's readings into any existing data for this station.
+                    existing = ionosonde_data.get(ursi, {})
+                    merged_fof2 = {**{float(t): v for t, v in (existing.get("fof2") or {}).items()}, **fof2}
+                    merged_muf = {**{float(t): v for t, v in (existing.get("muf") or {}).items()}, **muf}
+                    merged_luf = dict(luf) if luf else {}
+
+                    merged_fof2 = {t: v for t, v in merged_fof2.items() if t >= cutoff_ts}
+                    merged_muf = {t: v for t, v in merged_muf.items() if t >= cutoff_ts}
+                    merged_luf = {t: v for t, v in merged_luf.items() if t >= cutoff_ts}
+
+                    band_states = compute_band_states(merged_fof2, merged_muf, merged_luf)
+                    ionosonde_data[ursi] = {
+                        "ursi": ursi, "name": name,
+                        "fof2": merged_fof2 or None,
+                        "muf": merged_muf or None,
+                        "luf": merged_luf or None,
+                        "band_states": band_states,
+                    }
                     updated_count += 1
                 except Exception:
                     logging.warning(f"Could not fetch ionosonde data for {ursi} ({name})")
@@ -91,7 +116,7 @@ class GIROIonosonde(SolarConditionsProvider):
 
         except Exception:
             self.status = "Error"
-            logging.exception(f"Exception in GIRO Ionosonde data provider")
+            logging.exception("Exception in GIRO Ionosonde data provider")
             self._stop_event.wait(timeout=1)
 
     def _fetch_station_data(self, ursi, from_time, to_time):
@@ -105,40 +130,6 @@ class GIROIonosonde(SolarConditionsProvider):
             return None, None, None
         return self._parse_all(response.text)
 
-    @staticmethod
-    def _latest(d):
-        """Return the value with the highest timestamp key, or None if the dict is empty."""
-        return d[max(d.keys())] if d else None
-
-    @staticmethod
-    def _compute_band_statess(fof2_dict, muf_dict, luf_dict):
-        """Compute HF band states from the latest foF2, MUF and LUF values.
-
-        States:
-          Closed if band frequency is below LUF (if known) or above MUF
-          Short if band frequency is >= LUF and < foF2 (good for NVIS)
-          Long if band frequency is >= foF2 and < MUF (good for DX)
-        """
-
-        # We have a list of timestamped data for each value, but for this we only want the latest value
-        fof2 = GIROIonosonde._latest(fof2_dict)
-        muf = GIROIonosonde._latest(muf_dict)
-        luf = GIROIonosonde._latest(luf_dict)
-        if fof2 is None or muf is None:
-            return {}
-        band_states = {}
-
-        # Iterate over all ham HF bands, we don't care about the others at this point
-        for band in HF_BANDS:
-            freq = band.start_freq / 1000000
-            if freq > muf or (luf is not None and freq < luf):
-                band_states[band.name] = "Closed"
-            elif freq < fof2:
-                band_states[band.name] = "Short"
-            else:
-                band_states[band.name] = "Long"
-        return band_states
-
     @staticmethod
     def _parse_all(text):
         """Parse web server response and return (fof2_dict, muf_dict, luf_dict) keyed by UNIX timestamp."""

solarconditionsproviders/ionosonde_utils.py

@@ -0,0 +1,33 @@
+from core.constants import BANDS
+
+HF_BANDS = [b for b in BANDS if b.is_ham_hf]
+
+
+def _latest(d):
+    return d[max(d.keys())] if d else None
+
+
+def compute_band_states(fof2_dict, muf_dict, luf_dict):
+    """Compute HF band states from the latest foF2, MUF and LUF values.
+
+    States:
+      Closed if band frequency is above MUF or below LUF (if known)
+      Short  if band frequency is >= LUF and < foF2 (good for NVIS)
+      Long   if band frequency is >= foF2 and < MUF (good for DX)
+    """
+
+    fof2 = _latest(fof2_dict)
+    muf = _latest(muf_dict)
+    luf = _latest(luf_dict) if luf_dict else None
+    if fof2 is None or muf is None:
+        return {}
+    band_states = {}
+    for band in HF_BANDS:
+        freq = band.start_freq / 1_000_000
+        if freq > muf or (luf is not None and freq < luf):
+            band_states[band.name] = "Closed"
+        elif freq < fof2:
+            band_states[band.name] = "Short"
+        else:
+            band_states[band.name] = "Long"
+    return band_states

solarconditionsproviders/kc2gprop.py

@@ -0,0 +1,121 @@
+import logging
+from datetime import datetime, timezone, timedelta
+from threading import Thread, Event
+
+import pytz
+import requests
+
+from core.constants import HTTP_HEADERS
+from solarconditionsproviders.ionosonde_utils import compute_band_states
+from solarconditionsproviders.solar_conditions_provider import SolarConditionsProvider
+
+POLL_INTERVAL = 900  # 15 minutes
+KC2G_URL = "https://prop.kc2g.com/api/stations.json"
+HISTORY_HOURS = 24
+
+
+class KC2GProp(SolarConditionsProvider):
+    """Solar conditions provider using ionosonde data from prop.kc2g.com. The API returns only the latest reading per
+     station, so this provider polls every 15 minutes and accumulates a 24-hour time series by merging each new reading
+     into the persisted ionosonde_data, producing the same data structure as GIROIonosonde.
+
+     Can run alongside GIROIonosonde: KC2G provides foF2/MUF with good reliability, while GIRO supplements with LUF
+     readings. Stations from each source that the other does not cover are preserved."""
+
+    def __init__(self, provider_config):
+        super().__init__(provider_config)
+        self._thread = None
+        self._stop_event = Event()
+
+    def start(self):
+        logging.info(f"Set up query of KC2G ionosonde data API every {POLL_INTERVAL} seconds.")
+        self._thread = Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+
+    def _run(self):
+        while True:
+            self._poll()
+            if self._stop_event.wait(timeout=POLL_INTERVAL):
+                break
+
+    def _poll(self):
+        try:
+            logging.debug("Polling KC2G ionosonde data...")
+            response = requests.get(KC2G_URL, headers=HTTP_HEADERS, timeout=(5, 30))
+            if response.status_code != 200:
+                logging.warning(f"KC2G ionosonde API returned HTTP {response.status_code}")
+                return
+
+            now = datetime.now(timezone.utc)
+            cutoff_ts = (now - timedelta(hours=HISTORY_HOURS)).timestamp()
+
+            # Start from existing ionosonde_data so the accumulated time series survives across polls and restarts and
+            # stations provided only by GIROIonosonde are not discarded
+            ionosonde_data = dict(self._solar_conditions.ionosonde_data or {})
+            updated_count = 0
+
+            for reading in response.json():
+                station = reading.get("station", {})
+                ursi = station.get("code")
+                name = station.get("name")
+                if not ursi or not name:
+                    continue
+
+                time_str = reading.get("time")
+                if not time_str:
+                    continue
+                try:
+                    ts = datetime.fromisoformat(time_str)
+                    if ts.tzinfo is None:
+                        ts = ts.replace(tzinfo=timezone.utc)
+                    ts_float = ts.timestamp()
+                except ValueError:
+                    continue
+
+                # Skip readings outside our history window (some stations have months-old data)
+                if ts_float < cutoff_ts:
+                    continue
+
+                fof2_val = reading.get("fof2")
+                muf_val = reading.get("mufd")
+                if fof2_val is None and muf_val is None:
+                    continue
+
+                # Merge this reading into the existing time series for the station.
+                existing = ionosonde_data.get(ursi, {})
+                fof2_dict = dict(existing.get("fof2") or {})
+                muf_dict = dict(existing.get("muf") or {})
+                # LUF is not available from KC2G; carry forward whatever GIRO has written.
+                luf_dict = {float(t): v for t, v in (existing.get("luf") or {}).items()}
+
+                fof2_dict[ts_float] = fof2_val
+                muf_dict[ts_float] = muf_val
+
+                # Trim all series to the 24-hour window.
+                fof2_dict = {t: v for t, v in fof2_dict.items() if t >= cutoff_ts}
+                muf_dict = {t: v for t, v in muf_dict.items() if t >= cutoff_ts}
+                luf_dict = {t: v for t, v in luf_dict.items() if t >= cutoff_ts}
+
+                band_states = compute_band_states(fof2_dict, muf_dict, luf_dict)
+                ionosonde_data[ursi] = {
+                    "ursi": ursi,
+                    "name": name,
+                    "fof2": fof2_dict or None,
+                    "muf": muf_dict or None,
+                    "luf": luf_dict or None,
+                    "band_states": band_states,
+                }
+                updated_count += 1
+
+            self.update_data({"ionosonde_data": ionosonde_data})
+            self.status = "OK"
+            self.last_update_time = datetime.now(pytz.UTC)
+            logging.debug(f"Updated KC2G ionosonde data for {updated_count} stations.")
+
+        except Exception:
+            self.status = "Error"
+            logging.exception("Exception in KC2G ionosonde data provider")
+            self._stop_event.wait(timeout=1)

spothole.py

@@ -9,8 +9,8 @@ from diskcache import Cache
 
 from core.cleanup import CleanupTimer
 from data.solar_conditions import SolarConditions
-from core.config import config, WEB_SERVER_PORT, SERVER_OWNER_CALLSIGN
+from core.config import config, SERVER_OWNER_CALLSIGN
-from core.constants import SOFTWARE_NAME, SOFTWARE_VERSION
+from core.constants import SOFTWARE_VERSION
 from core.lookup_helper import lookup_helper
 from core.status_reporter import StatusReporter
 from server.webserver import WebServer
@@ -90,7 +90,7 @@ if __name__ == '__main__':
 
     logging.info("Starting...")
     logging.info(
-        "This is " + SOFTWARE_NAME + " version " + SOFTWARE_VERSION + ". This instance is run by " + SERVER_OWNER_CALLSIGN + ".")
+        "This is Spothole version " + SOFTWARE_VERSION + ". This instance is run by " + SERVER_OWNER_CALLSIGN + ".")
 
     # Shut down gracefully on SIGINT
     signal.signal(signal.SIGINT, shutdown)
@@ -99,8 +99,7 @@ if __name__ == '__main__':
     lookup_helper.start()
 
     # Set up web server
-    web_server = WebServer(spots=spots, alerts=alerts, solar_conditions=solar_conditions, status_data=status_data,
+    web_server = WebServer(spots=spots, alerts=alerts, solar_conditions=solar_conditions, status_data=status_data)
-                           solar_condition_providers=solar_condition_providers, port=WEB_SERVER_PORT)
 
     # Fetch, set up and start spot providers
     for entry in config["spot-providers"]:

templates/about.html

@@ -27,7 +27,7 @@
     <h4 class="mt-4">What data sources are supported?</h4>
     <p>Spothole can retrieve spots from: <a href="https://www.dxcluster.info/telnet/">Telnet-based DX clusters</a>, the <a href="https://www.reversebeacon.net/">Reverse Beacon Network (RBN)</a>, the <a href="https://www.aprs-is.net/">APRS Internet Service (APRS-IS)</a>, <a href="https://pota.app">POTA</a>, <a href="https://www.sota.org.uk/">SOTA</a>, <a href="https://wwff.co/">WWFF</a>, <a href="https://www.cqgma.org/">GMA</a>, <a href="https://wwbota.net/">WWBOTA</a>, <a href="http://www.hema.org.uk/">HEMA</a>, <a href="https://www.parksnpeaks.org/">Parks 'n' Peaks</a>, <a href="https://ontheair.nz">ZLOTA</a>, <a href="https://www.wota.org.uk/">WOTA</a>, <a href="https://llota.app">LLOTA</a>, <a href="https://wwtota.com">WWTOTA</a>, <a href="https://tilesontheair.com/">Tiles on the Air</a>, the <a href="https://ukpacketradio.network/">UK Packet Repeater Network</a>, and any site based on the <a href="https://github.com/nischu/xOTA">xOTA software by nischu</a>.</p>
     <p>Spothole can retrieve alerts from: <a href="https://www.ng3k.com/">NG3K</a>, <a href="https://pota.app">POTA</a>, <a href="https://www.sota.org.uk/">SOTA</a>, <a href="https://wwff.co/">WWFF</a>, <a href="https://www.parksnpeaks.org/">Parks 'n' Peaks</a>, <a href="https://www.wota.org.uk/">WOTA</a> and <a href="https://www.beachesontheair.com/">BOTA</a>.</p>
-    <p>Spothole can retrieve solar and propagation condition data from <a href="https://www.hamqsl.com">HamQSL</a>, the <a href="https://www.swpc.noaa.gov/">NOAA Space Weather Prediction Center</a> and the <a href="https://giro.uml.edu/">Lowell GIRO Data Center</a>.</p>
+    <p>Spothole can retrieve solar and propagation condition data from <a href="https://www.hamqsl.com">HamQSL</a>, the <a href="https://www.swpc.noaa.gov/">NOAA Space Weather Prediction Center</a>, the <a href="https://giro.uml.edu/">Lowell GIRO Data Center</a> and <a href="https://prop.kc2g.com/">prop.kc2g.com</a> by KC2G.</p>
     <p>Spothole can also perform lookups for callsign data on behalf of the user from <a href="https://qrz.com">QRZ.com</a> and <a href="https://hamqth.com">HamQTH</a>.</p>
     <p>Note that the server owner has not necessarily enabled all these data sources. In particular it is common to disable RBN, to avoid the server being swamped with FT8 traffic, and to disable APRS-IS and UK Packet Net so that the server only displays stations where there is likely to be an operator physically present for a QSO.</p>
     <p>Between the various data sources, the following Special Interest Groups (SIGs) are supported: Parks on the Air (POTA), Summits on the Air (SOTA), Worldwide Flora & Fauna (WWFF), Global Mountain Activity (GMA), Worldwide Bunkers on the Air (WWBOTA), HuMPs Excluding Marilyns Award (HEMA), Islands on the Air (IOTA), Mills on the Air (MOTA), the Amateur Radio Lighthouse Socirty (ARLHS), International Lighthouse Lightship Weekend (ILLW), Silos on the Air (SIOTA), World Castles Award (WCA), New Zealand on the Air (ZLOTA), Keith Roget Memorial National Parks Award (KRMNPA), Wainwrights on the Air (WOTA), Beaches on the Air (BOTA), Lagos y Lagunas On the Air (LLOTA), Towers on the Air (WWTOTA), Tiles on the Air, Worked All Britain (WAB), Worked All Ireland (WAI), and Toilets on the Air (TOTA).</p>
@@ -69,7 +69,7 @@
     <p>This software is dedicated to the memory of Tom G1PJB, SK, a friend and colleague who sadly passed away around the time I started writing it in Autumn 2025. I was looking forward to showing it to you when it was done.</p>
 </div>
 
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-about").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/add_spot.html

@@ -69,8 +69,8 @@
 
 </div>
 
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/add-spot.js?v=1780424170"></script>
+<script src="/js/add-spot.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-add-spot").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/alerts.html

@@ -70,8 +70,8 @@
 
 </div>
 
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/alerts.js?v=1780424170"></script>
+<script src="/js/alerts.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-alerts").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/api_only_home.html

@@ -0,0 +1,22 @@
+{% extends "skeleton.html" %}
+{% block head_extra %}
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css" rel="stylesheet" crossorigin="anonymous">
+{% end %}
+{% block body %}
+<div class="container mt-5">
+    <div class="row justify-content-center">
+        <div class="col-md-8">
+            <div class="text-center mb-4">
+                <img src="/img/logo.png" width="192" height="60" alt="Spothole">
+            </div>
+            <div class="card">
+                <div class="card-body">
+                    <p class="card-text">This server is running <strong>Spothole v{{software_version}}</strong>, and is operated by <strong>{{server_owner_callsign}}</strong>.</p>
+                    <p class="card-text">The web UI is not available on this instance because the server is running in API-only mode, intended for use by client software rather than visitors to the website. See the <a href="/apidocs">API documentation</a> for details of how client software can interact with the server.</p>
+                    <p class="card-text">Please see the <a href="https://git.ianrenton.com/ian/spothole#readme">README</a> for details of what Spothole is and how you can run it for yourself.</p>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% end %}

templates/bands.html

@@ -76,9 +76,9 @@
 <script>
     let spotProvidersEnabledByDefault = {% raw json_encode(web_ui_options["spot-providers-enabled-by-default"]) %};
 </script>
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/spotsbandsandmap.js?v=1780424170"></script>
+<script src="/js/spotsbandsandmap.js?v=1781716082"></script>
-<script src="/js/bands.js?v=1780424170"></script>
+<script src="/js/bands.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-bands").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/base.html

@@ -1,27 +1,18 @@
 {% extends "skeleton.html" %}
 {% block head_extra %}
-    <link rel="stylesheet" href="/css/style.css?v=1780424170" type="text/css">
+    <link rel="stylesheet" href="/css/style.css?v=1781716082" type="text/css">
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css" rel="stylesheet"
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css" rel="stylesheet" crossorigin="anonymous">
-          integrity="sha384-sRIl4kxILFvY47J16cr9ZwB07vP4J8+LH7qKQnuqkuIAvNWLzeN8tE5YBujZqJLB" crossorigin="anonymous">
     <link href="/fa/css/fontawesome.min.css" rel="stylesheet" />
     <link href="/fa/css/solid.min.css" rel="stylesheet" />
 
-    <script src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js"
+    <script src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js" crossorigin="anonymous"></script>
-            integrity="sha384-1H217gwSVyLSIfaLxHbE7dRb3v4mYCKbpQvzx0cegeju1MVsGrX5xXxAvs/HgeFs"
+    <script src="https://cdn.jsdelivr.net/npm/moment@2.29.4/moment.min.js" crossorigin="anonymous"></script>
-            crossorigin="anonymous"></script>
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/js/bootstrap.bundle.min.js" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/moment@2.29.4/moment.min.js"
+    <script src="https://cdn.jsdelivr.net/npm/tinycolor2@1.6.0/cjs/tinycolor.min.js" crossorigin="anonymous"></script>
-            integrity="sha384-N1xdnJwBzqfCpEDxEeSQzv4NPVPViBQq2NLbzth3YA1pLvR9mtf+TV5g6O+KLkPY"
-            crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/js/bootstrap.bundle.min.js"
-            integrity="sha384-FKyoEForCGlyvwx9Hj09JcYn3nv7wiPVlz7YYwJrWVcXK/BmnVDxM+D2scQbITxI"
-            crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/tinycolor2@1.6.0/cjs/tinycolor.min.js"
-            integrity="sha384-L1eE4eD41kpBIWe2I0eHy+GnEUC4RIpcvibVW2JCminuPlTl+2Bc528iPdVMg5Dn"
-            crossorigin="anonymous"></script>
 
-    <script src="https://misc.ianrenton.com/jsutils/utils.js?v=1780424170"></script>
+    <script src="https://misc.ianrenton.com/jsutils/utils.js?v=1781716082"></script>
-    <script src="https://misc.ianrenton.com/jsutils/ui-ham.js?v=1780424170"></script>
+    <script src="https://misc.ianrenton.com/jsutils/ui-ham.js?v=1781716082"></script>
-    <script src="https://misc.ianrenton.com/jsutils/geo.js?v=1780424170"></script>
+    <script src="https://misc.ianrenton.com/jsutils/geo.js?v=1781716082"></script>
 {% end %}
 {% block body %}
 <div class="container">
@@ -42,9 +33,7 @@
                   {% if allow_spotting %}
                     <li class="nav-item ms-4"><a href="/add-spot" class="nav-link" id="nav-link-add-spot"><i class="fa-solid fa-comment"></i> Add&nbsp;Spot</a></li>
                   {% end %}
-                  {% if has_hamqsl or has_noaa_forecast %}
                     <li class="nav-item ms-4"><a href="/conditions" class="nav-link" id="nav-link-conditions"><i class="fa-solid fa-sun"></i> Conditions</a></li>
-                  {% end %}
                     <li class="nav-item ms-4"><a href="/status" class="nav-link" id="nav-link-status"><i class="fa-solid fa-chart-simple"></i> Status</a></li>
                     <li class="nav-item ms-4"><a href="/about" class="nav-link" id="nav-link-about"><i class="fa-solid fa-circle-info"></i> About</a></li>
                     <li class="nav-item ms-4"><a href="/apidocs" class="nav-link" id="nav-link-api"><i class="fa-solid fa-gear"></i> API</a></li>

templates/conditions.html

@@ -1,8 +1,8 @@
 {% extends "base.html" %}
 {% block content %}
 
-{% if has_hamqsl %}
+<div id="hamqsl-section" style="display:none">
-<div class="card mt-5">
+    <div class="card mt-5">
         <div class="card-header">
             Propagation Conditions
         </div>
@@ -82,9 +82,9 @@
             </div>
             <div class="form-text mt-3">Data from <a href="https://hamqsl.com">HamQSL.com</a>.</div>
         </div>
-</div>
+    </div>
 
-<div class="card mt-5">
+    <div class="card mt-5">
         <div class="card-header">
             Solar Weather
         </div>
@@ -126,16 +126,17 @@
             </div>
             <div class="row border-bottom align-items-start me-0">
                 <div class="col-12 col-md-2 fw-bold py-2">Electron Flux</div>
-            <div id="sw-electron-vals" class="col-12 col-md-3 py-2"><strong id="sw-electron-flux"></strong> efu</div>
+                <div id="sw-electron-vals" class="col-12 col-md-3 py-2"><strong id="sw-electron-flux"></strong> efu
+                </div>
                 <div id="sw-electron-desc" class="col-12 col-md-7 py-2"></div>
             </div>
             <div class="form-text mt-3">Data from <a href="https://hamqsl.com">HamQSL.com</a>.</div>
         </div>
+    </div>
 </div>
-{% end %}
 
-{% if has_noaa_forecast %}
+<div id="noaa-section" style="display:none">
-<div class="card mt-5">
+    <div class="card mt-5">
         <div class="card-header">
             Solar Weather Forecast
         </div>
@@ -170,11 +171,11 @@
                 Center</a>.
             </div>
         </div>
+    </div>
 </div>
-{% end %}
 
-{% if has_giro_ionosonde %}
+<div id="ionosonde-section" style="display:none">
-<div class="card mt-5">
+    <div class="card mt-5">
         <div class="card-header">
             Ionosonde Data
         </div>
@@ -186,33 +187,45 @@
                 </select>
             </div>
             <div id="ionosonde-latest" class="mb-3">
-            <div id="ionosonde-no-data" class="alert alert-warning mt-2 mb-0 py-2 js-hidden">No data available for this station.</div>
+                <div id="ionosonde-no-data" class="alert alert-warning mt-2 mb-0 py-2 js-hidden">No data available for
+                    this station.
+                </div>
                 <div id="ionosonde-data-rows" class="js-hidden">
                     <div class="row align-items-center me-0">
-                    <div class="col-12 py-2 text-muted">Latest values as of <span id="ionosonde-latest-time"></span></div>
+                        <div class="col-12 py-2 text-muted">Latest values as of <span id="ionosonde-latest-time"></span>
+                        </div>
                     </div>
                     <div class="row align-items-center me-0">
                         <div class="col-12 col-md-4 py-2">LUF: <strong id="ionosonde-latest-luf"></strong></div>
                         <div class="col-12 col-md-4 py-2">foF2: <strong id="ionosonde-latest-fof2"></strong></div>
-                    <div class="col-12 col-md-4 py-2">MUF (3000 km): <strong id="ionosonde-latest-muf"></strong></div>
+                        <div class="col-12 col-md-4 py-2">MUF (3000 km): <strong id="ionosonde-latest-muf"></strong>
+                        </div>
+                    </div>
+                    <div id="ionosonde-stale-warning" class="alert alert-warning mt-2 mb-0 py-2 js-hidden">Data is more
+                        than 12 hours old!
                     </div>
-                <div id="ionosonde-stale-warning" class="alert alert-warning mt-2 mb-0 py-2 js-hidden">Data is more than 12 hours old!</div>
                 </div>
             </div>
             <div id="ionosonde-band-state" class="mb-3 js-hidden">
                 <table class="table table-sm table-bordered mb-0 d-none d-md-table table-fixed-on-desktop">
-                <thead><tr id="ionosonde-band-state-head"></tr></thead>
+                    <thead>
-                <tbody><tr id="ionosonde-band-state-row"></tr></tbody>
+                    <tr id="ionosonde-band-state-head"></tr>
+                    </thead>
+                    <tbody>
+                    <tr id="ionosonde-band-state-row"></tr>
+                    </tbody>
                 </table>
                 <table class="table table-sm table-bordered mb-0 d-md-none">
                     <tbody id="ionosonde-band-state-body"></tbody>
                 </table>
             </div>
             <canvas id="ionosonde-chart" class="mt-3 mb-3 hideonmobile"></canvas>
-        <div class="form-text mt-2">Data from the <a href="https://lgdc.uml.edu/">Lowell GIRO Data Center</a>.</div>
+            <div class="form-text mt-2">Data from the <a href="https://lgdc.uml.edu/">Lowell GIRO Data Center</a> and/or
+                <a href="https://prop.kc2g.com/">KC2G</a>.
+            </div>
+        </div>
     </div>
 </div>
-{% end %}
 
 <div class="card mt-5">
     <div class="card-header">
@@ -271,8 +284,8 @@
 </div>
 
 <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.9/dist/chart.umd.min.js"></script>
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/conditions.js?v=1780424170"></script>
+<script src="/js/conditions.js?v=1781716082"></script>
 <script>$(document).ready(function () {
     $("#nav-link-conditions").addClass("active");
 }); <!-- highlight active page in nav --></script>

templates/map.html

@@ -94,9 +94,9 @@
 <script>
     let spotProvidersEnabledByDefault = {% raw json_encode(web_ui_options["spot-providers-enabled-by-default"]) %};
 </script>
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/spotsbandsandmap.js?v=1780424170"></script>
+<script src="/js/spotsbandsandmap.js?v=1781716082"></script>
-<script src="/js/map.js?v=1780424170"></script>
+<script src="/js/map.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-map").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/spots.html

@@ -104,9 +104,9 @@
 <script>
     let spotProvidersEnabledByDefault = {% raw json_encode(web_ui_options["spot-providers-enabled-by-default"]) %};
 </script>
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/spotsbandsandmap.js?v=1780424170"></script>
+<script src="/js/spotsbandsandmap.js?v=1781716082"></script>
-<script src="/js/spots.js?v=1780424170"></script>
+<script src="/js/spots.js?v=1781716082"></script>
 <script>$(document).ready(function() { $("#nav-link-spots").addClass("active"); }); <!-- highlight active page in nav --></script>
 
 {% end %}

templates/status.html

@@ -59,8 +59,8 @@
     </div>
 </div>
 
-<script src="/js/common.js?v=1780424170"></script>
+<script src="/js/common.js?v=1781716082"></script>
-<script src="/js/status.js?v=1780424170"></script>
+<script src="/js/status.js?v=1781716082"></script>
 <script>
     $(document).ready(function() { $("#nav-link-status").addClass("active"); }); <!-- highlight active page in nav -->
 </script>

webassets/apidocs/openapi.yml

@@ -11,6 +11,8 @@ info:
     
     Please note that the data coming out of Spothole is only as good as the data going in. People mis-hear and make typos when spotting callsigns all the time, and there are plenty of areas where Spothole's location data may be inaccurate. If you are doing something where accuracy is important, such as contesting, you should not rely on Spothole's data to fill in any gaps in your log.
     
+    Spothole's source code is located at https://git.ianrenton.com/ian/spothole and the README there provides setup instructions if you would like to run your own copy. A demonstration server of Spothole is located at https://spothole.app.
+    
     ## Changelog
     
     ### 1.3
@@ -1377,6 +1379,32 @@ components:
             included, but not all of them may contain data.
           additionalProperties:
             $ref: '#/components/schemas/IonosondeStation'
+          example:
+            DB049:
+              ursi: DB049
+              name: Dourbes
+              fof2:
+                "1747267201.0": 7.45
+                "1747267501.0": 7.50
+              muf:
+                "1747267201.0": 21.66
+                "1747267501.0": 21.80
+              luf:
+                "1747267201.0": 2.10
+                "1747267501.0": 2.05
+              band_states:
+                "160m": Closed
+                "80m": Short
+                "40m": Long
+                "20m": Long
+                "10m": Closed
+            EA036:
+              ursi: EA036
+              name: Chilton
+              fof2: null
+              muf: null
+              luf: null
+              band_states: null
 
     IonosondeStation:
       type: object

webassets/css/style.css

@@ -184,7 +184,7 @@ tr.new td {
     background-color: var(--bs-success-border-subtle);
   }
   100% {
-    background-color: intial;
+    background-color: initial;
   }
 }
 
@@ -355,7 +355,7 @@ div.band-spot:hover span.band-spot-info {
 
 /* GENERAL MOBILE SUPPORT */
 
-@media (max-width: 991.99px) {
+@media (max-width: 991px) {
     /* General "hide this on mobile" class */
     .hideonmobile {
         display: none !important;

webassets/js/conditions.js

@@ -17,6 +17,7 @@ function loadSolarConditions() {
         const hfConditionClass = {'Good': 'bg-success-subtle', 'Fair': 'bg-warning-subtle', 'Poor': 'bg-danger-subtle'};
 
         if (jsonData.hf_conditions) {
+            $('#hamqsl-section').show();
             Object.entries(jsonData.hf_conditions).forEach(function ([key, condition]) {
                 const cell = $('#hf-conditions-' + key);
                 cell.text(condition);
@@ -116,6 +117,7 @@ function loadSolarConditions() {
         // Ionosonde
 
         if (jsonData.ionosonde_data && Object.keys(jsonData.ionosonde_data).length > 0) {
+            $('#ionosonde-section').show();
             ionosondeData = jsonData.ionosonde_data;
             populateIonosondeDropdown(ionosondeData);
             renderIonosondeData();
@@ -123,6 +125,9 @@ function loadSolarConditions() {
 
         // Forecast
 
+        if (jsonData.k_index_forecast) {
+            $('#noaa-section').show();
+        }
         renderKIndexForecast(jsonData.k_index_forecast);
         renderSolarStormForecast(jsonData.solar_storm_forecast);
         renderBlackoutForecast(jsonData.blackout_forecast_r1r2, jsonData.blackout_forecast_r3_or_greater);
@@ -431,9 +436,9 @@ function renderIonosondeData() {
         const latestDate = moment.utc(maxTs * 1000);
         $('#ionosonde-latest-time').text(latestDate.format('DD MMM YYYY HH:mm [UTC]') + ' (' + latestDate.fromNow() + ')');
     }
-    $('#ionosonde-latest-luf').text(latestLuf !== null ? latestLuf.toFixed(2) + ' MHz' : 'N/A');
+    $('#ionosonde-latest-luf').text(latestLuf !== null ? latestLuf.toFixed(2) + ' MHz' : 'Unknown');
-    $('#ionosonde-latest-fof2').text(latestFof2 !== null ? latestFof2.toFixed(2) + ' MHz' : 'N/A');
+    $('#ionosonde-latest-fof2').text(latestFof2 !== null ? latestFof2.toFixed(2) + ' MHz' : 'Unknown');
-    $('#ionosonde-latest-muf').text(latestMuf !== null ? latestMuf.toFixed(2) + ' MHz' : 'N/A');
+    $('#ionosonde-latest-muf').text(latestMuf !== null ? latestMuf.toFixed(2) + ' MHz' : 'Unknown');
     $('#ionosonde-stale-warning').toggle(maxTs !== null && (Date.now() / 1000 - maxTs) > 12 * 3600);
 
     // Populate band state tables. There are actually two tables to populate, which is pretty janky, but allows us to

webassets/js/spots.js

@@ -4,6 +4,14 @@ let restartSSEOnErrorTimeoutId;
 // Table row count, to alternate shading
 let rowCount = 0;
 
+// Set up a listener to close the SSE connection nicely when we navigate away from the page, to prevent console errors
+// and keep things nice and tidy for the server.
+window.addEventListener('beforeunload', function() {
+    if (evtSource != null) {
+        evtSource.close();
+    }
+});
+
 // Load spots and populate the table.
 function loadSpots() {
     // If we have an ongoing SSE connection, stop it so it doesn't interfere with our reload