initial rework separating server and client impl

freqtrade/rpc/api_server/webserver.py

@@ -1,15 +1,20 @@
+import asyncio
 import logging
 from ipaddress import IPv4Address
+from threading import Thread
 from typing import Any, Dict
 
 import orjson
 import uvicorn
 from fastapi import Depends, FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+# Look into alternatives
+from janus import Queue as ThreadedQueue
 from starlette.responses import JSONResponse
 
 from freqtrade.exceptions import OperationalException
 from freqtrade.rpc.api_server.uvicorn_threaded import UvicornServer
+from freqtrade.rpc.api_server.ws.channel import ChannelManager
 from freqtrade.rpc.rpc import RPC, RPCException, RPCHandler
 
 
@@ -43,6 +48,10 @@ class ApiServer(RPCHandler):
     _config: Dict[str, Any] = {}
     # Exchange - only available in webserver mode.
     _exchange = None
+    # websocket message queue stuff
+    _channel_manager = None
+    _thread = None
+    _loop = None
 
     def __new__(cls, *args, **kwargs):
         """
@@ -64,10 +73,15 @@ class ApiServer(RPCHandler):
             return
         self._standalone: bool = standalone
         self._server = None
+        self._queue = None
+        self._background_task = None
+
         ApiServer.__initialized = True
 
         api_config = self._config['api_server']
 
+        ApiServer._channel_manager = ChannelManager()
+
         self.app = FastAPI(title="Freqtrade API",
                            docs_url='/docs' if api_config.get('enable_openapi', False) else None,
                            redoc_url=None,
@@ -95,6 +109,18 @@ class ApiServer(RPCHandler):
             logger.info("Stopping API Server")
             self._server.cleanup()
 
+        if self._thread and self._loop:
+            logger.info("Stopping API Server background tasks")
+
+            if self._background_task:
+                # Cancel the queue task
+                self._background_task.cancel()
+
+            # Finally stop the loop
+            self._loop.call_soon_threadsafe(self._loop.stop)
+
+            self._thread.join()
+
     @classmethod
     def shutdown(cls):
         cls.__initialized = False
@@ -104,7 +130,10 @@ class ApiServer(RPCHandler):
         cls._rpc = None
 
     def send_msg(self, msg: Dict[str, str]) -> None:
-        pass
+        if self._queue:
+            logger.info(f"Adding message to queue: {msg}")
+            sync_q = self._queue.sync_q
+            sync_q.put(msg)
 
     def handle_rpc_exception(self, request, exc):
         logger.exception(f"API Error calling: {exc}")
@@ -114,10 +143,12 @@ class ApiServer(RPCHandler):
         )
 
     def configure_app(self, app: FastAPI, config):
-        from freqtrade.rpc.api_server.api_auth import http_basic_or_jwt_token, router_login
+        from freqtrade.rpc.api_server.api_auth import (get_ws_token, http_basic_or_jwt_token,
+                                                       router_login)
         from freqtrade.rpc.api_server.api_backtest import router as api_backtest
         from freqtrade.rpc.api_server.api_v1 import router as api_v1
         from freqtrade.rpc.api_server.api_v1 import router_public as api_v1_public
+        from freqtrade.rpc.api_server.api_ws import router as ws_router
         from freqtrade.rpc.api_server.web_ui import router_ui
 
         app.include_router(api_v1_public, prefix="/api/v1")
@@ -128,6 +159,9 @@ class ApiServer(RPCHandler):
         app.include_router(api_backtest, prefix="/api/v1",
                            dependencies=[Depends(http_basic_or_jwt_token)],
                            )
+        app.include_router(ws_router, prefix="/api/v1",
+                           dependencies=[Depends(get_ws_token)]
+                           )
         app.include_router(router_login, prefix="/api/v1", tags=["auth"])
         # UI Router MUST be last!
         app.include_router(router_ui, prefix='')
@@ -142,6 +176,43 @@ class ApiServer(RPCHandler):
 
         app.add_exception_handler(RPCException, self.handle_rpc_exception)
 
+    def start_message_queue(self):
+        # Create a new loop, as it'll be just for the background thread
+        self._loop = asyncio.new_event_loop()
+
+        # Start the thread
+        if not self._thread:
+            self._thread = Thread(target=self._loop.run_forever)
+            self._thread.start()
+        else:
+            raise RuntimeError("Threaded loop is already running")
+
+        # Finally, submit the coro to the thread
+        self._background_task = asyncio.run_coroutine_threadsafe(
+            self._broadcast_queue_data(), loop=self._loop)
+
+    async def _broadcast_queue_data(self):
+        # Instantiate the queue in this coroutine so it's attached to our loop
+        self._queue = ThreadedQueue()
+        async_queue = self._queue.async_q
+
+        try:
+            while True:
+                logger.debug("Getting queue data...")
+                # Get data from queue
+                data = await async_queue.get()
+                logger.debug(f"Found data: {data}")
+                # Broadcast it
+                await self._channel_manager.broadcast(data)
+                # Sleep, make this configurable?
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            # Silently stop
+            pass
+        # For testing, shouldn't happen when stable
+        except Exception as e:
+            logger.info(f"Exception happened in background task: {e}")
+
     def start_api(self):
         """
         Start API ... should be run in thread.
@@ -179,6 +250,7 @@ class ApiServer(RPCHandler):
             if self._standalone:
                 self._server.run()
             else:
+                self.start_message_queue()
                 self._server.run_in_thread()
         except Exception:
             logger.exception("Api server failed to start.")