matlab-proxy 0.22.0__py3-none-any.whl → 0.23.3__py3-none-any.whl

matlab_proxy_manager/web/app.py

@@ -14,17 +14,18 @@ from aiohttp import ClientSession, client_exceptions, web
 import matlab_proxy.util.mwi.environment_variables as mwi_env
 import matlab_proxy.util.system as mwi_sys
 import matlab_proxy_manager.lib.api as mpm_lib
-from matlab_proxy.util.event_loop import get_event_loop
 from matlab_proxy_manager.utils import constants, helpers, logger
 from matlab_proxy_manager.utils import environment_variables as mpm_env
 from matlab_proxy_manager.utils.auth import authenticate_access_decorator
 from matlab_proxy_manager.web import watcher
 from matlab_proxy_manager.web.monitor import OrphanedProcessMonitor
 
-# We use __all__ to list down all the public-facing APIs exported by this module
-__all__ = ["proxy", "SHUTDOWN_EVENT"]
+# List of public-facing APIs exported by this module.
+# This list contains the names of functions or classes that are intended to be
+# used by external code importing this module. Only items listed here will be
+# directly accessible when using "from module import *".
+__all__ = ["proxy"]
 
-SHUTDOWN_EVENT = None
 log = logger.get(init=True)
 
 
@@ -40,6 +41,8 @@ def init_app() -> web.Application:
         web.Application: The configured aiohttp web application.
     """
     app = web.Application()
+    # Async event is utilized to signal app termination from this and other modules
+    app["shutdown_event"] = asyncio.Event()
 
     # Create and get the proxy manager data directory
     try:
@@ -53,7 +56,7 @@ def init_app() -> web.Application:
 
     async def start_idle_monitor(app):
         """Start the idle timeout monitor."""
-        asyncio.create_task(monitor.start())
+        app["monitor_task"] = asyncio.create_task(monitor.start())
 
     async def create_client_session(app):
         """Create an aiohttp client session."""
@@ -65,10 +68,34 @@ def init_app() -> web.Application:
         """Cleanup the aiohttp client session."""
         await app["session"].close()
 
+    async def cleanup_monitor(app):
+        """Cancel the idle timeout monitor task."""
+        if "monitor_task" in app:
+            app["monitor_task"].cancel()
+            try:
+                await app["monitor_task"]
+            except asyncio.CancelledError:
+                pass
+
+    async def cleanup_watcher(app):
+        """Cleanup the filesystem watcher."""
+        if "observer" in app:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, watcher.stop_watcher, app)
+
+        if "watcher_future" in app:
+            app["watcher_future"].cancel()
+            try:
+                await app["watcher_future"]
+            except asyncio.CancelledError:
+                pass
+
     app.on_startup.append(start_idle_monitor)
     app.on_startup.append(create_client_session)
     app.on_cleanup.append(helpers.delete_dangling_servers)
     app.on_cleanup.append(cleanup_client_session)
+    app.on_cleanup.append(cleanup_monitor)
+    app.on_cleanup.append(cleanup_watcher)
 
     app.router.add_route("*", "/{tail:.*}", proxy)
 
@@ -86,11 +113,6 @@ async def start_app(env_vars: namedtuple):
     Raises:
         Exception: If any error occurs during the application startup or runtime.
     """
-    # Async events are utilized to signal app termination from other modules,
-    # necessitating the use of a global variable. To avoid potential issues with variable attachment
-    # to other event loops in Python versions prior to 3.10, the variable is initialized locally
-    # rather than globally.
-    global SHUTDOWN_EVENT
     app = init_app()
 
     app["port"] = env_vars.mpm_port
@@ -110,47 +132,51 @@ async def start_app(env_vars: namedtuple):
     log.debug("Proxy manager started at http://127.0.0.1:%d", site._port)
 
     # Get the default event loop
-    loop = get_event_loop()
+    loop = asyncio.get_running_loop()
 
-    # Run the observer in a separate thread
-    loop.run_in_executor(None, watcher.start_watcher, app)
+    # Run the observer in a separate thread and store the future
+    app["watcher_future"] = loop.run_in_executor(None, watcher.start_watcher, app)
 
     # Register signal handler for graceful shutdown
-    _register_signal_handler(loop)
-
-    SHUTDOWN_EVENT = asyncio.Event()
+    _register_signal_handler(loop, app)
 
     # Wait for receiving shutdown_event (set by interrupts or by monitoring process)
-    await SHUTDOWN_EVENT.wait()
+    await app.get("shutdown_event").wait()
 
     # After receiving the shutdown signal, perform cleanup by stopping the web server
     await runner.cleanup()
 
 
-def _register_signal_handler(loop):
+def _register_signal_handler(loop, app):
     """
-    Registers signal handlers for supported termination signals to allow for graceful shutdown
-    of the application.
+    Registers signal handlers for graceful shutdown of the application.
+
+    This function sets up handlers for supported termination signals to allow
+    the application to shut down gracefully. It uses different methods for
+    POSIX and non-POSIX systems to add the signal handlers.
 
     Args:
         loop (asyncio.AbstractEventLoop): The event loop to which the signal handlers
-        should be added.
+            should be added.
+        app (aiohttp.web.Application): The web application instance.
     """
     signals = mwi_sys.get_supported_termination_signals()
     for sig_name in signals:
         if mwi_sys.is_posix():
-            loop.add_signal_handler(sig_name, catch_signals)
+            loop.add_signal_handler(sig_name, lambda: _catch_signals(app))
         else:
             # loop.add_signal_handler() is not yet supported in Windows.
             # Using the 'signal' package instead.
-            signal.signal(sig_name, catch_signals)
+            # signal module expects a handler function that takes two arguments:
+            # the signal number and the current stack frame
+            signal.signal(sig_name, lambda s, f: _catch_signals(app))
 
 
-def catch_signals(*args):
+def _catch_signals(app):
     """Handle termination signals for graceful shutdown."""
     # Poll for parent process to clean up to avoid race conditions in cleanup of matlab proxies
     helpers.poll_for_server_deletion()
-    SHUTDOWN_EVENT.set()
+    app.get("shutdown_event").set()
 
 
 async def _start_default_proxy(app):
@@ -162,7 +188,7 @@ async def _start_default_proxy(app):
     """
     server_process = await mpm_lib.start_matlab_proxy_for_jsp(
         parent_id=app.get("parent_pid"),
-        is_isolated_matlab=False,
+        is_shared_matlab=True,
         mpm_auth_token=app.get("auth_token"),
     )
     if not server_process:
@@ -206,7 +232,7 @@ async def proxy(req):
 
     # Set content length in case of modification
     req_headers["Content-Length"] = str(len(req_body))
-    req_headers["x-forwarded-proto"] = "http"
+    req_headers["X-Forwarded-Proto"] = "http"
     req_path = req.rel_url
 
     # Redirect block to move /*/matlab to /*/matlab/default/
@@ -230,7 +256,7 @@ async def proxy(req):
     if not ctx:
         log.debug("MPM Context header not found in the request")
         return _render_error_page(
-            "Required header (MWI-MPM-CONTEXT) not found in the request"
+            f"Required header: ${constants.HEADER_MWI_MPM_CONTEXT} not found in the request"
         )
 
     client_key = f"{ctx}_{ident}"
@@ -246,9 +272,11 @@ async def proxy(req):
         and req_headers.get(upgrade, "").lower() == "websocket"
         and req.method == "GET"
     ):
-        return await _handle_websocket_request(req, proxy_url)
+        return await _forward_websocket_request(req, proxy_url)
     try:
-        return await _handle_http_request(req, req_body, proxy_url, backend_server)
+        return await _forward_http_request(
+            req, req_body, proxy_url, _collate_headers(req_headers, backend_server)
+        )
     except web.HTTPFound:
         log.debug("Redirection to path with /default")
         raise
@@ -266,7 +294,23 @@ async def proxy(req):
         raise web.HTTPNotFound() from err
 
 
-async def _handle_websocket_request(
+# Helper private functions
+
+
+def _collate_headers(req_headers: dict, backend_server: dict) -> dict:
+    """Combines request headers with backend server (matlab-proxy) headers.
+
+    Args:
+        req_headers (dict): The headers from the incoming request.
+        backend_server (dict): The backend server configuration.
+
+    Returns:
+        dict: A new dictionary containing all headers from both sources.
+    """
+    return {**req_headers, **backend_server.get("headers")}
+
+
+async def _forward_websocket_request(
     req: web.Request, proxy_url: str
 ) -> web.WebSocketResponse:
     """Handles a websocket request to the backend matlab proxy server
@@ -352,11 +396,11 @@ async def _handle_websocket_request(
             raise aiohttp.WebSocketError(code=code, message=message)
 
 
-# Helper private functions
-
-
-async def _handle_http_request(
-    req: web.Request, req_body: Optional[bytes], proxy_url: str, backend_server: dict
+async def _forward_http_request(
+    req: web.Request,
+    req_body: Optional[bytes],
+    proxy_url: str,
+    headers: dict,
 ) -> web.Response:
     """
     Forwards an incoming HTTP request to a specified backend server.
@@ -370,7 +414,7 @@ async def _handle_http_request(
         proxy_url,
         allow_redirects=True,
         data=req_body,
-        headers=backend_server.get("headers"),
+        headers=headers,
     ) as res:
         headers = res.headers.copy()
         body = await res.read()
@@ -410,16 +454,6 @@ def _render_error_page(error_msg: str) -> web.Response:
     return web.HTTPServiceUnavailable(text=f"Error: {error_msg}")
 
 
-def main() -> None:
-    """
-    The main entry point of the application. Starts the app and run until the shutdown
-    signal to terminate the app is received.
-    """
-    env_vars: namedtuple = _fetch_and_validate_required_env_vars()
-    loop: asyncio.AbstractEventLoop | asyncio.ProactorEventLoop = get_event_loop()
-    loop.run_until_complete(start_app(env_vars))
-
-
 def _fetch_and_validate_required_env_vars() -> namedtuple:
     EnvVars = namedtuple("EnvVars", ["mpm_port", "mpm_auth_token", "mpm_parent_pid"])
 
@@ -428,7 +462,7 @@ def _fetch_and_validate_required_env_vars() -> namedtuple:
     ctx = os.getenv(mpm_env.get_env_name_mwi_mpm_parent_pid())
 
     if not ctx or not port or not mpm_auth_token:
-        print("Error: One or more required environment variables are missing.")
+        log.error("Error: One or more required environment variables are missing.")
         sys.exit(1)
 
     try:
@@ -437,10 +471,19 @@ def _fetch_and_validate_required_env_vars() -> namedtuple:
             mpm_port=mwi_mpm_port, mpm_auth_token=mpm_auth_token, mpm_parent_pid=ctx
         )
     except ValueError as ve:
-        print("Error: Invalid type for port: ", ve)
+        log.error("Error: Invalid type for port: %s", ve)
         sys.exit(1)
 
 
+def main() -> None:
+    """
+    The main entry point of the application. Starts the app and run until the shutdown
+    signal to terminate the app is received.
+    """
+    env_vars: namedtuple = _fetch_and_validate_required_env_vars()
+    asyncio.run(start_app(env_vars))
+
+
 if __name__ == "__main__":
     # This ensures that the app is not created when the module is imported and
     # is only started when the script is run directly or via executable invocation

matlab_proxy_manager/web/monitor.py

@@ -36,10 +36,9 @@ class OrphanedProcessMonitor:
         """
         Triggers the shutdown process by setting the shutdown event.
         """
-        from matlab_proxy_manager.web.app import SHUTDOWN_EVENT
 
         try:
             # Set the shutdown async event to signal app shutdown to the app runner
-            SHUTDOWN_EVENT.set()
+            self.app.get("shutdown_event").set()
         except Exception as ex:
             log.debug("Unable to set proxy manager shutdown event, err: %s", ex)

matlab_proxy_manager/web/watcher.py

@@ -51,4 +51,15 @@ def start_watcher(app: web.Application):
     observer = Observer()
     observer.schedule(event_handler, path_to_watch, recursive=True)
     observer.start()
+    app["observer"] = observer
     return observer
+
+
+def stop_watcher(app):
+    """
+    Stop the file system watcher associated with the application.
+    This function stops and joins the observer thread if it exists in the application.
+    """
+    if "observer" in app:
+        app["observer"].stop()
+        app["observer"].join()

tests/unit/test_app.py

@@ -317,6 +317,7 @@ async def test_get_env_config(test_server):
         "doc_url": "foo",
         "extension_name": "bar",
         "extension_name_short_description": "foobar",
+        "should_show_shutdown_button": True,
         "isConcurrencyEnabled": "foobar",
         "idleTimeoutDuration": 100,
     }

tests/unit/test_app_state.py

@@ -364,9 +364,23 @@ def test_are_required_processes_ready(
     assert actual == expected
 
 
-@pytest.mark.parametrize("platform", [("linux"), ("windows"), ("mac")])
-async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fixture):
-    """Test to check track_embedded_connector task
+# The test: test_track_embedded_connector has been split into:
+# 1) test_track_embedded_connector_posix: Test to check if stop_matlab is called on posix systems.
+# 2) test_track_embedded_connector : Test to check if stop_matlab is not called in windows.
+
+# In windows, errors are shown as UI windows and calling stop_matlab() if MATLAB had not started in
+# PROCESS_TIMEOUT seconds would remove the window thereby leaving the user without knowing why MATLAB
+# failed to start.
+
+
+@pytest.mark.parametrize("platform", [("linux"), ("mac")])
+async def test_track_embedded_connector_posix(
+    mocker_os_patching_fixture, app_state_fixture
+):
+    """Test to check track_embedded_connector task for posix platforms.
+
+    Checks if stop_matlab() has been called when the embedded connector doesn't respond
+    even after PROCESS_TIMEOUT seconds of starting MATLAB.
 
     Args:
         mocker_os_patching_fixture (mocker): Custom pytest fixture for mocking
@@ -374,7 +388,16 @@ async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fi
     """
 
     # Arrange
-    # patching embedded_connector_start_time to EPOCH+1 seconds and state to be "down"
+    # Patching embedded_connector_start_time to EPOCH+1 seconds and state to be "down".
+
+    # For this test, the embedded_connector_start_time can be patched to ant value 600(default PROCESS_TIMEOUT) seconds
+    # before the current time.
+
+    # To always ensure that the time difference between the embedded_connector_start_time
+    # and the current time is greater than PROCESS_TIMEOUT, the embedded_connector_start_time is patched to
+    # EPOCH + 1 seconds so that the time_diff = current_time -  embedded_connector_start_time is greater
+    # than PROCESS_TIMEOUT always evaluates to True.
+
     mocker_os_patching_fixture.patch.object(
         app_state_fixture, "embedded_connector_start_time", new=float(1.0)
     )
@@ -392,6 +415,58 @@ async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fi
     spy.assert_called_once()
 
 
+@pytest.mark.parametrize("platform", [("windows")])
+async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fixture):
+    """Test to check track_embedded_connector task on windows.
+
+    In windows, since errors are shown in native UI windows , calling stop_matlab() would remove them,
+    thereby not knowing the error with which MATLAB failed to start.
+
+    Hence, this test checks that stop_matlab() is not called.
+
+    Args:
+        mocker_os_patching_fixture (mocker): Custom pytest fixture for mocking
+        app_state_fixture (AppState): Object of AppState class with defaults set
+    """
+    # Arrange
+    # Patching embedded_connector_start_time to EPOCH+1 seconds and state to be "down".
+
+    # For this test, the embedded_connector_start_time can be patched to any value 600(default PROCESS_TIMEOUT) seconds
+    # before the current time.
+
+    # To always ensure that the time difference between the embedded_connector_start_time
+    # and the current time is greater than PROCESS_TIMEOUT, the embedded_connector_start_time is patched to
+    # EPOCH + 1 seconds so that the time_diff = current_time -  embedded_connector_start_time is greater
+    # than PROCESS_TIMEOUT always evaluates to True.
+
+    mocker_os_patching_fixture.patch.object(
+        app_state_fixture, "embedded_connector_start_time", new=float(1.0)
+    )
+    mocker_os_patching_fixture.patch.object(
+        app_state_fixture, "embedded_connector_state", return_value="down"
+    )
+
+    spy = mocker_os_patching_fixture.spy(app_state_fixture, "stop_matlab")
+
+    # Act
+
+    # Unlike the posix test (test_track_embedded_connector_posix) where the task track_embedded_connector_state()
+    # would exit automatically after stopping MATLAB, in windows, the task will never exit(until the user checks the error
+    # manually and clicks on "Stop MATLAB").
+
+    # So, the task is manually stopped by raising a timeout error(set to 3 seconds). This is a generous amount of
+    # time for the error to be set as a MatlabError in CI systems.
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(
+            app_state_fixture._AppState__track_embedded_connector_state(),
+            timeout=3,  # timeout of 3 seconds to account for CI systems. This is to wait for the error to be set as MatlabError.
+        )
+
+    # Assert
+    spy.assert_not_called()  # In windows, MATLAB process should not be stopped so that the UI error window is not closed.
+    assert isinstance(app_state_fixture.error, MatlabError)
+
+
 @pytest.mark.parametrize(
     "env_var_name, filter_prefix, is_filtered",
     [("MWI_AUTH_TOKEN", "MWI_", None), ("MWIFOO_AUTH_TOKEN", "MWI_", "foo")],

tests/unit/util/mwi/test_validators.py

@@ -1,7 +1,6 @@
-# Copyright 2020-2023 The MathWorks, Inc.
+# Copyright 2020-2024 The MathWorks, Inc.
 
-"""Tests for functions in matlab_proxy/util/mwi_validators.py
-"""
+"""Tests for functions in matlab_proxy/util/mwi_validators.py"""
 
 import os
 import random
@@ -185,8 +184,8 @@ def test_validate_env_config_true():
 def test_validate_env_config_false():
     """Passing a non existent config should raise FatalError exception"""
 
-    with pytest.raises(FatalError) as e:
-        config = validators.validate_env_config(str(random.randint(10, 100)))
+    with pytest.raises(FatalError):
+        validators.validate_env_config(str(random.randint(10, 100)))
 
 
 def test_get_configs():