Bug fix:Fix RuntimeError on SIGINT signal (CTRL+C)

A dictionary to hold MWI's async tasks
Use simple await for matlab_starter and init_licensing

Author: prabhakk-mw

jupyter_matlab_proxy/app.py

@@ -340,19 +340,23 @@ async def matlab_starter(app):
 
 
 async def start_background_tasks(app):
-    loop = asyncio.get_running_loop()
-    app["license_init"] = loop.create_task(license_init(app))
-    app["matlab_starter"] = loop.create_task(matlab_starter(app))
+    await license_init(app)
+    await matlab_starter(app)
 
 
 async def cleanup_background_tasks(app):
-
+    logger = mwi_logger.get()
     state = app["state"]
+    tasks = state.tasks
+    for task_name, task in tasks.items():
+        if not task.cancelled():
+            logger.debug(f"Cancelling MWI task: {task_name} : {task} ")
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
 
-    app["license_init"].cancel()
-    app["matlab_starter"].cancel()
-    await app["license_init"]
-    await app["matlab_starter"]
     await state.stop_matlab()
 
 
@@ -427,9 +431,21 @@ def main():
 
     async def shutdown():
         logger.info("Shutting down MATLAB proxy-app")
+        for task in asyncio.Task.all_tasks():
+            logger.debug(f"calling cancel on all_tasks: {task}")
+            task.cancel()
         await app.shutdown()
         await app.cleanup()
-        # waiting here to allow matlab to finish exiting.
-        await asyncio.sleep(5)
 
-    loop.run_until_complete(shutdown())
+        asyncio.ensure_future(exit())
+
+    try:
+        loop.run_until_complete(shutdown())
+    except:
+        pass
+
+    logger.info(
+        "Finished shutting down. Thank you for using the MATLAB web desktop proxy."
+    )
+    loop.close()
+    sys.exit(0)

jupyter_matlab_proxy/app_state.py

@@ -34,6 +34,7 @@ def __init__(self, settings):
         self.processes = {"matlab": None, "xvfb": None}
         self.matlab_port = None
         self.licensing = None
+        self.tasks = {}
         self.logs = {
             "matlab": deque(maxlen=200),
         }
@@ -66,6 +67,14 @@ def __reset_and_delete_cached_licensing(self):
         self.licensing = None
         self.__delete_cached_licensing_file()
 
+    async def __update_and_persist_licensing(self):
+        successful_update = await self.update_entitlements()
+        if successful_update:
+            self.persist_licensing()
+        else:
+            self.__reset_and_delete_cached_licensing()
+        return successful_update
+
     async def init_licensing(self):
         """Initialize licensing from environment variable or cached file.
 
@@ -122,12 +131,9 @@ async def init_licensing(self):
                         ) - timedelta(hours=1)
 
                         if expiry_window > datetime.now(timezone.utc):
-                            successful_update = await self.update_entitlements()
+                            successful_update = self.__update_and_persist_licensing()
                             if successful_update:
                                 logger.info("Successful re-use of cached information.")
-                                self.persist_licensing()
-                            else:
-                                self.__reset_and_delete_cached_licensing()
                         else:
                             self.__reset_and_delete_cached_licensing()
                     else:
@@ -198,8 +204,9 @@ async def set_licensing_mhlm(
                 "entitlement_id": entitlement_id,
             }
 
-            await self.update_entitlements()
-            self.persist_licensing()
+            successful_update = self.__update_and_persist_licensing()
+            if successful_update:
+                logger.info("Login successful, persisting login information.")
 
         except OnlineLicensingError as e:
             self.error = e
@@ -445,16 +452,19 @@ async def start_matlab(self, restart=False):
         self.processes["matlab"] = matlab
         logger.debug(f"Started MATLAB (PID={matlab.pid})")
 
-        async def reader():
+        async def matlab_stderr_reader():
+            logger.info("Starting task to save error logs from MATLAB")
             while not self.processes["matlab"].stderr.at_eof():
+                logger.info("Checking for any error logs from MATLAB to save...")
                 line = await self.processes["matlab"].stderr.readline()
                 if line is None:
                     break
+                logger.info("Saving error logs from MATLAB.")
                 self.logs["matlab"].append(line)
             await self.handle_matlab_output()
 
         loop = asyncio.get_running_loop()
-        loop.create_task(reader())
+        self.tasks["matlab_stderr_reader"] = loop.create_task(matlab_stderr_reader())
 
     async def stop_matlab(self):
         """Terminate MATLAB."""
@@ -497,12 +507,15 @@ async def handle_matlab_output(self):
         matlab = self.processes["matlab"]
 
         # Wait for MATLAB process to exit
+        logger.info("handle_matlab_output Waiting for MATLAB to exit...")
         await matlab.wait()
 
         rc = self.processes["matlab"].returncode
+        logger.info(f"handle_matlab_output MATLAB has exited with errorcode: {rc}")
 
         # Look for errors if MATLAB was not intentionally stopped and had an error code
         if len(self.logs["matlab"]) > 0 and self.processes["matlab"].returncode != 0:
+            logger.info(f"handle_matlab_output Some error was found!")
             err = None
             logs = [log.decode().rstrip() for log in self.logs["matlab"]]
 

setup.py

@@ -54,6 +54,8 @@ def run(self):
     version="0.2.0",
     url="https://github.com/mathworks/jupyter-matlab-proxy",
     author="The MathWorks, Inc.",
+    author_email="jupyter-support@mathworks.com",
+    license="MATHWORKS CLOUD REFERENCE ARCHITECTURE LICENSE",
     description="Jupyter extension to proxy MATLAB JavaScript Desktop",
     packages=setuptools.find_packages(exclude=["devel", "tests"]),
     keywords=["Jupyter"],