spothole/server/webserver.py

import asyncio
import logging
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.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
from server.handlers.api.spots import APISpotsHandler, APISpotsStreamHandler
from server.handlers.api.status import APIStatusHandler
from server.handlers.metrics import PrometheusMetricsHandler
from server.handlers.pagetemplate import PageTemplateHandler


class WebServer:
    """Provides the public-facing web server."""

    def __init__(self, spots, alerts, solar_conditions, status_data, spot_providers=None):
        """Constructor"""

        self._spots = spots
        self._alerts = alerts
        self._solar_conditions = solar_conditions
        self._sse_spot_queues = []
        self._sse_alert_queues = []
        self._status_data = status_data
        self._spot_providers = spot_providers or []
        self._port = WEB_SERVER_PORT
        self._api_only_mode = API_ONLY_MODE
        self._shutdown_event = asyncio.Event()
        self.web_server_metrics = {
            "last_page_access_time": None,
            "last_api_access_time": None,
            "page_access_counter": 0,
            "api_access_counter": 0,
            "status": "Starting"
        }

    def start(self):
        """Start the web server"""

        asyncio.run(self._start_inner())

    def stop(self):
        """Stop the web server"""

        self._shutdown_event.set()

    async def _start_inner(self):
        """Start method (async). Sets up the Tornado application."""

        # Prepare a list of common arguments that are passed in to every API & page handler. This is just a basic thing
        # to avoid copy-pasting the same thing to every route declaration below.
        handler_opts = {"web_server_metrics": self.web_server_metrics}

        # API endpoints are always enabled
        api_routes = [
            (r"/api/v1/spots", APISpotsHandler, {"spots": self._spots, **handler_opts}),
            (r"/api/v1/alerts", APIAlertsHandler, {"alerts": self._alerts, **handler_opts}),
            (r"/api/v1/spots/stream", APISpotsStreamHandler,
             {"sse_spot_queues": self._sse_spot_queues, **handler_opts}),
            (r"/api/v1/alerts/stream", APIAlertsStreamHandler,
             {"sse_alert_queues": self._sse_alert_queues, **handler_opts}),
            (r"/api/v1/solar", APISolarConditionsHandler, {"solar_conditions": self._solar_conditions, **handler_opts}),
            (r"/api/v1/dxstats", APIDxStatsHandler, {"spots": self._spots, **handler_opts}),
            (r"/api/v1/options", APIOptionsHandler, {"status_data": self._status_data, "spot_providers": self._spot_providers, **handler_opts}),
            (r"/api/v1/status", APIStatusHandler, {"status_data": self._status_data, **handler_opts}),
            (r"/api/v1/lookup/call", APILookupCallHandler, {**handler_opts}),
            (r"/api/v1/lookup/sigref", APILookupSIGRefHandler, {**handler_opts}),
            (r"/api/v1/lookup/grid", APILookupGridHandler, {**handler_opts}),
            (r"/api/v1/spot", APISpotHandler, {"spots": self._spots, "spot_providers": self._spot_providers, **handler_opts}),
        ]

        # If in API-only mode, serve a basic homepage; in normal mode, serve the usual UI routes
        if self._api_only_mode:
            logging.info("API-only mode is enabled. Web UI will not be served.")
            ui_routes = [
                (r"/", PageTemplateHandler, {"template_name": "api_only_home", **handler_opts})
            ]
        else:
            ui_routes = [
                (r"/", PageTemplateHandler, {"template_name": "spots", **handler_opts}),
                (r"/map", PageTemplateHandler, {"template_name": "map", **handler_opts}),
                (r"/bands", PageTemplateHandler, {"template_name": "bands", **handler_opts}),
                (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),
            (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):
        """Internal method called when a new spot is added to the system. This is used to ping any SSE clients that are
        awaiting a server-sent message with new spots."""

        for queue in self._sse_spot_queues:
            try:
                queue.put(spot)
            except:
                # Cleanup thread was probably deleting the queue, that's fine
                pass
        pass

    def notify_new_alert(self, alert):
        """Internal method called when a new alert is added to the system. This is used to ping any SSE clients that are
        awaiting a server-sent message with new spots."""

        for queue in self._sse_alert_queues:
            try:
                queue.put(alert)
            except:
                # Cleanup thread was probably deleting the queue, that's fine
                pass
        pass

    def clean_up_sse_queues(self):
        """Clean up any SSE queues that are growing too large; probably their client disconnected and we didn't catch it
        properly for some reason."""

        for q in self._sse_spot_queues:
            try:
                if q.full():
                    logging.warning(
                        "A full SSE spot queue was found, presumably because the client disconnected strangely. It has been removed.")
                    self._sse_spot_queues.remove(q)
                    empty_queue(q)
            except:
                # Probably got deleted already on another thread
                pass
        for q in self._sse_alert_queues:
            try:
                if q.full():
                    logging.warning(
                        "A full SSE alert queue was found, presumably because the client disconnected strangely. It has been removed.")
                    self._sse_alert_queues.remove(q)
                    empty_queue(q)
            except:
                # Probably got deleted already on another thread
                pass
        pass