Introduces the environment variable MWI_PROCESS_START_TIMEOUT, to configure the default timeout of 120 seconds, used by matlab-proxy while waiting for the processes it launches (viz: Xvfb & MATLAB).

fixes #24

Eg:
```
# Set the timeout to 5 minutes (300 seconds)
env MWI_PROCESS_START_TIMEOUT=300 matlab-proxy-app
```

Author: diningPhilosopher64

matlab_proxy/app_state.py

@@ -10,6 +10,7 @@
 from datetime import datetime, timedelta, timezone
 
 from matlab_proxy import util
+from matlab_proxy.settings import get_process_startup_timeout
 from matlab_proxy.util import mw, mwi, system, windows
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi import token_auth
@@ -35,9 +36,6 @@ class AppState:
 
     # Constants that are applicable to AppState class
     MATLAB_PORT_CHECK_DELAY_IN_SECONDS = 1
-    # The maximum amount of time in seconds the Embedded Connector can take
-    # for launching, before the matlab-proxy server concludes that something is wrong.
-    EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS = 120
 
     def __init__(self, settings):
         """Parameterized constructor for the AppState class.
@@ -49,6 +47,9 @@ def __init__(self, settings):
         self.settings = settings
         self.processes = {"matlab": None, "xvfb": None}
 
+        # Timeout for processes launched by matlab-proxy
+        self.PROCESS_TIMEOUT = get_process_startup_timeout()
+
         # The port on which MATLAB(launched by this matlab-proxy process) starts on.
         self.matlab_port = None
 
@@ -825,10 +826,7 @@ async def __track_embedded_connector_state():
 
                     else:
                         time_diff = time.time() - self.embedded_connector_start_time
-                        if (
-                            time_diff
-                            > self.EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS
-                        ):
+                        if time_diff > self.PROCESS_TIMEOUT:
                             # Since max allowed startup time has elapsed, it means that MATLAB is in a stuck state and cannot be launched.
                             # Set the error and stop matlab.
                             user_visible_error = "Unable to start MATLAB.\nTry again by clicking Start MATLAB."
@@ -845,12 +843,12 @@ async def __force_stop_matlab(error):
                             if system.is_windows():
                                 # In WINDOWS systems, errors are raised as UI windows and cannot be captured programmatically.
                                 # So, raise a generic error wherever appropriate
-                                generic_error = f"MATLAB did not start in {int(self.EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS)} seconds. Use Windows Remote Desktop to check for any errors."
+                                generic_error = f"MATLAB did not start in {int(self.PROCESS_TIMEOUT)} seconds. Use Windows Remote Desktop to check for any errors."
                                 logger.error(f":{this_task}: {generic_error}")
                                 if len(self.logs["matlab"]) == 0:
                                     await __force_stop_matlab(user_visible_error)
                                     # Breaking out of the loop to end this task as matlab-proxy was unable to launch MATLAB successfully
-                                    # even after waiting for EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS
+                                    # even after waiting for self.PROCESS_TIMEOUT
                                     break
                                 else:
                                     # Do not stop the MATLAB process or break from the loop (the error type is unknown)
@@ -862,12 +860,12 @@ async def __force_stop_matlab(error):
                                 # If there are no logs after the max startup time has elapsed, it means that MATLAB is in a stuck state and cannot be launched.
                                 # Set the error and stop matlab.
                                 logger.error(
-                                    f":{this_task}: MATLAB did not start in {int(self.EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS)} seconds!"
+                                    f":{this_task}: MATLAB did not start in {int(self.PROCESS_TIMEOUT)} seconds!"
                                 )
                                 if len(self.logs["matlab"]) == 0:
                                     await __force_stop_matlab(user_visible_error)
                                     # Breaking out of the loop to end this task as matlab-proxy was unable to launch MATLAB successfully
-                                    # even after waiting for EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS
+                                    # even after waiting for self.PROCESS_TIMEOUT
                                     break
 
                         else:
@@ -909,7 +907,7 @@ async def __update_matlab_port(delay: int):
             try:
                 await asyncio.wait_for(
                     __read_matlab_ready_file(delay),
-                    self.EMBEDDED_CONNECTOR_MAX_STARTUP_DURATION_IN_SECONDS,
+                    self.PROCESS_TIMEOUT,
                 )
             except asyncio.TimeoutError:
                 logger.debug(

matlab_proxy/constants.py

@@ -1,6 +1,12 @@
 # Copyright (c) 2023 The MathWorks, Inc.
 
 """This module defines project-level constants"""
+
 CONNECTOR_SECUREPORT_FILENAME = "connector.securePort"
 VERSION_INFO_FILE_NAME = "VersionInfo.xml"
 MAX_HTTP_REQUEST_SIZE = 500_000_000  # 500MB
+
+# Max startup duration in seconds for processes launched by matlab-proxy
+# This constant is meant for internal use within matlab-proxy
+# Clients of this package should use settings.py::get_process_startup_timeout() function
+DEFAULT_PROCESS_START_TIMEOUT = 120

matlab_proxy/settings.py

@@ -10,7 +10,7 @@
 import xml.etree.ElementTree as ET
 
 import matlab_proxy
-from matlab_proxy.constants import VERSION_INFO_FILE_NAME
+from matlab_proxy import constants
 from matlab_proxy.util import mwi, system
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi import token_auth
@@ -23,6 +23,35 @@
 logger = mwi.logger.get()
 
 
+def get_process_startup_timeout():
+    """Returns the timeout for a process launched by matlab-proxy as specified by MWI_PROCESS_START_TIMEOUT environment variable
+    if valid, else returns the default value.
+
+    Returns:
+        int: timeout for a process launched by matlab-proxy
+    """
+    custom_startup_timeout = os.getenv(mwi_env.get_env_name_process_startup_timeout())
+
+    if custom_startup_timeout:
+        if custom_startup_timeout.isdigit():
+            logger.info(
+                f"Using custom process startup timeout {custom_startup_timeout} seconds"
+            )
+            return int(custom_startup_timeout)
+
+        else:
+            logger.warn(
+                f"The value set for {mwi_env.get_env_name_process_startup_timeout()}:{custom_startup_timeout} is not a number. Using {constants.DEFAULT_PROCESS_START_TIMEOUT} as the default value"
+            )
+            return constants.DEFAULT_PROCESS_START_TIMEOUT
+
+    logger.info(
+        f"Using {constants.DEFAULT_PROCESS_START_TIMEOUT} seconds as the default timeout value"
+    )
+
+    return constants.DEFAULT_PROCESS_START_TIMEOUT
+
+
 def get_matlab_executable_and_root_path():
     """Returns the path from the MWI_CUSTOM_MATLAB_ROOT environment variable if valid, else returns
     MATLAB root based on the matlab executable if found on the system path.
@@ -86,7 +115,7 @@ def get_matlab_version(matlab_root_path):
     if matlab_root_path is None:
         return None
 
-    version_info_file_path = Path(matlab_root_path) / VERSION_INFO_FILE_NAME
+    version_info_file_path = Path(matlab_root_path) / constants.VERSION_INFO_FILE_NAME
     tree = ET.parse(version_info_file_path)
     root = tree.getroot()
 

matlab_proxy/util/mw.py

@@ -8,6 +8,7 @@
 import aiohttp
 from matlab_proxy.default_configuration import config
 from matlab_proxy.util import mwi
+from matlab_proxy.settings import get_process_startup_timeout
 from matlab_proxy.util.mwi.exceptions import (
     EntitlementError,
     MatlabError,
@@ -290,8 +291,11 @@ async def create_xvfb_process(xvfb_cmd, pipe, env=None):
     number_of_bytes = 200
 
     logger.debug("Waiting for XVFB process to initialize and provide Display Number")
-    # Waits upto 10 seconds for the read_descriptor to be ready.
-    ready_descriptors, _, _ = select.select([read_descriptor], [], [], 10)
+
+    # Wait for timeout specified by matlab-proxy for launching processes.
+    ready_descriptors, _, _ = select.select(
+        [read_descriptor], [], [], get_process_startup_timeout()
+    )
 
     # If read_descriptor is in ready_descriptors, read from it.
     if read_descriptor in ready_descriptors:

matlab_proxy/util/mwi/environment_variables.py

@@ -150,3 +150,8 @@ def get_env_name_mwi_use_existing_license():
 def get_env_name_custom_matlab_root():
     """User specified path to MATLAB root"""
     return "MWI_CUSTOM_MATLAB_ROOT"
+
+
+def get_env_name_process_startup_timeout():
+    """User specified timeout in seconds for processes launched by matlab-proxy"""
+    return "MWI_PROCESS_START_TIMEOUT"

tests/test_settings.py

@@ -291,3 +291,31 @@ def test_get_mw_context_tags(monkeypatch):
     actual_result = settings.get_mw_context_tags(extension_name)
 
     assert expected_result == actual_result
+
+
+@pytest.mark.parametrize(
+    "timeout_value",
+    [(130, 130), ("asdf", 120), (120.5, 120), (None, 120)],
+    ids=["Valid number", "Invalid number", "Valid decimal number", "No value supplied"],
+)
+def test_get_process_timeout(timeout_value, monkeypatch):
+    """Parameterized test to check settings.test_get_process_timeout returns the correct timeout value when MWI_PROCESS_STARTUP_TIMEOUT is set.
+
+    Args:
+        timeout (str): Timeout for processes launched by matlab-proxy
+        monkeypatch (Builtin pytest fixture): Pytest fixture to monkeypatch environment variables.
+    """
+    # Arrange
+    supplied_timeout, expected_timeout = timeout_value[0], timeout_value[1]
+
+    # pytest would throw warnings if None is supplied to monkeypatch
+    if supplied_timeout:
+        monkeypatch.setenv(
+            mwi_env.get_env_name_process_startup_timeout(), str(supplied_timeout)
+        )
+
+    # Act
+    actual_timeout = settings.get_process_startup_timeout()
+
+    # Assert
+    assert expected_timeout == actual_timeout