matlab-proxy 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

matlab_proxy/app.py

@@ -1,10 +1,11 @@
-# Copyright 2020-2023 The MathWorks, Inc.
+# Copyright 2020-2024 The MathWorks, Inc.
 
 import asyncio
 import json
 import mimetypes
 import pkgutil
 import sys
+import uuid
 
 import aiohttp
 from aiohttp import client_exceptions, web
@@ -19,6 +20,7 @@ from matlab_proxy.util import mwi
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi import token_auth
 from matlab_proxy.util.mwi.exceptions import AppError, InvalidTokenError, LicensingError
+from matlab_proxy.constants import IS_CONCURRENCY_CHECK_ENABLED
 
 
 mimetypes.add_type("font/woff", ".woff")
@@ -93,28 +95,45 @@ def marshal_error(error):
         return {"message": error.__str__, "logs": "", "type": error.__class__.__name__}
 
 
-async def create_status_response(app, loadUrl=None):
-    """Send a generic status response about the state of server,MATLAB and MATLAB Licensing
+async def create_status_response(
+    app, loadUrl=None, client_id=None, transfer_session=False, is_desktop=False
+):
+    """Send a generic status response about the state of server, MATLAB, MATLAB Licensing and the client session status.
 
     Args:
         app (aiohttp.web.Application): Web Server
         loadUrl (String, optional): Represents the root URL. Defaults to None.
+        client_id (String, optional): Represents the unique client_id when concurrency check is enabled. Defaults to None.
+        transfer_session (Boolean, optional): Represents whether the connection should be transfered or not when concurrency check is enabled. Defaults to False.
+        is_desktop (Boolean, optional): Represents whether the request is made by the desktop app or some other kernel. Defaults to False.
 
     Returns:
-        JSONResponse: A JSONResponse object containing the generic state of the server, MATLAB and MATLAB Licensing.
+        JSONResponse: A JSONResponse object containing the generic state of the server, MATLAB, MATLAB Licensing and the client session status.
     """
     state = app["state"]
-    return web.json_response(
-        {
-            "matlab": {
-                "status": await state.get_matlab_state(),
-            },
-            "licensing": marshal_licensing_info(state.licensing),
-            "loadUrl": loadUrl,
-            "error": marshal_error(state.error),
-            "wsEnv": state.settings.get("ws_env", ""),
-        }
-    )
+    status = {
+        "matlab": {
+            "status": await state.get_matlab_state(),
+            "version": state.settings["matlab_version"],
+        },
+        "licensing": marshal_licensing_info(state.licensing),
+        "loadUrl": loadUrl,
+        "error": marshal_error(state.error),
+        "warnings": state.warnings,
+        "wsEnv": state.settings.get("ws_env", ""),
+    }
+
+    if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
+        if not client_id:
+            client_id = str(uuid.uuid4())
+            status["clientId"] = client_id
+
+        if not state.active_client or transfer_session:
+            state.active_client = client_id
+
+        status["isActiveClient"] = True if state.active_client == client_id else False
+
+    return web.json_response(status)
 
 
 @token_auth.authenticate_access_decorator
@@ -150,13 +169,21 @@ async def get_env_config(req):
     """
     state = req.app["state"]
     config = state.settings["env_config"]
-    config["authEnabled"] = state.settings["mwi_is_token_auth_enabled"]
 
     config["useMOS"] = mwi_env.Experimental.should_use_mos_html()
     config["useMRE"] = mwi_env.Experimental.should_use_mre_html()
-
+    config["isConcurrencyEnabled"] = IS_CONCURRENCY_CHECK_ENABLED
     # In a previously authenticated session, if the url is accessed without the token(using session cookie), send the token as well.
-    config["authStatus"] = True if await token_auth.authenticate_request(req) else False
+    config["authentication"] = {
+        "enabled": state.settings["mwi_is_token_auth_enabled"],
+        "status": True if await token_auth.authenticate_request(req) else False,
+    }
+
+    config["matlab"] = {
+        "version": state.settings["matlab_version"],
+        "supported_versions": constants.SUPPORTED_MATLAB_VERSIONS,
+    }
+
     return web.json_response(config)
 
 
@@ -172,7 +199,17 @@ async def get_status(req):
     Returns:
         JSONResponse: JSONResponse object containing information about the server, MATLAB and MATLAB Licensing.
     """
-    return await create_status_response(req.app)
+    # The client sends the CLIENT_ID as a query parameter if the concurrency check has been set to true.
+    client_id = req.query.get("MWI_CLIENT_ID", None)
+    transfer_session = json.loads(req.query.get("TRANSFER_SESSION", "false"))
+    is_desktop = req.query.get("IS_DESKTOP", False)
+
+    return await create_status_response(
+        req.app,
+        client_id=client_id,
+        transfer_session=transfer_session,
+        is_desktop=is_desktop,
+    )
 
 
 # @token_auth.authenticate_access_decorator
@@ -198,7 +235,7 @@ async def authenticate(req):
 
     return web.json_response(
         {
-            "authStatus": is_authenticated,
+            "status": is_authenticated,
             "error": error,
         }
     )
@@ -263,11 +300,20 @@ async def set_licensing_info(req):
             await state.set_licensing_nlm(data.get("connectionString"))
 
         elif lic_type == "mhlm":
+            # If matlab version could not be determined on startup update
+            # the value received from the front-end.
+            if not state.settings.get(
+                "matlab_version_determined_on_startup"
+            ) and data.get("matlabVersion"):
+                state.settings["matlab_version"] = data.get("matlabVersion")
+
             await state.set_licensing_mhlm(
                 data.get("token"), data.get("emailAddress"), data.get("sourceId")
             )
+
         elif lic_type == "existing_license":
             state.set_licensing_existing_license()
+
         else:
             raise Exception(
                 'License type must be "NLM" or "MHLM" or "ExistingLicense"!'
@@ -325,11 +371,18 @@ async def licensing_info_delete(req):
     # Removing license information implies terminating MATLAB
     await state.stop_matlab()
 
+    # When removing licensing data, if matlab version was fetched from the user, remove it
+    # on the server side to have a complete 'reset'.
+    if state.licensing["type"] == "mhlm" and not state.settings.get(
+        "matlab_version_determined_on_startup"
+    ):
+        state.settings["matlab_version"] = None
+
     # Unset licensing information
     state.unset_licensing()
 
-    # Persist licensing information
-    state.persist_licensing()
+    # Persist config information
+    state.persist_config_data()
 
     return await create_status_response(req.app)
 

matlab_proxy/app_state.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2023 The MathWorks, Inc.
+# Copyright 2020-2024 The MathWorks, Inc.
 
 import asyncio
 import contextlib
@@ -17,7 +17,6 @@ from matlab_proxy.settings import (
 from matlab_proxy.constants import (
     CONNECTOR_SECUREPORT_FILENAME,
     MATLAB_LOGS_FILE_NAME,
-    VERSION_INFO_FILE_NAME,
 )
 from matlab_proxy.util import mw, mwi, system, windows
 from matlab_proxy.util.mwi import environment_variables as mwi_env
@@ -85,6 +84,7 @@ class AppState:
 
         # Initialize with the error state from the initialization of settings
         self.error = settings["error"]
+        self.warnings = settings["warnings"]
 
         if self.error is not None:
             self.logs["matlab"].clear()
@@ -100,40 +100,44 @@ class AppState:
         # This variable can be either "up" or "down"
         self.embedded_connector_state = "down"
 
-    def __get_cached_licensing_file(self):
-        """Get the cached licensing file
+        # Specific to concurrent session and is used to track the active client/s that are currently
+        # connected to the backend
+        self.active_client = None
+
+    def __get_cached_config_file(self):
+        """Get the cached config file
 
         Returns:
-            Path : Path object to cached licensing file
+            Path : Path object to cached config file
         """
         return self.settings["matlab_config_file"]
 
-    def __delete_cached_licensing_file(self):
-        """Deletes the cached licensing file"""
+    def __delete_cached_config_file(self):
+        """Deletes the cached config file"""
         try:
-            logger.info(f"Deleting any cached licensing files!")
-            os.remove(self.__get_cached_licensing_file())
+            logger.info(f"Deleting any cached config files!")
+            os.remove(self.__get_cached_config_file())
         except FileNotFoundError:
             # The file being absent is acceptable.
             pass
 
-    def __reset_and_delete_cached_licensing(self):
-        """Reset licensing variable of the class and removes the cached licensing file."""
-        logger.info(f"Resetting cached licensing information...")
+    def __reset_and_delete_cached_config(self):
+        """Reset licensing variable of the class and removes the cached config file."""
+        logger.info(f"Resetting cached config information...")
         self.licensing = None
-        self.__delete_cached_licensing_file()
+        self.__delete_cached_config_file()
 
     async def __update_and_persist_licensing(self):
-        """Update entitlements from mhlm servers and persist licensing
+        """Update entitlements from mhlm servers and persist config data
 
         Returns:
             Boolean: True when entitlements were updated and persisted successfully. False otherwise.
         """
         successful_update = await self.update_entitlements()
         if successful_update:
-            self.persist_licensing()
+            self.persist_config_data()
         else:
-            self.__reset_and_delete_cached_licensing()
+            self.__reset_and_delete_cached_config()
         return successful_update
 
     async def init_licensing(self):
@@ -158,8 +162,8 @@ class AppState:
                 f"!!! Launching MATLAB without providing any additional licensing information. This requires MATLAB to have been activated on the machine from which its being launched !!!"
             )
 
-            # Delete old licensing mode info from cache to ensure its wiped out first before persisting new info.
-            self.__delete_cached_licensing_file()
+            # Delete old config info from cache to ensure its wiped out first before persisting new info.
+            self.__delete_cached_config_file()
 
         # NLM Connection String set in environment
         elif self.settings.get("nlm_conn_str", None) is not None:
@@ -171,17 +175,25 @@ class AppState:
                 "conn_str": nlm_licensing_str,
             }
 
-            # Delete old licensing mode info from cache to ensure its wiped out first before persisting new info.
-            self.__delete_cached_licensing_file()
+            # Delete old config info from cache to ensure its wiped out first before persisting new info.
+            self.__delete_cached_config_file()
 
         # If NLM connection string is not present or if an existing license is not being used,
         # then look for persistent LNU info
-        elif self.__get_cached_licensing_file().exists():
-            with open(self.__get_cached_licensing_file(), "r") as f:
+        elif self.__get_cached_config_file().exists():
+            with open(self.__get_cached_config_file(), "r") as f:
                 logger.debug("Found cached licensing information...")
                 try:
-                    # Load can throw if the file is empty for some reason.
-                    licensing = json.loads(f.read())
+                    # Load can throw if the file is empty or expected fields in the json object are missing.
+                    cached_data = json.loads(f.read())
+                    licensing = cached_data["licensing"]
+                    matlab = cached_data["matlab"]
+
+                    # If Matlab version could not be determined on startup and 'version' is available in
+                    # cached config, update it.
+                    if not self.settings["matlab_version"]:
+                        self.settings["matlab_version"] = matlab["version"]
+
                     if licensing["type"] == "nlm":
                         # Note: Only NLM settings entered in browser were cached.
                         self.licensing = {
@@ -219,15 +231,15 @@ class AppState:
                                     "Using cached Online Licensing to launch MATLAB."
                                 )
                         else:
-                            self.__reset_and_delete_cached_licensing()
+                            self.__reset_and_delete_cached_config()
                     elif licensing["type"] == "existing_license":
                         logger.info("Using cached existing license to launch MATLAB")
                         self.licensing = licensing
                     else:
                         # Somethings wrong, licensing is neither NLM or MHLM
-                        self.__reset_and_delete_cached_licensing()
+                        self.__reset_and_delete_cached_config()
                 except Exception as e:
-                    self.__reset_and_delete_cached_licensing()
+                    self.__reset_and_delete_cached_config()
 
     async def get_matlab_state(self):
         """Determine the state of MATLAB to be down/starting/up.
@@ -255,7 +267,10 @@ class AppState:
             xvfb_process = self.processes["xvfb"]
 
         if system.is_linux():
-            if xvfb_process is None or xvfb_process.returncode is not None:
+            # If Xvfb is on system PATH, check if it up and running.
+            if self.settings["is_xvfb_available"] and (
+                xvfb_process is None or xvfb_process.returncode is not None
+            ):
                 logger.debug(
                     "Xvfb has not started"
                     if xvfb_process is None
@@ -355,12 +370,12 @@ class AppState:
 
         # TODO Validate connection string
         self.licensing = {"type": "nlm", "conn_str": conn_str}
-        self.persist_licensing()
+        self.persist_config_data()
 
     def set_licensing_existing_license(self):
         """Set the licensing type to NLM and the connection string."""
         self.licensing = {"type": "existing_license"}
-        self.persist_licensing()
+        self.persist_config_data()
 
     async def set_licensing_mhlm(
         self,
@@ -461,17 +476,6 @@ class AppState:
                 "MHLM licensing must be configured to update entitlements!"
             )
 
-        # TODO: Updating entitlements requires the matlab version. If it
-        # could not be determined at server startup, take input from the user
-        # for the MATLAB version they intend to start and update settings.
-
-        # As MHLM licensing requires matlab version to update entitlements, if it couldn't be determined
-        # for now show an error to the user to set MWI_CUSTOM_MATLAB_ROOT env var.
-        if self.settings["matlab_version"] is None:
-            raise UIVisibleFatalError(
-                f"Could not find {VERSION_INFO_FILE_NAME} file at MATLAB root. Set {mwi_env.get_env_name_custom_matlab_root()} to a valid MATLAB root path"
-            )
-
         try:
             # Fetch an access token
             access_token_data = await mw.fetch_access_token(
@@ -532,19 +536,23 @@ class AppState:
     async def update_user_selected_entitlement_info(self, entitlement_id):
         self.licensing["entitlement_id"] = entitlement_id
         logger.debug(f"Successfully set {entitlement_id} as the entitlement_id")
-        self.persist_licensing()
+        self.persist_config_data()
 
-    def persist_licensing(self):
-        """Saves licensing information to file"""
+    def persist_config_data(self):
+        """Saves config information to file"""
         if self.licensing is None:
-            self.__delete_cached_licensing_file()
+            self.__delete_cached_config_file()
 
         elif self.licensing["type"] in ["mhlm", "nlm", "existing_license"]:
             logger.debug("Saving licensing information...")
-            cached_licensing_file = self.__get_cached_licensing_file()
-            cached_licensing_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(cached_licensing_file, "w") as f:
-                f.write(json.dumps(self.licensing))
+            cached_config_file = self.__get_cached_config_file()
+            cached_config_file.parent.mkdir(parents=True, exist_ok=True)
+            config = {
+                "licensing": self.licensing,
+                "matlab": {"version": self.settings["matlab_version"]},
+            }
+            with open(cached_config_file, "w") as f:
+                f.write(json.dumps(config))
 
     def create_logs_dir_for_MATLAB(self):
         """Creates the root folder where MATLAB writes the ready file and updates attibutes on self."""
@@ -671,9 +679,22 @@ class AppState:
         # DDUX info for MATLAB
         matlab_env["MW_CONTEXT_TAGS"] = self.settings.get("mw_context_tags")
 
+        # Update DISPLAY env variable for MATLAB only if it was supplied by Xvfb.
         if system.is_linux():
-            # Adding DISPLAY key which is only available after starting Xvfb successfully.
-            matlab_env["DISPLAY"] = self.settings["matlab_display"]
+            if self.settings.get("matlab_display", None):
+                matlab_env["DISPLAY"] = self.settings["matlab_display"]
+                logger.info(
+                    f"Using the display number supplied by Xvfb process:{matlab_env['DISPLAY']} for launching MATLAB"
+                )
+            else:
+                if "DISPLAY" in matlab_env:
+                    logger.info(
+                        f"Using the existing DISPLAY environment variable with value:{matlab_env['DISPLAY']} for launching MATLAB"
+                    )
+                else:
+                    logger.info(
+                        "No DISPLAY environment variable found. Launching MATLAB without it."
+                    )
 
         # The matlab ready file is written into this location(self.mwi_logs_dir) by MATLAB
         # The mwi_logs_dir is where MATLAB will write any subsequent logs
@@ -968,8 +989,8 @@ class AppState:
         self.error = None
         self.logs["matlab"].clear()
 
-        # Start Xvfb process if in a posix system
-        if system.is_linux():
+        # Start Xvfb process on linux if possible
+        if system.is_linux() and self.settings["is_xvfb_available"]:
             xvfb = await self.__start_xvfb_process()
 
             # xvfb variable would be None if creation of the process failed.

matlab_proxy/constants.py

@@ -1,5 +1,5 @@
-# Copyright 2023 The MathWorks, Inc.
-from typing import Final
+# Copyright 2023-2024 The MathWorks, Inc.
+from typing import Final, List
 
 """This module defines project-level constants"""
 
@@ -12,3 +12,16 @@ MATLAB_LOGS_FILE_NAME: Final[str] = "matlab_logs.txt"
 # 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: Final[int] = 600
+
+SUPPORTED_MATLAB_VERSIONS: Final[List[str]] = [
+    "R2020b",
+    "R2021a",
+    "R2021b",
+    "R2022a",
+    "R2022b",
+    "R2023a",
+    "R2023b",
+]
+
+# This constant when set to True restricts the number of active sessions to one
+IS_CONCURRENCY_CHECK_ENABLED: Final[bool] = True

matlab_proxy/gui/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
-    "main.css": "./static/css/main.aa888962.css",
-    "main.js": "./static/js/main.fbc5c728.js",
+    "main.css": "./static/css/main.47712126.css",
+    "main.js": "./static/js/main.ea1ebdce.js",
     "static/media/mathworks-pictograms.svg?20181009": "./static/media/mathworks-pictograms.f6f087b008b5a9435f26.svg",
     "static/media/MATLAB-env-blur.png": "./static/media/MATLAB-env-blur.4fc94edbc82d3184e5cb.png",
     "static/media/mathworks.svg?20181004": "./static/media/mathworks.80a3218e1ba29f0573fb.svg",
@@ -34,11 +34,11 @@
     "index.html": "./index.html",
     "static/media/gripper.svg": "./static/media/gripper.9defbc5e76d0de8bb6e0.svg",
     "static/media/arrow.svg": "./static/media/arrow.0c2968b90bd9a64c8c3f.svg",
-    "main.aa888962.css.map": "./static/css/main.aa888962.css.map",
-    "main.fbc5c728.js.map": "./static/js/main.fbc5c728.js.map"
+    "main.47712126.css.map": "./static/css/main.47712126.css.map",
+    "main.ea1ebdce.js.map": "./static/js/main.ea1ebdce.js.map"
   },
   "entrypoints": [
-    "static/css/main.aa888962.css",
-    "static/js/main.fbc5c728.js"
+    "static/css/main.47712126.css",
+    "static/js/main.ea1ebdce.js"
   ]
 }

matlab_proxy/gui/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="MATLAB"/><meta name="internal_mw_identifier" content="MWI_MATLAB_PROXY_IDENTIFIER"/><link rel="manifest" href="./manifest.json"/><title>MATLAB</title><script defer="defer" src="./static/js/main.fbc5c728.js"></script><link href="./static/css/main.aa888962.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="MATLAB"/><meta name="internal_mw_identifier" content="MWI_MATLAB_PROXY_IDENTIFIER"/><link rel="manifest" href="./manifest.json"/><title>MATLAB</title><script defer="defer" src="./static/js/main.ea1ebdce.js"></script><link href="./static/css/main.47712126.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>