matlab-proxy 0.25.1__py3-none-any.whl → 0.27.0__py3-none-any.whl

matlab_proxy/app.py

@@ -209,6 +209,8 @@ async def get_env_config(req):
         "supportedVersions": constants.SUPPORTED_MATLAB_VERSIONS,
     }
 
+    config["browserTitle"] = state.settings["browser_title"]
+
     # Send timeout duration for the idle timer as part of the response
     config["idleTimeoutDuration"] = state.settings["mwi_idle_timeout"]
 
@@ -283,6 +285,10 @@ async def start_matlab(req):
         JSONResponse: JSONResponse object containing updated information on the state of MATLAB among other information.
     """
     state = req.app["state"]
+    cookie_jar = req.app["settings"]["cookie_jar"]
+
+    if cookie_jar:
+        cookie_jar.clear()
 
     # Start MATLAB
     await state.start_matlab(restart_matlab=True)
@@ -349,7 +355,7 @@ async def set_licensing_info(req):
             raise Exception(
                 'License type must be "NLM" or "MHLM" or "ExistingLicense"!'
             )
-    except Exception as e:
+    except Exception:
         raise web.HTTPBadRequest(text="Error with licensing!")
 
     # This is true for a user who has only one license associated with their account
@@ -493,7 +499,7 @@ def make_static_route_table(app):
     Returns:
         Dict: Containing information about the static files and header information.
     """
-    import importlib_resources
+    import importlib_resources as resources
 
     from matlab_proxy import gui
     from matlab_proxy.gui import static
@@ -505,14 +511,14 @@ def make_static_route_table(app):
 
     for mod, parent in [
         (gui.__name__, ""),
-        (gui.static.__name__, "/static"),
-        (gui.static.css.__name__, "/static/css"),
-        (gui.static.js.__name__, "/static/js"),
-        (gui.static.media.__name__, "/static/media"),
+        (static.__name__, "/static"),
+        (css.__name__, "/static/css"),
+        (js.__name__, "/static/js"),
+        (media.__name__, "/static/media"),
     ]:
-        for entry in importlib_resources.files(mod).iterdir():
+        for entry in resources.files(mod).iterdir():
             name = entry.name
-            if not importlib_resources.files(mod).joinpath(name).is_dir():
+            if not resources.files(mod).joinpath(name).is_dir():
                 if name != "__init__.py":
                     # Special case for manifest.json
                     if "manifest.json" in name:
@@ -557,6 +563,9 @@ async def matlab_view(req):
     matlab_protocol = req.app["settings"]["matlab_protocol"]
     mwapikey = req.app["settings"]["mwapikey"]
     matlab_base_url = f"{matlab_protocol}://127.0.0.1:{matlab_port}"
+    cookie_jar = req.app["settings"]["cookie_jar"]
+
+    cookies_from_jar = cookie_jar.get_dict() if cookie_jar else None
 
     # If we are trying to send request to matlab while the matlab_port is still not assigned
     # by embedded connector, return service not available and log a message
@@ -575,17 +584,23 @@ async def matlab_view(req):
         and reqH.get(UPGRADE, "").lower() == "websocket"
         and req.method == "GET"
     ):
-        ws_server = web.WebSocketResponse()
+        ws_server = web.WebSocketResponse(
+            max_msg_size=constants.MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB, compress=True
+        )
         await ws_server.prepare(req)
 
         async with aiohttp.ClientSession(
+            cookies=(
+                cookies_from_jar if cookie_jar else req.cookies
+            ),  # If cookie jar is not provided, use the cookies from the incoming request
             trust_env=True,
-            cookies=req.cookies,
             connector=aiohttp.TCPConnector(ssl=False),
         ) as client_session:
             try:
                 async with client_session.ws_connect(
                     matlab_base_url + req.path_qs,
+                    max_msg_size=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 wsforward(ws_from, ws_to):
@@ -617,16 +632,28 @@ async def matlab_view(req):
                                 await ws_to.close(
                                     code=ws_to.close_code, message=msg.extra
                                 )
+                            elif mt == aiohttp.WSMsgType.ERROR:
+                                logger.error(f"WebSocket error received: {msg}")
+                                if "exceeds limit" in str(msg.data):
+                                    logger.error(
+                                        f"Message too large: {msg.data}. Please refresh browser tab to reconnect."
+                                    )
+                                break
                             else:
                                 raise ValueError(f"Unexpected message type: {msg}")
 
                     await asyncio.wait(
                         [
-                            asyncio.create_task(wsforward(ws_server, ws_client)),
-                            asyncio.create_task(wsforward(ws_client, ws_server)),
+                            asyncio.create_task(
+                                wsforward(ws_server, ws_client)
+                            ),  # browser to MATLAB
+                            asyncio.create_task(
+                                wsforward(ws_client, ws_server)
+                            ),  # MATLAB to browser
                         ],
                         return_when=asyncio.FIRST_COMPLETED,
                     )
+
                     return ws_server
 
             except Exception as err:
@@ -666,11 +693,37 @@ async def matlab_view(req):
                     allow_redirects=False,
                     data=req_body,
                     params=None,
+                    cookies=cookies_from_jar,  # Pass cookies from  cookie_jar for HTTP requests to MATLAB. This value will
+                    # be none if cookie jar is not enabled
                 ) as res:
                     headers = res.headers.copy()
                     body = await res.read()
-                    headers.update(req.app["settings"]["mwi_custom_http_headers"])
-                    return web.Response(headers=headers, status=res.status, body=body)
+
+                    response = web.Response(
+                        status=res.status, headers=headers, body=body
+                    )
+
+                    # Purpose of the cookie-jar in matlab-proxy is to:
+                    # 1) Update the cookies within it when the Embedded Connector sends back Set-Cookie headers in the response.
+                    # 2) Read these cookies from the cookie jar and insert them into subsequent requests to the Embedded Connector.
+
+                    # Due to matlab-proxy's PING requests to EC, the number cookies present in the cookie-jar and their
+                    # value will be more than the ones present on the browser side.
+                    # Example: The JSESSIONID cookie will be present in the cookie-jar but not on the browser side.
+                    # This inconsistency of cookies between the browser and matlab-proxy's cookie-jar is expected and okay
+                    # as these cookies are HttpOnly cookies.
+
+                    # Incase the Embedded Connector sends cookies which are not HttpOnly, then additional logic needs to be written
+                    # to update the response with cookies from the cookie jar before it is forwarded to the browser.
+                    if cookie_jar:
+                        # Update the cookies in the cookie jar with the Set-Cookie headers in the response.
+                        cookie_jar.update_from_response_headers(headers)
+
+                    response.headers.update(
+                        req.app["settings"]["mwi_custom_http_headers"]
+                    )
+
+                    return response
 
             # Handles any pending HTTP requests from the browser when the MATLAB process is terminated before responding to them.
             except (
@@ -852,7 +905,7 @@ def configure_and_start(app):
 
     logger.debug("Starting MATLAB proxy app")
     logger.debug(
-        f' with base_url: {app["settings"]["base_url"]} and app_port:{app["settings"]["app_port"]}.'
+        f" with base_url: {app['settings']['base_url']} and app_port:{app['settings']['app_port']}."
     )
 
     app["state"].create_server_info_file()
@@ -987,7 +1040,6 @@ def print_version_and_exit():
 
 def main():
     """Starting point of the integration. Creates the web app and runs indefinitely."""
-
     if util.parse_cli_args()["version"]:
         print_version_and_exit()
 

matlab_proxy/app_state.py

@@ -896,8 +896,14 @@ class AppState:
 
         mwi_server_info_file = mwi_logs_dir / "mwi_server.info"
         mwi_auth_token_str = token_auth.get_mwi_auth_token_access_str(self.settings)
-        with open(mwi_server_info_file, "w") as fh:
-            fh.write(self.settings["mwi_server_url"] + mwi_auth_token_str + "\n")
+        with open(mwi_server_info_file, "w", encoding="utf-8") as fh:
+            fh.write(
+                self.settings["mwi_server_url"]
+                + mwi_auth_token_str
+                + "\n"
+                + self.settings["browser_title"]
+                + "\n"
+            )
         self.mwi_server_session_files["mwi_server_info_file"] = mwi_server_info_file
         logger.debug(f"Server info stored into: {mwi_server_info_file}")
 

matlab_proxy/constants.py

@@ -6,6 +6,7 @@ from typing import Final, List
 CONNECTOR_SECUREPORT_FILENAME: Final[str] = "connector.securePort"
 VERSION_INFO_FILE_NAME: Final[str] = "VersionInfo.xml"
 MAX_HTTP_REQUEST_SIZE: Final[int] = 500_000_000  # 500MB
+MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB: Final[int] = 500_000_000  # 500MB
 MATLAB_LOGS_FILE_NAME: Final[str] = "matlab_logs.txt"
 USER_CODE_OUTPUT_FILE_NAME: Final[str] = "startup_code_output.txt"
 

matlab_proxy/default_configuration.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 The MathWorks, Inc.
+# Copyright 2020-2025 The MathWorks, Inc.
 from enum import Enum
 from typing import List
 
@@ -45,7 +45,7 @@ def get_required_config() -> List[str]:
         list: A list of strings representing the required
         configuration keys.
     """
-    required_keys: List[str] = [
+    required_keys: List[ConfigKeys] = [
         ConfigKeys.DOC_URL,
         ConfigKeys.EXT_NAME,
         ConfigKeys.EXT_NAME_DESC,

matlab_proxy/gui/index.html

@@ -11,7 +11,7 @@
     <meta name="internal_mw_identifier" content="MWI_MATLAB_PROXY_IDENTIFIER" />
     <link rel="manifest" href="./manifest.json" />
     <title>MATLAB</title>
-    <script type="module" crossorigin src="./static/js/index.CZgGkMCD.js"></script>
+    <script type="module" crossorigin src="./static/js/index.BcDShXfH.js"></script>
     <link rel="stylesheet" crossorigin href="./static/css/index.BSVLACuY.css">
   </head>
   <body>