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

matlab_proxy/app_state.py

@@ -58,13 +58,13 @@ class AppState:
         self.settings = settings
         self.processes = {"matlab": None, "xvfb": None}
 
-        # Timeout for processes launched by matlab-proxy
+        # Timeout for processes started by matlab-proxy
         self.PROCESS_TIMEOUT = get_process_startup_timeout()
 
-        # The port on which MATLAB(launched by this matlab-proxy process) starts on.
+        # The port on which MATLAB(started by this matlab-proxy process) starts on.
         self.matlab_port = None
 
-        # The directory in which the instance of MATLAB (launched by this matlab-proxy process) will write logs to.
+        # The directory in which the instance of MATLAB (started by this matlab-proxy process) will write logs to.
         self.mwi_logs_dir = None
 
         # Dictionary of all files used to manage the MATLAB session.
@@ -99,7 +99,7 @@ class AppState:
         self.embedded_connector_start_time = None
 
         # Keep track of the state of the Embedded Connector.
-        # If there is some problem with launching the Embedded Connector(say an issue with licensing),
+        # If there is some problem with starting the Embedded Connector(say an issue with licensing),
         # the state of MATLAB process in app_state will continue to be in a 'starting' indefinitely.
         # This variable can be either "up" or "down"
         self.embedded_connector_state = "down"
@@ -222,7 +222,7 @@ class AppState:
     def __delete_cached_config_file(self):
         """Deletes the cached config file"""
         try:
-            logger.info(f"Deleting any cached config files!")
+            logger.debug(f"Deleting any cached config files!")
             os.remove(self.__get_cached_config_file())
         except FileNotFoundError:
             # The file being absent is acceptable.
@@ -230,7 +230,7 @@ class AppState:
 
     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...")
+        logger.debug(f"Resetting cached config information...")
         self.licensing = None
         self.__delete_cached_config_file()
 
@@ -259,14 +259,14 @@ class AppState:
         # Default value
         self.licensing = None
 
-        # If MWI_USE_EXISTING_LICENSE is set in environment, try launching MATLAB directly
+        # If MWI_USE_EXISTING_LICENSE is set in environment, try starting MATLAB directly
         if self.settings["mwi_use_existing_license"]:
             self.licensing = {"type": "existing_license"}
             logger.debug(
                 f"{mwi_env.get_env_name_mwi_use_existing_license()} variable set in environment"
             )
             logger.info(
-                f"!!! Launching MATLAB without providing any additional licensing information. This requires MATLAB to have been activated on the machine from which its being launched !!!"
+                f"!!! Starting MATLAB without providing any additional licensing information. This requires MATLAB to have been activated on the machine from which its being started !!!"
             )
 
             # Delete old config info from cache to ensure its wiped out first before persisting new info.
@@ -276,7 +276,7 @@ class AppState:
         elif self.settings.get("nlm_conn_str", None) is not None:
             nlm_licensing_str = self.settings.get("nlm_conn_str")
             logger.debug(f"Found NLM:[{nlm_licensing_str}] set in environment")
-            logger.debug(f"Using NLM string to connect ... ")
+            logger.info(f"Using NLM:{nlm_licensing_str} to connect...")
             self.licensing = {
                 "type": "nlm",
                 "conn_str": nlm_licensing_str,
@@ -307,7 +307,7 @@ class AppState:
                             "type": "nlm",
                             "conn_str": licensing["conn_str"],
                         }
-                        logger.info("Using cached NLM licensing to launch MATLAB")
+                        logger.debug("Using cached NLM licensing to start MATLAB")
 
                     elif licensing["type"] == "mhlm":
                         self.licensing = {
@@ -335,12 +335,12 @@ class AppState:
                             )
                             if successful_update:
                                 logger.debug(
-                                    "Using cached Online Licensing to launch MATLAB."
+                                    "Using cached Online Licensing to start MATLAB."
                                 )
                         else:
                             self.__reset_and_delete_cached_config()
                     elif licensing["type"] == "existing_license":
-                        logger.info("Using cached existing license to launch MATLAB")
+                        logger.debug("Using cached existing license to start MATLAB")
                         self.licensing = licensing
                     else:
                         # Somethings wrong, licensing is neither NLM or MHLM
@@ -920,14 +920,14 @@ class AppState:
         try:
             for session_file in self.mwi_server_session_files.items():
                 if session_file[1] is not None:
-                    logger.info(f"Deleting:{session_file[1]}")
+                    logger.debug(f"Deleting:{session_file[1]}")
                     session_file[1].unlink()
         except FileNotFoundError:
             # Files may not exist if cleanup is called before they are created
             pass
 
     async def __setup_env_for_matlab(self) -> dict:
-        """Configure the environment variables required for launching MATLAB by matlab-proxy.
+        """Configure the environment variables required for starting MATLAB by matlab-proxy.
 
         Returns:
             [dict]: Containing keys as the Env variable names and values are its corresponding values.
@@ -979,17 +979,17 @@ class AppState:
         if system.is_linux():
             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"
+                logger.debug(
+                    f"Using the display number supplied by Xvfb process'{matlab_env['DISPLAY']}' for starting MATLAB"
                 )
             else:
                 if "DISPLAY" in matlab_env:
-                    logger.info(
-                        f"Using the existing DISPLAY environment variable with value:{matlab_env['DISPLAY']} for launching MATLAB"
+                    logger.debug(
+                        f"Using the existing DISPLAY environment variable with value:{matlab_env['DISPLAY']} for starting MATLAB"
                     )
                 else:
-                    logger.info(
-                        "No DISPLAY environment variable found. Launching MATLAB without it."
+                    logger.debug(
+                        "No DISPLAY environment variable found. Starting MATLAB without it."
                     )
 
         # The matlab ready file is written into this location(self.mwi_logs_dir) by MATLAB
@@ -1080,11 +1080,11 @@ class AppState:
 
             return xvfb
 
-        # If something went wrong ie. exception is raised in launching Xvfb process, capture error for logging
+        # If something went wrong ie. exception is raised in starting Xvfb process, capture error for logging
         # and for showing the error on the frontend.
 
         # FileNotFoundError: is thrown if Xvfb is not found on System Path.
-        # XvfbError: is thrown if something went wrong when launching Xvfb process.
+        # XvfbError: is thrown if something went wrong when starting Xvfb process.
         except (FileNotFoundError, XvfbError) as err:
             self.error = XvfbError(
                 """Unable to start the Xvfb process. Ensure Xvfb is installed and is available on the System Path. See https://github.com/mathworks/matlab-proxy#requirements for information on Xvfb"""
@@ -1178,7 +1178,7 @@ class AppState:
                 else:
                     time_diff = time.time() - self.embedded_connector_start_time
                     if time_diff > self.PROCESS_TIMEOUT:
-                        # Since max allowed startup time has elapsed, it means that MATLAB is in a stuck state and cannot be launched.
+                        # Since max allowed startup time has elapsed, it means that MATLAB is stuck and is unable to start.
                         # Set the error and stop matlab.
                         user_visible_error = "Unable to start MATLAB.\nTry again by clicking Start MATLAB."
 
@@ -1187,32 +1187,27 @@ class AppState:
                             # So, raise a generic error wherever appropriate
                             generic_error = f"MATLAB did not start in {int(self.PROCESS_TIMEOUT)} seconds. Use Windows Remote Desktop to check for any errors."
                             logger.error(f":{this_task}: {generic_error}")
-                            if len(self.logs["matlab"]) == 0:
-                                await self.__force_stop_matlab(
-                                    user_visible_error, this_task
-                                )
-                                # Breaking out of the loop to end this task as matlab-proxy was unable to launch MATLAB successfully
-                                # even after waiting for self.PROCESS_TIMEOUT
-                                break
-                            else:
-                                # Do not stop the MATLAB process or break from the loop (the error type is unknown)
-                                self.error = MatlabError(generic_error)
-                                await asyncio.sleep(5)
-                                continue
+
+                            # Stopping the MATLAB process would remove the UI window displaying the error too.
+                            # Do not stop the MATLAB or break from the loop (as the error is still unknown)
+                            self.error = MatlabError(generic_error)
+                            await asyncio.sleep(5)
+                            continue
 
                         else:
-                            # If there are no logs after the max startup time has elapsed, it means that MATLAB is in a stuck state and cannot be launched.
+                            # If there are no logs after the max startup time has elapsed, it means that MATLAB is stuck and is unable to start.
                             # Set the error and stop matlab.
                             logger.error(
                                 f":{this_task}: MATLAB did not start in {int(self.PROCESS_TIMEOUT)} seconds!"
                             )
-                            if len(self.logs["matlab"]) == 0:
-                                await self.__force_stop_matlab(
-                                    user_visible_error, this_task
-                                )
-                                # Breaking out of the loop to end this task as matlab-proxy was unable to launch MATLAB successfully
-                                # even after waiting for self.PROCESS_TIMEOUT
-                                break
+                            # MATLAB can be stopped on posix systems because the stderr pipe of the MATLAB process is
+                            # read (by __matlab_stderr_reader_posix() task) and is logged by matlab-proxy appropriately.
+                            await self.__force_stop_matlab(
+                                user_visible_error, this_task
+                            )
+                            # Breaking out of the loop to end this task as matlab-proxy was unable to start MATLAB successfully
+                            # even after waiting for self.PROCESS_TIMEOUT
+                            break
 
                     else:
                         logger.debug(
@@ -1410,7 +1405,7 @@ class AppState:
             if session_file_path is not None:
                 self.matlab_session_files[session_file_name] = None
                 with contextlib.suppress(FileNotFoundError):
-                    logger.info(f"Deleting:{session_file_path}")
+                    logger.debug(f"Deleting:{session_file_path}")
                     session_file_path.unlink()
 
         # In posix systems, variable matlab is an instance of asyncio.subprocess.Process()
@@ -1496,7 +1491,7 @@ class AppState:
         if system.is_posix():
             xvfb = self.processes["xvfb"]
             if xvfb is not None and xvfb.returncode is None:
-                logger.info(f"Terminating Xvfb (PID={xvfb.pid})")
+                logger.debug(f"Terminating Xvfb (PID={xvfb.pid})")
                 xvfb.terminate()
                 waiters.append(xvfb.wait())
 

matlab_proxy/settings.py

@@ -103,7 +103,7 @@ def get_matlab_executable_and_root_path():
     # Note, error messages are formatted as multi-line strings and the front end displays them as is.
     error_message = "Unable to find MATLAB on the system PATH. Add MATLAB to the system PATH, and restart matlab-proxy."
 
-    logger.info(error_message)
+    logger.error(error_message)
     raise MatlabInstallError(error_message)
 
 

matlab_proxy/util/__init__.py

@@ -98,7 +98,7 @@ def prepare_site(app, runner):
                 )
                 break
             except:
-                logger.info(f"Failed to launch the site on port {p}")
+                logger.error(f"Failed to launch the site on port {p}")
 
     return site
 

matlab_proxy/util/mwi/validators.py

@@ -326,7 +326,7 @@ def validate_matlab_root_path(matlab_root: Path, is_custom_matlab_root: bool):
 
     try:
         __validate_if_paths_exist([matlab_root])
-        logger.info(
+        logger.debug(
             f"MATLAB root path: {matlab_root} exists, continuing to verify its validity..."
         )
 

{matlab_proxy-0.23.1.dist-info → matlab_proxy-0.23.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matlab-proxy
-Version: 0.23.1
+Version: 0.23.3
 Summary: Python® package enables you to launch MATLAB® and access it from a web browser.
 Home-page: https://github.com/mathworks/matlab-proxy/
 Author: The MathWorks, Inc.

{matlab_proxy-0.23.1.dist-info → matlab_proxy-0.23.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 matlab_proxy/__init__.py,sha256=6cwi8buKCMtw9OeWaOYUHEoqwl5MyJ_s6GxgNuqPuNg,1673
 matlab_proxy/app.py,sha256=7BsHSM3PxTjN6eN10HLj74Y1wtu-Gl92g1RLbaTGz9U,34698
-matlab_proxy/app_state.py,sha256=kzgcdzU7O5AgUWtL0pPDPQxRBxpQLW0ZSpEEkZKEvHU,71298
+matlab_proxy/app_state.py,sha256=fGZjhY8ZupX54Q6gEbXjfrxR8svDBicnsO97vetjpo4,71015
 matlab_proxy/constants.py,sha256=L9fhXdcGH7Eu56h0aB_TNm3d6aNFr2nP6-HyQJ96TAA,1175
 matlab_proxy/default_configuration.py,sha256=tBHaEq_bYsX2uC9pPA9mi_8M6o94ij-rxq8mbvcYpFc,1874
 matlab_proxy/devel.py,sha256=nR6XPVBUEdQ-RZGtYvX1YHTp8gj9cuw5Hp8ahasMBc8,14310
-matlab_proxy/settings.py,sha256=63pyCUvT7WLBRUpUr3F4r4nL13pQ2Hn6-oZODAhuGLo,26722
+matlab_proxy/settings.py,sha256=ni-9zNbWF3cy4v0X8vAwAiM5WcC8U_t3a-s7GXIkyBA,26723
 matlab_proxy/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 matlab_proxy/gui/asset-manifest.json,sha256=VW67P_Jg7RPTCNDkMCWmphyXKJvv-KE-DjFQvQxm8aM,3516
 matlab_proxy/gui/favicon.ico,sha256=7w7Ki1uQP2Rgwc64dOV4-NrTu97I3WsZw8OvRSoY1A0,130876
@@ -54,7 +54,7 @@ matlab_proxy/gui/static/media/trigger-ok.7b9c238be42f685c4fa7.svg,sha256=mD-7N9c
 matlab_proxy/icons/matlab.svg,sha256=xh5uYebQd8I-ISvenjU9A-PkClzW_lU9wvm3doXOFKM,13366
 matlab_proxy/matlab/evaluateUserMatlabCode.m,sha256=R8w6nPdGtadR4UUFJaspcrGQL7cJwUItdrfc531w3bM,2420
 matlab_proxy/matlab/startup.m,sha256=Rgb1Y3F2pFgByKAaXxWWcYOA2594D7V2HXuyuVmGYjs,653
-matlab_proxy/util/__init__.py,sha256=CoH6sfgrQ1phhO1FXeyQwTjtl7PPgeZOCGNrkyGv-5o,11711
+matlab_proxy/util/__init__.py,sha256=JkVIsTOae5giDK0cQ7jcxQSHa8zo1umdq-1C0grDZwk,11712
 matlab_proxy/util/event_loop.py,sha256=sX_0tKlirCY5ImLxkss_XO4Ksj65u6JHtwMj25oGL94,1816
 matlab_proxy/util/list_servers.py,sha256=M93coVZjyQCdIvCCxsNOU_XDWNjBSysOJ5tWXaTjP8Y,1369
 matlab_proxy/util/mw.py,sha256=dLGSdfcTZiwKR1MMZA-39o-8na13IEPZOGBqcaHmKVI,11086
@@ -67,27 +67,27 @@ matlab_proxy/util/mwi/environment_variables.py,sha256=sOfmL8PjQONgkJdegdotLbsqHs
 matlab_proxy/util/mwi/exceptions.py,sha256=3jklFU6br2_pSSsATCRDY3A5fTzk6ekJ4M69sunwxBk,5114
 matlab_proxy/util/mwi/logger.py,sha256=EHHr6OWlXe6yVX0RPh57HSE7lz6MhWmwLQIpe_SlsC0,3803
 matlab_proxy/util/mwi/token_auth.py,sha256=UbIWqo7qADaZdijFvorLYsZbxzaB8TycGP8nk305ru0,9997
-matlab_proxy/util/mwi/validators.py,sha256=CQnwf2kIm-bApSYClasbJCIWP-2ZxBNGn0X4B1U-2_0,12632
+matlab_proxy/util/mwi/validators.py,sha256=iXPR7b3jtnwx2i15YxKQgmOm2pt3ujJeMGYNxY0oGGw,12633
 matlab_proxy/util/mwi/embedded_connector/__init__.py,sha256=Vfl2hNC7V1IwoK9_wrwfENs4BC8P-Mvvqh4BNGi2n48,119
 matlab_proxy/util/mwi/embedded_connector/helpers.py,sha256=aOn-AvcDy6jBQJIffiv_agIa4UVldAIl3--QnDpXWDM,3656
 matlab_proxy/util/mwi/embedded_connector/request.py,sha256=-IzTDjy3qViHfLJpK3OnFtEyV7dgwJKPQAfav9lqILc,4317
 matlab_proxy_manager/__init__.py,sha256=CMqm2aSYUWo5sxV3vyqWudrQU31muouSqZRDesJNJSA,178
 matlab_proxy_manager/lib/__init__.py,sha256=KfwQxxM5a1kMRtNbhz8tb7YfHp8e2d0tNLB55wYvDS8,37
-matlab_proxy_manager/lib/api.py,sha256=IBAYvrTCA2TQ1pBzz8mkn1GQXUpIC1mUwaqVktvl4aE,10639
+matlab_proxy_manager/lib/api.py,sha256=_ukL8ZeQg8E5s9uPeNjYAuCc_1BR08GSlom0VQclt84,12549
 matlab_proxy_manager/storage/__init__.py,sha256=KfwQxxM5a1kMRtNbhz8tb7YfHp8e2d0tNLB55wYvDS8,37
 matlab_proxy_manager/storage/file_repository.py,sha256=U4FAw0zFN9z7YNlaMsYZXWm5ccs3rp3bzZL-W2BNhxA,5187
 matlab_proxy_manager/storage/interface.py,sha256=pnRRD0Ku3gzbruAOM3J3NI2Kk8do3-_yRw9Pag1IqnE,1883
-matlab_proxy_manager/storage/server.py,sha256=kQ4jtG2xqCa8c7zqDBFYxOhxMxwZwqTIITBxcJRDcvE,4848
+matlab_proxy_manager/storage/server.py,sha256=MjTw5-CRb3jF57wUXnVJmOyezM6peBOAyBfMfEqSzBc,4848
 matlab_proxy_manager/utils/__init__.py,sha256=KfwQxxM5a1kMRtNbhz8tb7YfHp8e2d0tNLB55wYvDS8,37
 matlab_proxy_manager/utils/auth.py,sha256=60vi16eQ7LWp3I4CNv2easTjObw50irEm518fiMA5YI,2526
 matlab_proxy_manager/utils/constants.py,sha256=pyg-bkk6wWfmy60nvhroZDMZt__FcbZbuvU-b9m2Fkg,163
 matlab_proxy_manager/utils/environment_variables.py,sha256=rbDeWnyJp77Yr6btK3eXKZQ5thwiwhOGZcvDetGPOH8,1436
-matlab_proxy_manager/utils/helpers.py,sha256=8RlUe2WfhJ65YEVlhfU6ivpjpy4AAyA70vzmnJh0ypA,9267
+matlab_proxy_manager/utils/helpers.py,sha256=vgbWDTGmHpI_IMEy67UMfExxmbjMskhdEadCmbbvav8,9983
 matlab_proxy_manager/utils/logger.py,sha256=GSRGD-yf518o-2b1BxEeJYuNiEz2eEqpl0Solqbwpb4,1869
 matlab_proxy_manager/web/__init__.py,sha256=KfwQxxM5a1kMRtNbhz8tb7YfHp8e2d0tNLB55wYvDS8,37
-matlab_proxy_manager/web/app.py,sha256=Lu6sl3Mft98oL-Z1NwBdmmG1OvnwYEN31pU2bOdzFi0,16572
-matlab_proxy_manager/web/monitor.py,sha256=Gj0DxwX0c1PEAly5jWmuIGqNJYGDDjTkQIzbVXu4zCQ,1589
-matlab_proxy_manager/web/watcher.py,sha256=aNa_UDwvzaZrIdHyvWGX7dILH199uc6xVH4odrKU5-E,1817
+matlab_proxy_manager/web/app.py,sha256=a_fCQS1rDGCuQ7iE1J2oaFrKSeBUyk_9lYeuyZo-MVc,18174
+matlab_proxy_manager/web/monitor.py,sha256=PWkwV0kP3XHCxDRHpurPh74Zg-SgaIXnCnX2xZSW_R8,1541
+matlab_proxy_manager/web/watcher.py,sha256=89JHjBAQtOrllstaJFxqrjHwckpRmu3qfUqeqPLmH2Q,2130
 tests/integration/__init__.py,sha256=ttzJ8xKWGxOJZz56qOiWOn6sp5LGomkZMn_w4KJLRMU,42
 tests/integration/integration_tests_with_license/__init__.py,sha256=vVYZCur-QhmIGCxUmn-WZjIywtDQidaLDmlmrRHRlgY,37
 tests/integration/integration_tests_with_license/conftest.py,sha256=sCaIXB8d4vf05C7JWSVA7g5gnPjbpRq3dftuBpWyp1s,1599
@@ -101,7 +101,7 @@ tests/integration/utils/licensing.py,sha256=rEBjvMXO8R3mL6KnePu2lojmOsjD4GXl9frf
 tests/unit/__init__.py,sha256=KfwQxxM5a1kMRtNbhz8tb7YfHp8e2d0tNLB55wYvDS8,37
 tests/unit/conftest.py,sha256=Hfxq3h8IZuLJkRMh5jdEFiq78CIAdKvm-6KryRDZ0FY,1918
 tests/unit/test_app.py,sha256=pM8zVyXWLx8nP8RePusXH4admEBYKc5JC8eE2t8xIQE,38487
-tests/unit/test_app_state.py,sha256=ZtM79HAe5W6pVVWV-NICjDJBlmuxJ4NnZn-urGGtH-E,33429
+tests/unit/test_app_state.py,sha256=mq0qDWY3k2-_8job9g3BY52aT3ciNxji5_HVG1VhVBw,37112
 tests/unit/test_constants.py,sha256=2nXxTmDP8utr8krsfZ4c_Bh4_mWPcDO5uI8MXeq4Usg,158
 tests/unit/test_ddux.py,sha256=a2J2iM8j_nnfJVuMI38p5AjwrRdoMj3N88gFgS2I4hg,713
 tests/unit/test_devel.py,sha256=A-1iVhSSwmywaW65QIRcUS2Fk7nJxceCcCm7CJtNdEc,7982
@@ -121,9 +121,9 @@ tests/unit/util/mwi/embedded_connector/test_helpers.py,sha256=vYTWNUTuDeaygo16JG
 tests/unit/util/mwi/embedded_connector/test_request.py,sha256=PR-jddnXDEiip-lD7A_QSvRwEkwo3eQ8owZlk-r9vnk,1867
 tests/utils/__init__.py,sha256=ttzJ8xKWGxOJZz56qOiWOn6sp5LGomkZMn_w4KJLRMU,42
 tests/utils/logging_util.py,sha256=VBy_NRvwau3C_CVTBjK5RMROrQimnJYHO2U0aKSZiRw,2234
-matlab_proxy-0.23.1.dist-info/LICENSE.md,sha256=oF0h3UdSF-rlUiMGYwi086ZHqelzz7yOOk9HFDv9ELo,2344
-matlab_proxy-0.23.1.dist-info/METADATA,sha256=T9odF5XgnV7G2o8ETI3vvLvYCCGBu8WqSbF_b9vAWYY,10199
-matlab_proxy-0.23.1.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-matlab_proxy-0.23.1.dist-info/entry_points.txt,sha256=ZAlCUsgKzGcAeQaMZOq31FrTB5tQ8Ypq8Op_8U600-A,305
-matlab_proxy-0.23.1.dist-info/top_level.txt,sha256=KF-347aoRGsfHTpiSqfIPUZ95bzK5-oMIu8S_TUcu-w,40
-matlab_proxy-0.23.1.dist-info/RECORD,,
+matlab_proxy-0.23.3.dist-info/LICENSE.md,sha256=oF0h3UdSF-rlUiMGYwi086ZHqelzz7yOOk9HFDv9ELo,2344
+matlab_proxy-0.23.3.dist-info/METADATA,sha256=l32qvymxSsGA0amtHFIGVvMQDMFMBs6758Qm2_YSq-A,10199
+matlab_proxy-0.23.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+matlab_proxy-0.23.3.dist-info/entry_points.txt,sha256=ZAlCUsgKzGcAeQaMZOq31FrTB5tQ8Ypq8Op_8U600-A,305
+matlab_proxy-0.23.3.dist-info/top_level.txt,sha256=KF-347aoRGsfHTpiSqfIPUZ95bzK5-oMIu8S_TUcu-w,40
+matlab_proxy-0.23.3.dist-info/RECORD,,

{matlab_proxy-0.23.1.dist-info → matlab_proxy-0.23.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

matlab_proxy_manager/lib/api.py

@@ -3,7 +3,7 @@ import asyncio
 import os
 import secrets
 import subprocess
-from typing import Optional
+from typing import List, Optional, Tuple
 
 import matlab_proxy
 import matlab_proxy.util.system as mwi_sys
@@ -20,7 +20,7 @@ log = logger.get(init=True)
 
 
 async def start_matlab_proxy_for_kernel(
-    caller_id: str, parent_id: str, is_isolated_matlab: bool
+    caller_id: str, parent_id: str, is_shared_matlab: bool
 ):
     """
     Starts a MATLAB proxy server specifically for MATLAB Kernel.
@@ -29,12 +29,12 @@ 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_isolated_matlab=is_isolated_matlab
+        caller_id=caller_id, ctx=parent_id, is_shared_matlab=is_shared_matlab
     )
 
 
 async def start_matlab_proxy_for_jsp(
-    parent_id: str, is_isolated_matlab: bool, mpm_auth_token: str
+    parent_id: str, is_shared_matlab: bool, mpm_auth_token: str
 ):
     """
     Starts a MATLAB proxy server specifically for Jupyter Server Proxy (JSP) - Open MATLAB launcher.
@@ -45,7 +45,7 @@ async def start_matlab_proxy_for_jsp(
     return await _start_matlab_proxy(
         caller_id="jsp",
         ctx=parent_id,
-        is_isolated_matlab=is_isolated_matlab,
+        is_shared_matlab=is_shared_matlab,
         mpm_auth_token=mpm_auth_token,
     )
 
@@ -60,7 +60,7 @@ async def _start_matlab_proxy(**options) -> Optional[dict]:
     Args (keyword arguments):
         - caller_id (str): The identifier for the caller (kernel id for kernels, "jsp" for JSP).
         - ctx (str): The context in which the server is being started (parent pid).
-        - is_isolated_matlab (bool, optional): Whether to start an isolated MATLAB proxy instance.
+        - is_shared_matlab (bool, optional): Whether to start a shared MATLAB proxy instance.
         Defaults to False.
         - mpm_auth_token (str, optional): The MATLAB proxy manager token. If not provided,
         a new token is generated. Defaults to None.
@@ -69,16 +69,23 @@ async def _start_matlab_proxy(**options) -> Optional[dict]:
         ServerProcess: The process representing the MATLAB proxy server.
 
     Raises:
-        ValueError: If `caller_id` is "default" and `is_isolated_matlab` is True.
+        ValueError: If `caller_id` is "default" and `is_shared_matlab` is False.
     """
-    caller_id: str = options.get("caller_id")
-    ctx: str = options.get("ctx")
-    is_isolated_matlab: bool = options.get("is_isolated_matlab", 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)}")
+
+    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)
 
-    if is_isolated_matlab and caller_id == "default":
+    if not is_shared_matlab and caller_id == "default":
         raise ValueError(
-            "Caller id cannot be default when isolated_matlab is set to true"
+            "Caller id cannot be default when matlab proxy is not shareable"
         )
 
     mpm_auth_token = mpm_auth_token or secrets.token_hex(32)
@@ -86,9 +93,9 @@ async def _start_matlab_proxy(**options) -> Optional[dict]:
     # Cleanup stale entries before starting new instance of matlab proxy server
     helpers._are_orphaned_servers_deleted(ctx)
 
-    ident = caller_id if is_isolated_matlab else "default"
+    ident = caller_id if not is_shared_matlab else "default"
     key = f"{ctx}_{ident}"
-    log.debug("Starting matlab proxy using %s, %s, %s", ctx, ident, is_isolated_matlab)
+    log.debug("Starting matlab proxy using %s, %s, %s", ctx, ident, is_shared_matlab)
 
     data_dir = helpers.create_and_get_proxy_manager_data_dir()
     server_process = ServerProcess.find_existing_server(data_dir, key)
@@ -101,10 +108,8 @@ async def _start_matlab_proxy(**options) -> Optional[dict]:
 
     # Create a new matlab proxy server
     else:
-        server_process: ServerProcess | None = (
-            await _start_subprocess_and_check_for_readiness(
-                ident, ctx, key, is_isolated_matlab, mpm_auth_token
-            )
+        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
@@ -115,7 +120,7 @@ async def _start_matlab_proxy(**options) -> Optional[dict]:
 
 
 async def _start_subprocess_and_check_for_readiness(
-    server_id: str, ctx: str, key: str, isolated: bool, mpm_auth_token: str
+    server_id: str, ctx: str, key: str, is_shared_matlab: bool, mpm_auth_token: str
 ) -> Optional[ServerProcess]:
     """
     Starts a MATLAB proxy server.
@@ -136,10 +141,12 @@ async def _start_subprocess_and_check_for_readiness(
     matlab_proxy_cmd, matlab_proxy_env = _prepare_cmd_and_env_for_matlab_proxy()
 
     # Start the matlab proxy process
-    process_id, url, mwi_base_url = await _start_subprocess(
-        matlab_proxy_cmd, matlab_proxy_env, server_id
-    )
+    result = await _start_subprocess(matlab_proxy_cmd, matlab_proxy_env, server_id)
+    if not result:
+        log.error("Could not start matlab proxy")
+        return None
 
+    process_id, url, mwi_base_url = result
     server_process = None
 
     # Check for the matlab proxy server readiness
@@ -151,14 +158,14 @@ async def _start_subprocess_and_check_for_readiness(
             headers=helpers.convert_mwi_env_vars_to_header_format(
                 matlab_proxy_env, "MWI"
             ),
-            pid=process_id,
+            pid=str(process_id),
             parent_pid=ctx,
             id=key,
-            type="named" if isolated else "shared",
+            type="shared" if is_shared_matlab else "named",
             mpm_auth_token=mpm_auth_token,
         )
     else:
-        log.error("Could not start matlab proxy")
+        log.error("matlab-proxy server never became ready")
 
     return server_process
 
@@ -189,7 +196,7 @@ def _prepare_cmd_and_env_for_matlab_proxy():
     return matlab_proxy_cmd, matlab_proxy_env
 
 
-async def _start_subprocess(cmd, env, server_id) -> Optional[int]:
+async def _start_subprocess(cmd, env, server_id) -> Optional[Tuple[int, str, str]]:
     """
     Initializes and starts a subprocess using the specified command and provided environment.
 
@@ -199,33 +206,22 @@ async def _start_subprocess(cmd, env, server_id) -> Optional[int]:
     process = None
     mwi_base_url: str = f"{constants.MWI_BASE_URL_PREFIX}{server_id}"
 
-    # Get a free port, closer to starting the matlab proxy appx
-    port: str = helpers.find_free_port()
-    env.update(
-        {
-            "MWI_APP_PORT": port,
-            "MWI_BASE_URL": mwi_base_url,
-        }
-    )
+    # Get a free port and corresponding bound socket
+    with helpers.find_free_port() as (port, _):
+        env.update(
+            {
+                "MWI_APP_PORT": port,
+                "MWI_BASE_URL": mwi_base_url,
+            }
+        )
 
-    # Using loopback address so that DNS resolution doesn't add latency in Windows
-    url: str = f"http://127.0.0.1:{port}"
+        # Using loopback address so that DNS resolution doesn't add latency in Windows
+        url: str = f"http://127.0.0.1:{port}"
 
-    if mwi_sys.is_posix():
-        process = await asyncio.create_subprocess_exec(
-            *cmd,
-            env=env,
-        )
-        log.debug("Started matlab proxy subprocess for posix")
-    else:
-        process = subprocess.Popen(
-            cmd,
-            env=env,
-        )
-        log.debug("Started matlab proxy subprocess for windows")
+        process = await _initialize_process_based_on_os_type(cmd, env)
 
     if not process:
-        log.error("Matlab proxy process not created %d", process.returncode)
+        log.error("Matlab proxy process not created due to some error")
         return None
 
     process_pid = process.pid
@@ -233,6 +229,51 @@ async def _start_subprocess(cmd, env, server_id) -> Optional[int]:
     return process_pid, url, mwi_base_url
 
 
+async def _initialize_process_based_on_os_type(cmd, env):
+    """
+    Initializes and starts a subprocess based on the operating system.
+
+    This function attempts to create a subprocess using the provided command and
+    environment variables. It handles both POSIX and Windows systems differently.
+
+    Args:
+        cmd (List[str]): The command to execute in the subprocess.
+        env (Dict[str, str]): The environment variables for the subprocess.
+
+    Returns:
+        Union[Process, None, Popen[bytes]]: The created subprocess object if successful,
+        or None if an error occurs during subprocess creation.
+
+    Raises:
+        Exception: If there's an error creating the subprocess (caught and logged).
+    """
+    if mwi_sys.is_posix():
+        log.debug("Starting matlab proxy subprocess for posix")
+        try:
+            return await asyncio.create_subprocess_exec(
+                *cmd,
+                env=env,
+                # kernel sporadically ends up cleaning the child matlab-proxy process during the
+                # restart workflow. This is a workaround to handle that race condition which leads
+                # to starting matlab-proxy in a new process group and is not counted for deletion.
+                # https://github.com/ipython/ipykernel/blob/main/ipykernel/kernelbase.py#L1283
+                start_new_session=True,
+            )
+        except Exception as e:
+            log.error("Failed to create posix subprocess: %s", e)
+            return None
+    else:
+        try:
+            log.debug("Starting matlab proxy subprocess for windows")
+            return subprocess.Popen(
+                cmd,
+                env=env,
+            )
+        except Exception as e:
+            log.error("Failed to create windows subprocess: %s", e)
+            return None
+
+
 async def shutdown(parent_pid: str, caller_id: str, mpm_auth_token: str):
     """
     Shutdown the MATLAB proxy server if the provided authentication token is valid.

matlab_proxy_manager/storage/server.py

@@ -20,8 +20,8 @@ class ServerProcess:
     mwi_base_url: Optional[str] = None
     headers: Optional[dict] = None
     errors: Optional[list] = None
-    pid: Optional[int] = None
-    parent_pid: Optional[int] = None
+    pid: Optional[str] = None
+    parent_pid: Optional[str] = None
     absolute_url: Optional[str] = field(default=None)
     id: Optional[str] = None
     type: Optional[str] = None

matlab_proxy_manager/utils/helpers.py

@@ -1,9 +1,12 @@
 # Copyright 2024 The MathWorks, Inc.
+import http
 import os
 import socket
 import time
+from contextlib import contextmanager
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Generator, Optional, Tuple
+from urllib.parse import urlparse
 
 import psutil
 import requests
@@ -18,7 +21,7 @@ from matlab_proxy_manager.utils import logger
 log = logger.get()
 
 
-def is_server_ready(url: str, retries: int = 2, backoff_factor=None) -> bool:
+def is_server_ready(url: Optional[str], retries: int = 2, backoff_factor=None) -> bool:
     """
     Check if the server at the given URL is ready.
 
@@ -29,13 +32,19 @@ def is_server_ready(url: str, retries: int = 2, backoff_factor=None) -> bool:
         bool: True if the server is ready, False otherwise.
     """
     try:
+        # Validate URL
+        parsed_url = urlparse(url)
+        if not all([parsed_url.scheme, parsed_url.netloc]):
+            log.debug("Invalid URL provided: %s", url)
+            return False
+
         matlab_proxy_index_page_identifier = "MWI_MATLAB_PROXY_IDENTIFIER"
         resp = requests_retry_session(
             retries=retries, backoff_factor=backoff_factor
         ).get(f"{url}", verify=False)
         log.debug("Response status code from server readiness: %s", resp.status_code)
         return (
-            resp.status_code == requests.codes.OK
+            resp.status_code == http.HTTPStatus.OK
             and matlab_proxy_index_page_identifier in resp.text
         )
     except Exception as e:
@@ -71,16 +80,14 @@ def requests_retry_session(
     return session
 
 
-def does_process_exist(pid: int) -> bool:
+def does_process_exist(pid: Optional[str]) -> bool:
     """
     Checks if the parent process is alive.
 
     Returns:
         bool: True if the parent process is alive, False otherwise.
     """
-    parent_status = pid is not None and psutil.pid_exists(int(pid))
-    log.debug("Parent liveness check returned: %s", parent_status)
-    return parent_status
+    return bool(pid and psutil.pid_exists(int(pid)))
 
 
 def convert_mwi_env_vars_to_header_format(
@@ -124,11 +131,11 @@ async def delete_dangling_servers(app: web.Application) -> None:
     Args:
         app (web.Application): aiohttp web application
     """
-    is_delete_successful = _are_orphaned_servers_deleted(None)
+    is_delete_successful = _are_orphaned_servers_deleted()
     log.debug("Deleted dangling matlab proxy servers: %s", is_delete_successful)
 
 
-def _are_orphaned_servers_deleted(predicate: str) -> bool:
+def _are_orphaned_servers_deleted(predicate: Optional[str] = "") -> bool:
     """
     Get all the files under the proxy manager directory, check the status of the servers,
     and delete orphaned servers and their corresponding files.
@@ -146,7 +153,7 @@ def _are_orphaned_servers_deleted(predicate: str) -> bool:
     servers: dict = storage.get_all()
 
     def _matches_predicate(filename: str) -> bool:
-        return filename.split("_")[0] == predicate
+        return filename.split("_")[0] == str(predicate)
 
     # Checks only a subset of servers (that matches the parent_pid of the caller)
     # to reduce the MATLAB proxy startup time
@@ -154,7 +161,7 @@ def _are_orphaned_servers_deleted(predicate: str) -> bool:
         servers = {
             filename: server
             for filename, server in servers.items()
-            if _matches_predicate(filename)
+            if _matches_predicate(Path(filename).stem)
         }
         if not servers:
             log.debug("Parent pid not matched, nothing to cleanup")
@@ -163,7 +170,7 @@ def _are_orphaned_servers_deleted(predicate: str) -> bool:
     return _delete_server_and_file(storage, servers)
 
 
-def _delete_server_and_file(storage, servers):
+def _delete_server_and_file(storage, servers) -> bool:
     is_server_deleted = False
     for filename, server in servers.items():
         if not server.is_server_alive():
@@ -201,7 +208,7 @@ def poll_for_server_deletion() -> None:
     start_time = time.time()
 
     while time.time() - start_time < timeout_in_seconds:
-        is_server_deleted = _are_orphaned_servers_deleted(None)
+        is_server_deleted = _are_orphaned_servers_deleted()
         if is_server_deleted:
             log.debug("Servers deleted, breaking out of loop")
             break
@@ -210,21 +217,31 @@ def poll_for_server_deletion() -> None:
         time.sleep(0.5)
 
 
-def find_free_port() -> str:
+@contextmanager
+def find_free_port() -> Generator[Tuple[str, socket.socket], None, None]:
     """
-    Find a free port on the system.
+    Context manager for finding a free port on the system.
 
-    This function creates a socket, binds it to an available port, retrieves
-    the port number, and then closes the socket.
+    This function creates a socket, binds it to an available port, and yields
+    the port number along with the socket object. The socket is automatically
+    closed when exiting the context.
 
-    Returns:
-        str: The free port number as a string.
+    Yields:
+        Tuple[str, socket.socket]: A tuple containing:
+            - str: The free port number as a string.
+            - socket.socket: The socket object.
     """
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.bind(("", 0))
     port = str(s.getsockname()[1])
-    s.close()
-    return port
+    try:
+        yield port, s
+    finally:
+        try:
+            s.close()
+        except OSError as ex:
+            # Socket already closed, log and ignore the exception
+            log.debug("Failed to close socket: %s", ex)
 
 
 def pre_load_from_state_file(data_dir: str) -> Dict[str, str]:

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_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")],