Merge pull request #237 from sr-gi/fix-log-port

Lets the OS pick a free port instead of harcoding one

Author: sr-gi

teos/api.py

@@ -59,7 +59,7 @@ def get_request_data_json(request):
         raise InvalidParameter("Request is not json encoded")
 
 
-def serve(internal_api_endpoint, endpoint, min_to_self_delay, auto_run=False):
+def serve(internal_api_endpoint, endpoint, logging_port, min_to_self_delay, auto_run=False):
     """
     Starts the API.
 
@@ -68,6 +68,7 @@ def serve(internal_api_endpoint, endpoint, min_to_self_delay, auto_run=False):
     Args:
         internal_api_endpoint (:obj:`str`): endpoint where the internal api is running (``host:port``).
         endpoint (:obj:`str`): endpoint where the http api will be running (``host:port``).
+        logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
         min_to_self_delay (:obj:`str`): the minimum to_self_delay accepted by the :obj:`Inspector`.
         auto_run (:obj:`bool`): whether the server should be started by this process. False if run with an external
             WSGI. True is run by Flask.
@@ -76,7 +77,7 @@ def serve(internal_api_endpoint, endpoint, min_to_self_delay, auto_run=False):
         The application object needed by the WSGI server to run if ``auto_run`` is False, :obj:`None` otherwise.
     """
 
-    setup_logging()
+    setup_logging(logging_port)
     inspector = Inspector(int(min_to_self_delay))
     api = API(inspector, internal_api_endpoint)
 

teos/constants.py

@@ -1,5 +1,4 @@
 import logging.handlers
 
 SHUTDOWN_GRACE_TIME = 10  # Grace time in seconds to complete any pending call when stopping one of the services of TEOS
-TCP_LOGGING_PORT = logging.handlers.DEFAULT_TCP_LOGGING_PORT  # The port used for the tcp logging service is 9020
 OUTDATED_USERS_CACHE_SIZE_BLOCKS = 10  # Size of the users cache, in blocks

teos/logger.py

@@ -11,7 +11,6 @@
 from io import StringIO
 
 from teos.tools import ignore_signal
-from teos.constants import TCP_LOGGING_PORT
 
 configured = False  # set to True once setup_logging is called
 
@@ -31,10 +30,13 @@ def makeRecord(self, *args, **kwargs):
         return rv
 
 
-def setup_logging():
+def setup_logging(logging_port):
     """
     Configures the logging options. It must be called only once, before using get_logger.
 
+    Args:
+        logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
+
     Raises:
         :obj:`RuntimeError`: if ``setup_logging`` had already been called.
     """
@@ -56,7 +58,7 @@ def setup_logging():
                     "level": "DEBUG",
                     "class": "logging.handlers.SocketHandler",
                     "host": "localhost",
-                    "port": TCP_LOGGING_PORT,
+                    "port": logging_port,
                     "filters": ["onlyteos"],
                 },
             },
@@ -179,11 +181,19 @@ def handle_log_record(record):
 
 
 class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
-    """Simple TCP socket-based logging receiver."""
+    """
+    Simple TCP socket-based logging receiver.
+
+    Args:
+        host (:obj:`str`): the hostname or ip where the logging server can be reached. Defaults to localhost.
+        port (:obj:`int`): the port where the logging server can be reached. Defaults to 0 so the OS can pick a free
+            one.
+        handler (:obj:`StreamRequestHandler`): the log handler.
+    """
 
     allow_reuse_address = True
 
-    def __init__(self, host="localhost", port=TCP_LOGGING_PORT, handler=LogRecordStreamHandler):
+    def __init__(self, host="localhost", port=0, handler=LogRecordStreamHandler):
         socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
         self.timeout = 1
 
@@ -196,13 +206,14 @@ def serve_forever(self, poll_interval=0.5):
                 self.handle_request()
 
 
-def serve(log_file_path, silent, ready):
+def serve(log_file_path, logging_port, silent, ready):
     """
-    Sets up logging on console and file, and serves the tcp logging server on ``localhost:TCP_LOGGING_PORT``.
+    Sets up logging on console and file, and serves the tcp logging server on ``localhost:tcp_logging_port``.
     This method is meant to be run in a separate process and provides the logging service.
 
     Args:
         log_file_path (:obj:`str`): the full path and log file name.
+        logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
         silent (:obj:`bool`): if True, only ``CRITICAL`` errors are shown to console; otherwise ``INFO`` and above.
         ready (:obj:`multiprocessing.Event`): an event that is set once the logging server is ready.
     """
@@ -222,6 +233,7 @@ def serve(log_file_path, silent, ready):
     # Ignore SIGINT so this process does not crash on CTRL+C, but comply on other signals
     signal(SIGINT, ignore_signal)
 
-    tcpserver = LogRecordSocketReceiver()
+    tcpserver = LogRecordSocketReceiver(port=logging_port.value)
+    logging_port.value = tcpserver.server_address[1]
     ready.set()
     tcpserver.serve_forever()

teos/rpc.py

@@ -99,7 +99,7 @@ def stop(self, request, context):
         return self.stub.stop(request)
 
 
-def serve(rpc_bind, rpc_port, internal_api_endpoint, stop_event):
+def serve(rpc_bind, rpc_port, internal_api_endpoint, logging_port, stop_event):
     """
     Serves the external RPC API at the given endpoint and connects it to the internal api.
 
@@ -109,11 +109,12 @@ def serve(rpc_bind, rpc_port, internal_api_endpoint, stop_event):
         rpc_bind (:obj:`str`): the IP or host where the RPC server will be hosted.
         rpc_port (:obj:`int`): the port where the RPC server will be hosted.
         internal_api_endpoint (:obj:`str`): the endpoint where to reach the internal (gRPC) api.
+        logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
         stop_event (:obj:`multiprocessing.Event`) the Event that this service will monitor. The rpc server will
             initiate a graceful shutdown once this event is set.
     """
 
-    setup_logging()
+    setup_logging(logging_port)
     rpc = RPC(rpc_bind, rpc_port, internal_api_endpoint)
     # Ignores SIGINT so the main process can handle the teardown
     signal(SIGINT, ignore_signal)

teos/teosd.py

@@ -64,6 +64,7 @@ class TeosDaemon:
         config (:obj:`dict`): the configuration object.
         sk (:obj:`PrivateKey`): the :obj:`PrivateKey` of the tower.
         logger (:obj:`Logger <teos.logger.Logger>`): the logger instance.
+        logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
 
     Attributes:
         stop_command_event (:obj:`threading.Event`): The event that will be set to initiate a graceful shutdown.
@@ -85,9 +86,10 @@ class TeosDaemon:
         rpc_process (:obj:`multiprocessing.Process`): The instance of the internal RPC server; only set if running.
     """
 
-    def __init__(self, config, sk, logger):
+    def __init__(self, config, sk, logger, logging_port):
         self.config = config
         self.logger = logger
+        self.logging_port = logging_port
 
         # event triggered when a ``stop`` command is issued
         # Using multiprocessing.Event seems to cause a deadlock if event.set() is called in a signal handler that
@@ -153,6 +155,7 @@ def __init__(self, config, sk, logger):
                 self.config.get("RPC_BIND"),
                 self.config.get("RPC_PORT"),
                 self.internal_api_endpoint,
+                self.logging_port,
                 self.stop_event,
             ),
             daemon=True,
@@ -238,8 +241,14 @@ def bootstrap_components(self):
         # Activate ChainMonitor
         self.chain_monitor.activate()
 
-    def start_services(self):
-        """Readies the tower by setting up signal handling, and starting all the services."""
+    def start_services(self, logging_port):
+        """
+        Readies the tower by setting up signal handling, and starting all the services.
+
+        Args:
+            logging_port (:obj:`int`): the port where the logging server can be reached (localhost:logging_port)
+        """
+
         signal(SIGINT, self.handle_signals)
         signal(SIGTERM, self.handle_signals)
         signal(SIGQUIT, self.handle_signals)
@@ -262,7 +271,8 @@ def start_services(self):
                     "gunicorn",
                     f"--bind={api_endpoint}",
                     f"teos.api:serve(internal_api_endpoint='{self.internal_api_endpoint}', "
-                    f"endpoint='{api_endpoint}', min_to_self_delay='{self.config.get('MIN_TO_SELF_DELAY')}')",
+                    f"endpoint='{api_endpoint}', logging_port='{logging_port}', "
+                    f"min_to_self_delay='{self.config.get('MIN_TO_SELF_DELAY')}')",
                 ]
             )
         else:
@@ -271,6 +281,7 @@ def start_services(self):
                 kwargs={
                     "internal_api_endpoint": self.internal_api_endpoint,
                     "endpoint": api_endpoint,
+                    "logging_port": logging_port,
                     "min_to_self_delay": self.config.get("MIN_TO_SELF_DELAY"),
                     "auto_run": True,
                 },
@@ -326,7 +337,7 @@ def start(self):
         """This method implements the whole lifetime cycle of the the TEOS tower. This method does not return."""
         self.logger.info("Starting TEOS")
         self.bootstrap_components()
-        self.start_services()
+        self.start_services(self.logging_port)
 
         self.stop_command_event.wait()
 
@@ -338,14 +349,15 @@ def main(config):
 
     silent = config.get("DAEMON")
     logging_server_ready = multiprocessing.Event()
+    logging_port = multiprocessing.Value("i")
     logging_process = multiprocessing.Process(
-        target=serve_logging, daemon=True, args=(config.get("LOG_FILE"), silent, logging_server_ready)
+        target=serve_logging, daemon=True, args=(config.get("LOG_FILE"), logging_port, silent, logging_server_ready)
     )
     logging_process.start()
 
     logging_server_ready.wait()
 
-    setup_logging()
+    setup_logging(logging_port.value)
     logger = get_logger(component="Daemon")
 
     if not os.path.exists(config.get("TEOS_SECRET_KEY")) or config.get("OVERWRITE_KEY"):
@@ -366,7 +378,7 @@ def main(config):
         logger.warning("Windows cannot run gunicorn as WSGI. Changing to waitress")
 
     try:
-        TeosDaemon(config, sk, logger).start()
+        TeosDaemon(config, sk, logger, logging_port.value).start()
     except Exception as e:
         logger.error("An error occurred: {}. Shutting down".format(e))
         exit(1)