Fixes issues related to base url configurations from jupyter environments.

Author: krisctl

matlab_proxy_manager/lib/api.py

@@ -3,14 +3,14 @@
 import os
 import secrets
 import subprocess
-from typing import List, Optional, Tuple
+from typing import List, Tuple
 
 import matlab_proxy
-import matlab_proxy.util.system as mwi_sys
 import matlab_proxy.util.mwi.environment_variables as mwi_env
+import matlab_proxy.util.system as mwi_sys
 from matlab_proxy_manager.storage.file_repository import FileRepository
 from matlab_proxy_manager.storage.server import ServerProcess
-from matlab_proxy_manager.utils import constants, helpers, logger, exceptions
+from matlab_proxy_manager.utils import constants, exceptions, helpers, logger
 
 # Used to list all the public-facing APIs exported by this module.
 __all__ = ["shutdown", "start_matlab_proxy_for_kernel", "start_matlab_proxy_for_jsp"]
@@ -21,7 +21,7 @@
 
 
 async def start_matlab_proxy_for_kernel(
- caller_id: str, parent_id: str, is_shared_matlab: bool
+ caller_id: str, parent_id: str, is_shared_matlab: bool, base_url_prefix: str = ""
 ):
  """
  Starts a MATLAB proxy server specifically for MATLAB Kernel.
@@ -30,12 +30,18 @@ async def start_matlab_proxy_for_kernel(
  set to None, for starting the MATLAB proxy server via proxy manager.
  """
  return await _start_matlab_proxy(
- caller_id=caller_id, ctx=parent_id, is_shared_matlab=is_shared_matlab
+ caller_id=caller_id,
+ ctx=parent_id,
+ is_shared_matlab=is_shared_matlab,
+ base_url_prefix=base_url_prefix,
  )
 
 
 async def start_matlab_proxy_for_jsp(
- parent_id: str, is_shared_matlab: bool, mpm_auth_token: str
+ parent_id: str,
+ is_shared_matlab: bool,
+ mpm_auth_token: str,
+ base_url_prefix: str = "",
 ):
  """
  Starts a MATLAB proxy server specifically for Jupyter Server Proxy (JSP) - Open MATLAB launcher.
@@ -48,6 +54,7 @@ async def start_matlab_proxy_for_jsp(
  ctx=parent_id,
  is_shared_matlab=is_shared_matlab,
  mpm_auth_token=mpm_auth_token,
+ base_url_prefix=base_url_prefix,
  )
 
 
@@ -66,122 +73,116 @@ async def _start_matlab_proxy(**options) -> dict:
  - ctx (str): The context in which the server is being started (parent pid).
  - is_shared_matlab (bool): Flag indicating if the MATLAB proxy is shared.
  - mpm_auth_token (Optional[str]): Authentication token for the MATLAB proxy manager.
+ - base_url_prefix (Optional[str]): Custom URL path which gets added to mwi_base_url
 
  Returns:
  dict: A dictionary representation of the server process, including any errors encountered.
 
  Raises:
  ValueError: If `caller_id` is "default" and `is_shared_matlab` is False.
  """
- # Validate arguments
- required_args: List[str] = ["caller_id", "ctx", "is_shared_matlab"]
- missing_args: List[str] = [arg for arg in required_args if arg not in options]
-
- if missing_args:
- raise ValueError(f"Missing required arguments: {', '.join(missing_args)}")
+ _validate_required_arguments(options)
 
  caller_id: str = options["caller_id"]
  ctx: str = options["ctx"]
  is_shared_matlab: bool = options.get("is_shared_matlab", True)
- mpm_auth_token: Optional[str] = options.get("mpm_auth_token", None)
+ mpm_auth_token = options.get("mpm_auth_token", None) or secrets.token_hex(32)
 
  if not is_shared_matlab and caller_id == "default":
  raise ValueError(
  "Caller id cannot be default when matlab proxy is not shareable"
  )
 
- mpm_auth_token = mpm_auth_token or secrets.token_hex(32)
-
  # Cleanup stale entries before starting new instance of matlab proxy server
  helpers._are_orphaned_servers_deleted(ctx)
 
- ident = caller_id if not is_shared_matlab else "default"
- key = f"{ctx}_{ident}"
- log.debug(
- "Starting matlab proxy using ctx=%s, ident=%s, is_shared_matlab=%s",
- ctx,
- ident,
- is_shared_matlab,
+ client_id = caller_id if not is_shared_matlab else "default"
+ matlab_session_dir = f"{ctx}_{client_id}"
+ filename = f"{ctx}_{caller_id}"
+ proxy_manager_root_dir = helpers.create_and_get_proxy_manager_data_dir()
+ existing_matlab_proxy_process = ServerProcess.find_existing_server(
+ proxy_manager_root_dir, matlab_session_dir
  )
 
- data_dir = helpers.create_and_get_proxy_manager_data_dir()
- server_process = ServerProcess.find_existing_server(data_dir, key)
-
- if server_process:
+ if existing_matlab_proxy_process:
  log.debug("Found existing server for aliasing")
 
  # Create a backend file for this caller for reference tracking
- helpers.create_state_file(data_dir, server_process, f"{ctx}_{caller_id}")
+ helpers.create_state_file(
+ proxy_manager_root_dir, existing_matlab_proxy_process, filename
+ )
 
- return server_process.as_dict()
+ return existing_matlab_proxy_process.as_dict()
 
  # Create a new matlab proxy server
- else:
- try:
- server_process = await _start_subprocess_and_check_for_readiness(
- ident, ctx, key, is_shared_matlab, mpm_auth_token
- )
- # Store the newly created server into filesystem
- helpers.create_state_file(data_dir, server_process, f"{ctx}_{caller_id}")
- return server_process.as_dict()
-
- # Return a server process instance with the errors information set
- except exceptions.ProcessStartError as pse:
- return ServerProcess(errors=[str(pse)]).as_dict()
- except exceptions.ServerReadinessError as sre:
- return ServerProcess(errors=[str(sre)]).as_dict()
- except Exception as e:
- log.error("Error starting matlab proxy server: %s", str(e))
- return ServerProcess(errors=[str(e)]).as_dict()
-
-
-async def _start_subprocess_and_check_for_readiness(
- server_id: str, ctx: str, key: str, is_shared_matlab: bool, mpm_auth_token: str
-) -> ServerProcess:
- """
- Starts a MATLAB proxy server.
+ try:
+ base_url_prefix = options.get("base_url_prefix", "")
 
- This function performs the following steps:
- 1. Prepares the command and environment variables required to start the MATLAB proxy server.
- 2. Initializes the MATLAB proxy process.
- 3. Checks if the MATLAB proxy server is ready.
- 4. Creates and returns a ServerProcess instance if the server is ready.
+ # Prepare matlab proxy command and required environment variables
+ matlab_proxy_cmd, matlab_proxy_env = _prepare_cmd_and_env_for_matlab_proxy(
+ client_id, base_url_prefix
+ )
 
- Args:
- server_id (str): Unique identifier for the server.
- ctx (str): Parent process ID.
- key (str): Unique key for identifying the server process.
- is_shared_matlab (bool): Indicates if the MATLAB instance is shared.
- mpm_auth_token (str): Authentication token for MATLAB proxy manager.
+ log.debug(
+ "Starting new matlab proxy server using ctx=%s, client_id=%s, is_shared_matlab=%s",
+ ctx,
+ client_id,
+ is_shared_matlab,
+ )
+ # Start the matlab proxy process
+ process_id, url = await _start_subprocess(matlab_proxy_cmd, matlab_proxy_env)
+ log.debug("MATLAB proxy process url: %s", url)
+
+ matlab_proxy_process = ServerProcess(
+ server_url=url,
+ mwi_base_url=matlab_proxy_env.get(mwi_env.get_env_name_base_url()),
+ headers=helpers.convert_mwi_env_vars_to_header_format(
+ matlab_proxy_env, "MWI"
+ ),
+ pid=str(process_id),
+ parent_pid=ctx,
+ id=matlab_session_dir,
+ type="shared" if is_shared_matlab else "isolated",
+ mpm_auth_token=mpm_auth_token,
+ )
 
- Returns:
- ServerProcess: An instance representing the MATLAB proxy server process.
+ await _check_for_process_readiness(matlab_proxy_process)
 
- Raises:
- ServerReadinessError: If the MATLAB proxy server is not ready after retries.
- """
- log.debug("Starting new matlab proxy server")
+ # Store the newly created server into filesystem
+ helpers.create_state_file(
+ proxy_manager_root_dir, matlab_proxy_process, filename
+ )
+ return matlab_proxy_process.as_dict()
 
- # Prepare matlab proxy command and required environment variables
- matlab_proxy_cmd, matlab_proxy_env = _prepare_cmd_and_env_for_matlab_proxy(
- server_id
- )
+ # Return a server process instance with the errors information set
+ except exceptions.ProcessStartError as pse:
+ return ServerProcess(errors=[str(pse)]).as_dict()
+ except exceptions.ServerReadinessError as sre:
+ return ServerProcess(errors=[str(sre)]).as_dict()
+ except Exception as e:
+ log.error("Error starting matlab proxy server: %s", str(e))
+ return ServerProcess(errors=[str(e)]).as_dict()
 
- # Start the matlab proxy process
- process_id, url = await _start_subprocess(matlab_proxy_cmd, matlab_proxy_env)
-
- log.debug("MATLAB proxy process url: %s", url)
- matlab_proxy_process = ServerProcess(
- server_url=url,
- mwi_base_url=matlab_proxy_env.get(mwi_env.get_env_name_base_url()),
- headers=helpers.convert_mwi_env_vars_to_header_format(matlab_proxy_env, "MWI"),
- pid=str(process_id),
- parent_pid=ctx,
- id=key,
- type="shared" if is_shared_matlab else "isolated",
- mpm_auth_token=mpm_auth_token,
- )
 
+def _validate_required_arguments(options):
+ # Validates that all required arguments are present in the supplied values
+ required_args: List[str] = ["caller_id", "ctx", "is_shared_matlab"]
+ missing_args: List[str] = [arg for arg in required_args if arg not in options]
+
+ if missing_args:
+ raise ValueError(f"Missing required arguments: {', '.join(missing_args)}")
+
+
+async def _check_for_process_readiness(matlab_proxy_process: ServerProcess):
+ """
+ Checks if the MATLAB proxy server is ready.
+
+ Args:
+ matlab_proxy_process (ServerProcess): Deserialized matlab-proxy process
+
+ Raises:
+ ServerReadinessError: If the MATLAB proxy server is not ready after retries.
+ """
  # Check for the matlab proxy server readiness - with retries
  if not helpers.is_server_ready(
  url=matlab_proxy_process.absolute_url, retries=7, backoff_factor=0.5
@@ -192,10 +193,8 @@ async def _start_subprocess_and_check_for_readiness(
  matlab_proxy_process.shutdown()
  raise exceptions.ServerReadinessError()
 
- return matlab_proxy_process
-
 
-def _prepare_cmd_and_env_for_matlab_proxy(server_id: str):
+def _prepare_cmd_and_env_for_matlab_proxy(client_id: str, base_url_prefix: str):
  """
  Prepare the command and environment variables for starting the MATLAB proxy.
 
@@ -215,7 +214,9 @@ def _prepare_cmd_and_env_for_matlab_proxy(server_id: str):
  config.get("extension_name"),
  ]
 
- mwi_base_url: str = f"{constants.MWI_BASE_URL_PREFIX}{server_id}"
+ mwi_base_url = _construct_mwi_base_url(base_url_prefix, client_id)
+ log.info("MWI_BASE_URL : %s", mwi_base_url)
+
  input_env: dict = {
  "MWI_AUTH_TOKEN": secrets.token_urlsafe(32),
  "MWI_BASE_URL": mwi_base_url,
@@ -227,6 +228,19 @@ def _prepare_cmd_and_env_for_matlab_proxy(server_id: str):
  return matlab_proxy_cmd, matlab_proxy_env
 
 
+def _construct_mwi_base_url(base_url_prefix: str, client_id: str):
+ # Converts to correct base url (e.g. /jupyter/, default to /jupyter/matlab/default)
+ log.debug(
+ "base_url_prefix_from_client: %s, client_id: %s", base_url_prefix, client_id
+ )
+
+ if base_url_prefix:
+ base_url_prefix = base_url_prefix.rstrip("/")
+ prefix = constants.MWI_BASE_URL_PREFIX.strip("/")
+ client_id = client_id.strip("/")
+ return "/".join([base_url_prefix, prefix, client_id])
+
+
 async def _start_subprocess(cmd: list, env: dict) -> Tuple[int, str]:
  """
  Initializes and starts a subprocess using the specified command and provided environment.
@@ -333,10 +347,10 @@ async def shutdown(parent_pid: str, caller_id: str, mpm_auth_token: str):
  )
  return
 
+ filename = f"{parent_pid}_{caller_id}"
  try:
  data_dir = helpers.create_and_get_proxy_manager_data_dir()
  storage = FileRepository(data_dir)
- filename = f"{parent_pid}_{caller_id}"
  full_file_path, server = storage.get(filename)
 
  if not server:

matlab_proxy_manager/utils/environment_variables.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 The MathWorks, Inc.
+# Copyright 2020-2025 The MathWorks, Inc.
 """This file lists and exposes the environment variables which are used by proxy manager."""
 
 import os
@@ -41,6 +41,11 @@ def get_env_name_mwi_mpm_parent_pid():
  return "MWI_MPM_PARENT_PID"
 
 
+def get_env_name_base_url_prefix():
+ """Used to specify the base url prefix for setting base url on matlab (e.g. Jupyter base url)"""
+ return "MWI_MPM_BASE_URL_PREFIX"
+
+
 def is_web_logging_enabled():
  """Returns true if the web logging is required to be enabled"""
  return _is_env_set_to_true(get_env_name_enable_web_logging())

matlab_proxy_manager/web/app.py

@@ -109,7 +109,7 @@ async def cleanup_watcher(app):
  return app
 
 
-async def start_app(env_vars: namedtuple):
+async def start_app(env_vars):
  """
  Initialize and start the web application.
 
@@ -125,6 +125,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
+ app["base_url_prefix"] = env_vars.base_url_prefix
 
  web_logger = None if not mwi_env.is_web_logging_enabled() else log
 
@@ -196,8 +197,9 @@ 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"),
  )
- errors: list = server_process.get("errors")
+ errors = server_process.get("errors")
 
  # Raising an exception if there was an error starting the default MATLAB proxy
  if errors:
@@ -484,8 +486,10 @@ def _render_error_page(error_msg: str) -> web.Response:
  )
 
 
-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())
@@ -496,9 +500,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)
@@ -510,7 +518,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))