matlab-proxy 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

matlab_proxy_manager/web/app.py

@@ -1,4 +1,4 @@
-# Copyright 2024 The MathWorks, Inc.
+# Copyright 2024-2025 The MathWorks, Inc.
 
 import asyncio
 import os
@@ -14,6 +14,7 @@ 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
+import matlab_proxy.constants as mp_constants
 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
@@ -44,6 +45,9 @@ def init_app() -> web.Application:
     # Async event is utilized to signal app termination from this and other modules
     app["shutdown_event"] = asyncio.Event()
 
+    # Tracks whether default matlab proxy is started or not
+    app["has_default_matlab_proxy_started"] = False
+
     # Create and get the proxy manager data directory
     try:
         data_dir = helpers.create_and_get_proxy_manager_data_dir()
@@ -54,6 +58,10 @@ def init_app() -> web.Application:
     # Setup idle timeout monitor for the app
     monitor = OrphanedProcessMonitor(app)
 
+    # Load existing matlab proxy servers into app state for consistency
+    app["servers"] = helpers.pre_load_from_state_file(app.get("data_dir"))
+    log.debug("Loaded existing matlab proxy servers into app state: %s", app["servers"])
+
     async def start_idle_monitor(app):
         """Start the idle timeout monitor."""
         app["monitor_task"] = asyncio.create_task(monitor.start())
@@ -102,7 +110,7 @@ def init_app() -> web.Application:
     return app
 
 
-async def start_app(env_vars: namedtuple):
+async def start_app(env_vars):
     """
     Initialize and start the web application.
 
@@ -118,9 +126,7 @@ async def start_app(env_vars: namedtuple):
     app["port"] = env_vars.mpm_port
     app["auth_token"] = env_vars.mpm_auth_token
     app["parent_pid"] = env_vars.mpm_parent_pid
-
-    # Start default matlab proxy
-    await _start_default_proxy(app)
+    app["base_url_prefix"] = env_vars.base_url_prefix
 
     web_logger = None if not mwi_env.is_web_logging_enabled() else log
 
@@ -175,6 +181,8 @@ def _register_signal_handler(loop, app):
 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
+    # Ideally, we should minimize the work done when we catch exit signals, which would mean the
+    # polling for parent process should happen elsewhere
     helpers.poll_for_server_deletion()
     app.get("shutdown_event").set()
 
@@ -190,13 +198,13 @@ async def _start_default_proxy(app):
         parent_id=app.get("parent_pid"),
         is_shared_matlab=True,
         mpm_auth_token=app.get("auth_token"),
+        base_url_prefix=app.get("base_url_prefix"),
     )
-    if not server_process:
-        log.error("Failed to start default matlab proxy using Jupyter")
-        return
+    errors = server_process.get("errors")
 
-    # Load existing matlab proxy servers into app state for consistency
-    app["servers"] = helpers.pre_load_from_state_file(app.get("data_dir"))
+    # Raising an exception if there was an error starting the default MATLAB proxy
+    if errors:
+        raise Exception(":".join(errors))
 
     # Add the new/existing server to the app state
     app["servers"][server_process.get("id")] = server_process
@@ -259,12 +267,21 @@ async def proxy(req):
             f"Required header: ${constants.HEADER_MWI_MPM_CONTEXT} not found in the request"
         )
 
+    # Raising exception from here is not cleanly handled by Jupyter server proxy.
+    # It only shows 599 with a generic stream closed error message.
+    # Hence returning 503 with custom error message as response.
+    try:
+        await _start_default_proxy_if_not_already_started(req)
+    except Exception as e:
+        log.error("Error starting default proxy: %s", e)
+        return _render_error_page(f"Error during startup: {e}")
+
     client_key = f"{ctx}_{ident}"
     default_key = f"{ctx}_default"
     group_two_rel_url = match.group(2)
 
     backend_server = _get_backend_server(req, client_key, default_key)
-    proxy_url = f'{backend_server.get("absolute_url")}/{group_two_rel_url}'
+    proxy_url = f"{backend_server.get('absolute_url')}/{group_two_rel_url}"
     log.debug("Proxy URL: %s", proxy_url)
 
     if (
@@ -326,7 +343,9 @@ async def _forward_websocket_request(
     Returns:
         web.WebSocketResponse: The response from the backend server
     """
-    ws_server = web.WebSocketResponse()
+    ws_server = web.WebSocketResponse(
+        max_msg_size=mp_constants.MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB, compress=True
+    )
     await ws_server.prepare(req)
 
     async with aiohttp.ClientSession(
@@ -335,7 +354,11 @@ async def _forward_websocket_request(
         connector=aiohttp.TCPConnector(ssl=False),
     ) as client_session:
         try:
-            async with client_session.ws_connect(proxy_url) as ws_client:
+            async with client_session.ws_connect(
+                proxy_url,
+                max_msg_size=mp_constants.MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB,  # max websocket message size from MATLAB to browser
+                compress=12,  # enable websocket messages compression
+            ) as ws_client:
 
                 async def ws_forward(ws_src, ws_dest):
                     async for msg in ws_src:
@@ -373,6 +396,13 @@ async def _forward_websocket_request(
                             await ws_dest.close(
                                 code=ws_dest.close_code, message=msg.extra
                             )
+                        elif msg_type == aiohttp.WSMsgType.ERROR:
+                            log.error(f"WebSocket error received: {msg}")
+                            if "exceeds limit" in str(msg.data):
+                                log.error(
+                                    f"Message too large: {msg.data}. Please refresh browser tab to reconnect."
+                                )
+                            break
                         else:
                             raise ValueError(f"Unexpected message type: {msg}")
 
@@ -421,6 +451,20 @@ async def _forward_http_request(
         return web.Response(headers=headers, status=res.status, body=body)
 
 
+async def _start_default_proxy_if_not_already_started(req):
+    app = req.app
+    req_path = req.rel_url
+
+    # Start default matlab-proxy only when it is not already started and
+    # if the request path contains the default MATLAB path (/matlab/default)
+    if not app.get(
+        "has_default_matlab_proxy_started", False
+    ) and constants.MWI_DEFAULT_MATLAB_PATH in str(req_path):
+        log.debug("Starting default matlab-proxy for request path: %s", str(req_path))
+        await _start_default_proxy(app)
+        app["has_default_matlab_proxy_started"] = True
+
+
 def _get_backend_server(req: web.Request, client_key: str, default_key: str) -> dict:
     """
     Retrieves the backend server configuration for a given client key.
@@ -444,18 +488,22 @@ def _redirect_to_default(req_path) -> None:
     Raises:
         web.HTTPFound: Redirects the client to the new URL.
     """
-    new_redirect_url = f'{str(req_path).rstrip("/")}/default/'
+    new_redirect_url = f"{str(req_path).rstrip('/')}/default/"
     log.info("Redirecting to %s", new_redirect_url)
     raise web.HTTPFound(new_redirect_url)
 
 
 def _render_error_page(error_msg: str) -> web.Response:
     """Returns 503 with error text"""
-    return web.HTTPServiceUnavailable(text=f"Error: {error_msg}")
+    return web.HTTPServiceUnavailable(
+        text=f'<p style="color: red;">{error_msg}</p>', content_type="text/html"
+    )
 
 
-def _fetch_and_validate_required_env_vars() -> namedtuple:
-    EnvVars = namedtuple("EnvVars", ["mpm_port", "mpm_auth_token", "mpm_parent_pid"])
+def _fetch_and_validate_required_env_vars():
+    EnvVars = namedtuple(
+        "EnvVars", ["mpm_port", "mpm_auth_token", "mpm_parent_pid", "base_url_prefix"]
+    )
 
     port = os.getenv(mpm_env.get_env_name_mwi_mpm_port())
     mpm_auth_token = os.getenv(mpm_env.get_env_name_mwi_mpm_auth_token())
@@ -466,9 +514,13 @@ def _fetch_and_validate_required_env_vars() -> namedtuple:
         sys.exit(1)
 
     try:
+        base_url_prefix = os.getenv(mpm_env.get_env_name_base_url_prefix(), "")
         mwi_mpm_port: int = int(port)
         return EnvVars(
-            mpm_port=mwi_mpm_port, mpm_auth_token=mpm_auth_token, mpm_parent_pid=ctx
+            mpm_port=mwi_mpm_port,
+            mpm_auth_token=mpm_auth_token,
+            mpm_parent_pid=ctx,
+            base_url_prefix=base_url_prefix,
         )
     except ValueError as ve:
         log.error("Error: Invalid type for port: %s", ve)
@@ -480,7 +532,7 @@ 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()
+    env_vars = _fetch_and_validate_required_env_vars()
     asyncio.run(start_app(env_vars))
 
 

tests/unit/test_app.py

@@ -7,7 +7,7 @@ import platform
 import random
 import time
 from datetime import timedelta, timezone
-from http import HTTPStatus
+from http import HTTPStatus, cookies
 
 import pytest
 from aiohttp import WSMsgType
@@ -19,7 +19,9 @@ from matlab_proxy import app, util
 from matlab_proxy.app import matlab_view
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi.exceptions import EntitlementError, MatlabInstallError
-from tests.unit.fixtures.fixture_auth import patch_authenticate_access_decorator
+from tests.unit.fixtures.fixture_auth import (
+    patch_authenticate_access_decorator,  # noqa: F401
+)
 from tests.unit.mocks.mock_client import MockWebSocketClient
 
 
@@ -236,8 +238,8 @@ class FakeServer:
     Setting up the server in the context of Pytest.
     """
 
-    def __init__(self, loop, aiohttp_client):
-        self.loop = loop
+    def __init__(self, event_loop, aiohttp_client):
+        self.loop = event_loop
         self.aiohttp_client = aiohttp_client
 
     def __enter__(self):
@@ -256,7 +258,11 @@ def mock_request(mocker):
     req = mocker.MagicMock()
     req.app = {
         "state": mocker.MagicMock(matlab_port=8000),
-        "settings": {"matlab_protocol": "http", "mwapikey": "test-key"},
+        "settings": {
+            "matlab_protocol": "http",
+            "mwapikey": "test-key",
+            "cookie_jar": None,
+        },
     }
     req.headers = CIMultiDict()
     req.cookies = {}
@@ -275,11 +281,7 @@ def mock_messages(mocker):
 
 
 @pytest.fixture(name="test_server")
-def test_server_fixture(
-    event_loop,
-    aiohttp_client,
-    monkeypatch,
-):
+def test_server_fixture(event_loop, aiohttp_client, monkeypatch, request):
     """A pytest fixture which yields a test server to be used by tests.
 
     Args:
@@ -289,18 +291,29 @@ def test_server_fixture(
     Yields:
         aiohttp_client : A aiohttp_client server used by tests.
     """
-    # Disabling the authentication token mechanism explicitly
-    monkeypatch.setenv(mwi_env.get_env_name_enable_mwi_auth_token(), "False")
+    # Default set of environment variables for testing convenience
+    default_env_vars_for_testing = [
+        (mwi_env.get_env_name_enable_mwi_auth_token(), "False")
+    ]
+    custom_env_vars = getattr(request, "param", None)
+
+    if custom_env_vars:
+        default_env_vars_for_testing.extend(custom_env_vars)
+
+    for env_var_name, env_var_value in default_env_vars_for_testing:
+        monkeypatch.setenv(env_var_name, env_var_value)
+
     try:
         with FakeServer(event_loop, aiohttp_client) as test_server:
             yield test_server
+
     except ProcessLookupError:
         pass
+
     finally:
-        # Cleaning up the env variable related to auth token
-        monkeypatch.delenv(
-            mwi_env.get_env_name_enable_mwi_auth_token(), raising="False"
-        )
+        # Cleaning up the environment variables set for testing
+        for env_var_name, _ in default_env_vars_for_testing:
+            monkeypatch.delenv(env_var_name, raising="False")
 
 
 async def test_get_status_route(test_server):
@@ -689,7 +702,7 @@ async def test_matlab_view_websocket_success(
     mock_request,
     mock_websocket_messages,
     headers,
-    patch_authenticate_access_decorator,
+    patch_authenticate_access_decorator,  # noqa: F401
 ):
     """Test successful websocket connection and message forwarding"""
 
@@ -1198,3 +1211,89 @@ async def test_check_for_concurrency(test_server):
         status_resp_json = json.loads(await status_resp.text())
         assert "clientId" not in status_resp_json
         assert "isActiveClient" not in status_resp_json
+
+
+# Pytest construct to set the environment variable `MWI_ENABLE_COOKIE_JAR` to `"True"`
+# before initializing the test_server.
+@pytest.mark.parametrize(
+    "test_server",
+    [
+        [(mwi_env.Experimental.get_env_name_use_cookie_cache(), "True")],
+    ],
+    indirect=True,
+)
+async def test_cookie_jar_http_request(proxy_payload, test_server):
+    # Arrange
+    actual_custom_cookie = cookies.Morsel()
+    actual_custom_cookie.set("custom_cookie", "cookie_value", "cookie_value")
+    actual_custom_cookie["domain"] = "example.com"
+    actual_custom_cookie["path"] = "/"
+    actual_custom_cookie["HttpOnly"] = True
+    actual_custom_cookie["expires"] = (
+        datetime.datetime.now() + timedelta(days=1)
+    ).strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
+    await wait_for_matlab_to_be_up(test_server, test_constants.ONE_SECOND_DELAY)
+
+    # Manually update cookie in cookie jar
+    test_server.app["settings"]["cookie_jar"]._cookie_jar[
+        "custom_cookie"
+    ] = actual_custom_cookie
+
+    # Act
+    async with await test_server.get(
+        "/http_get_request.html", data=json.dumps(proxy_payload)
+    ) as _:
+        expected_custom_cookie = test_server.app["settings"]["cookie_jar"]._cookie_jar[
+            "custom_cookie"
+        ]
+
+        # Assert
+        assert actual_custom_cookie == expected_custom_cookie
+
+
+# Pytest construct to set the environment variable `MWI_ENABLE_COOKIE_JAR` to `"True"`
+# before initializing the test_server.
+@pytest.mark.parametrize(
+    "test_server",
+    [
+        [(mwi_env.Experimental.get_env_name_use_cookie_cache(), "True")],
+    ],
+    indirect=True,
+)
+async def test_cookie_jar_web_socket(proxy_payload, test_server):
+    # Arrange
+
+    # Createa a custom cookie
+    actual_custom_cookie = cookies.Morsel()
+    actual_custom_cookie.set("custom_cookie", "cookie_value", "cookie_value")
+    actual_custom_cookie["domain"] = "example.com"
+    actual_custom_cookie["path"] = "/"
+    actual_custom_cookie["expires"] = (
+        datetime.datetime.now() + timedelta(days=1)
+    ).strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
+    # Update cookie in cookie jar
+    test_server.app["settings"]["cookie_jar"]._cookie_jar[
+        "custom_cookie"
+    ] = actual_custom_cookie
+
+    await wait_for_matlab_to_be_up(test_server, test_constants.ONE_SECOND_DELAY)
+
+    # Act
+    async with test_server.get(
+        "/http_ws_request.html/",
+        headers={
+            # Headers required to initiate a websocket connection
+            # First 2 headers are required for the connection upgrade
+            "Connection": "upgrade",
+            "upgrade": "websocket",
+            "Sec-WebSocket-Version": "13",  # Required for initiating the websocket handshake with aiohttp server
+            "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",  # Optional unique key for the websocket handshake
+        },
+    ) as _:
+        expected_custom_cookie = test_server.app["settings"]["cookie_jar"]._cookie_jar[
+            "custom_cookie"
+        ]
+        # Assert
+        assert actual_custom_cookie == expected_custom_cookie

tests/unit/test_settings.py

@@ -1,15 +1,16 @@
 # Copyright 2020-2025 The MathWorks, Inc.
 
 import os
-import time
 import tempfile
-import platform
+import time
+from pathlib import Path
+
+import pytest
 
 import matlab_proxy
 import matlab_proxy.settings as settings
-from matlab_proxy.constants import VERSION_INFO_FILE_NAME, DEFAULT_PROCESS_START_TIMEOUT
-from pathlib import Path
-import pytest
+from matlab_proxy.constants import DEFAULT_PROCESS_START_TIMEOUT, VERSION_INFO_FILE_NAME
+from matlab_proxy.util.cookie_jar import HttpOnlyCookieJar
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi.exceptions import MatlabInstallError
 
@@ -122,7 +123,7 @@ def mock_shutil_which_fixture(mocker, fake_matlab_executable_path):
 @pytest.fixture(name="non_existent_path")
 def non_existent_path_fixture(tmp_path):
     # Build path to a non existent folder
-    random_folder = tmp_path / f'{str(time.time()).replace(".", "")}'
+    random_folder = tmp_path / f"{str(time.time()).replace('.', '')}"
     non_existent_path = Path(tmp_path) / random_folder
 
     return non_existent_path
@@ -657,3 +658,22 @@ def test_get_matlab_settings_invalid_custom_matlab_root(mocker, monkeypatch, tmp
         and mwi_env.get_env_name_custom_matlab_root()
         in matlab_settings["error"].message
     )
+
+
+def test_get_cookie_jar(monkeypatch):
+    """Test to check if Cookie Jar is returned as a part of server settings"""
+    monkeypatch.setenv(mwi_env.Experimental.get_env_name_use_cookie_cache(), "false")
+    assert (
+        settings.get_server_settings(matlab_proxy.get_default_config_name())[
+            "cookie_jar"
+        ]
+        is None
+    )
+
+    monkeypatch.setenv(mwi_env.Experimental.get_env_name_use_cookie_cache(), "true")
+    assert isinstance(
+        settings.get_server_settings(matlab_proxy.get_default_config_name())[
+            "cookie_jar"
+        ],
+        HttpOnlyCookieJar,
+    )