Starting to implement alerts #17

spothole.py

@@ -1,44 +1,50 @@
 # Main script
+import importlib
 import logging
-import os
 import signal
 import sys
-from datetime import datetime
-from time import sleep
 
-import importlib
-import psutil
-import pytz
 from diskcache import Cache
 
 from core.cleanup import CleanupTimer
-from core.config import config, MAX_SPOT_AGE, WEB_SERVER_PORT, SERVER_OWNER_CALLSIGN
-from core.constants import SOFTWARE_VERSION
+from core.config import config, WEB_SERVER_PORT
+from core.status_reporter import StatusReporter
 from core.utils import QRZ_CALLSIGN_DATA_CACHE
 from server.webserver import WebServer
 
 # Globals
 spots = Cache('.spots_cache')
+alerts = Cache('.alerts_cache')
 status_data = {}
-providers = []
+spot_providers = []
+alert_providers = []
 cleanup_timer = None
-run = True
+
 
 # Shutdown function
 def shutdown(sig, frame):
     logging.info("Stopping program, this may take a few seconds...")
-    global run
-    run = False
-    for p in providers:
+    for p in spot_providers:
+        if p.enabled:
+            p.stop()
+    for p in alert_providers:
         if p.enabled:
             p.stop()
     cleanup_timer.stop()
     QRZ_CALLSIGN_DATA_CACHE.close()
     spots.close()
 
-# Utility method to get a data provider based on the class specified in its config entry.
-def get_provider_from_config(config_providers_entry):
-    module = importlib.import_module('providers.' + config_providers_entry["class"].lower())
+
+# Utility method to get a spot provider based on the class specified in its config entry.
+def get_spot_provider_from_config(config_providers_entry):
+    module = importlib.import_module('spotproviders.' + config_providers_entry["class"].lower())
+    provider_class = getattr(module, config_providers_entry["class"])
+    return provider_class(config_providers_entry)
+
+
+# Utility method to get an alert provider based on the class specified in its config entry.
+def get_alert_provider_from_config(config_providers_entry):
+    module = importlib.import_module('alertproviders.' + config_providers_entry["class"].lower())
     provider_class = getattr(module, config_providers_entry["class"])
     return provider_class(config_providers_entry)
 
@@ -55,19 +61,23 @@ if __name__ == '__main__':
     root.addHandler(handler)
 
     logging.info("Starting...")
-    startup_time = datetime.now(pytz.UTC)
-    status_data["software-version"] = SOFTWARE_VERSION
-    status_data["server-owner-callsign"] = SERVER_OWNER_CALLSIGN
 
     # Shut down gracefully on SIGINT
     signal.signal(signal.SIGINT, shutdown)
 
-    for entry in config["providers"]:
-        providers.append(get_provider_from_config(entry))
-    # Set up data providers
-    for p in providers: p.setup(spots=spots)
-    # Start data providers
-    for p in providers:
+    # Fetch, set up and start spot providers
+    for entry in config["spot-providers"]:
+        spot_providers.append(get_spot_provider_from_config(entry))
+    for p in spot_providers:
+        p.setup(spots=spots)
+        if p.enabled:
+            p.start()
+
+    # Fetch, set up and start alert providers
+    for entry in config["alert-providers"]:
+        alert_providers.append(get_alert_provider_from_config(entry))
+    for p in alert_providers:
+        p.setup(alerts=alerts)
         if p.enabled:
             p.start()
 
@@ -79,14 +89,10 @@ if __name__ == '__main__':
     web_server = WebServer(spots=spots, status_data=status_data, port=WEB_SERVER_PORT)
     web_server.start()
 
-    logging.info("Startup complete.")
+    # Set up status reporter
+    status_reporter = StatusReporter(status_data=status_data, spots=spots, alerts=alerts, web_server=web_server,
+                                     cleanup_timer=cleanup_timer, spot_providers=spot_providers,
+                                     alert_providers=alert_providers, run_interval=5)
+    status_reporter.start()
 
-    # While running, update the status information at a regular interval
-    while run:
-        sleep(5)
-        status_data["uptime"] = str(datetime.now(pytz.UTC) - startup_time).split(".")[0]
-        status_data["mem_use_mb"] = round(psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024), 3)
-        status_data["num_spots"] = len(spots)
-        status_data["providers"] = list(map(lambda p: {"name": p.name, "enabled": p.enabled, "status": p.status, "last_updated": p.last_update_time, "last_spot": p.last_spot_time}, providers))
-        status_data["cleanup"] = {"status": cleanup_timer.status, "last_ran": cleanup_timer.last_cleanup_time}
-        status_data["webserver"] = {"status": web_server.status, "last_api_access": web_server.last_api_access_time, "last_page_access": web_server.last_page_access_time}
+    logging.info("Startup complete.")