Resets the active session when user closes the browser window.

fixes: #32

Author: Shushant Singh

gui/src/components/App/index.js

@@ -175,6 +175,22 @@ function App () {
         }
     }
 
+    useEffect(() => {
+        const handlePageHide = (event) => {
+            // Performs actions before the component unloads
+            if (isConcurrencyEnabled && !isSessionConcurrent && hasFetchedServerStatus) {
+                // A POST request to clear the active client when the tab/browser is closed
+                navigator.sendBeacon('./clear_client_id');
+            }
+            event.preventDefault();
+            event.returnValue = '';
+        };
+        window.addEventListener('pagehide', handlePageHide);
+        return () => {
+            window.removeEventListener('pagehide', handlePageHide);
+        };
+    }, [isConcurrencyEnabled, isSessionConcurrent, hasFetchedServerStatus]);
+
     useEffect(() => {
         // Initial fetch environment configuration
         if (!hasFetchedEnvConfig) {

matlab_proxy/app.py

@@ -6,7 +6,6 @@
 import pkgutil
 import secrets
 import sys
-import uuid
 
 import aiohttp
 from aiohttp import client_exceptions, web
@@ -97,16 +96,15 @@ def marshal_error(error):
 
 
 async def create_status_response(
-    app, loadUrl=None, client_id=None, transfer_session=False, is_desktop=False
+    app, loadUrl=None, client_id=None, is_active_client=None
 ):
     """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.
+        client_id (String, optional): Represents the generated client_id when concurrency check is enabled and client does not have a client_id. Defaults to None.
+        is_active_client (Boolean, optional): Represents whether the current client is the active_client when concurrency check is enabled. Defaults to None.
 
     Returns:
         JSONResponse: A JSONResponse object containing the generic state of the server, MATLAB, MATLAB Licensing and the client session status.
@@ -124,17 +122,30 @@ async def create_status_response(
         "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 client_id:
+        status["clientId"] = client_id
+    if is_active_client is not None:
+        status["isActiveClient"] = is_active_client
 
-        if not state.active_client or transfer_session:
-            state.active_client = client_id
+    return web.json_response(status)
 
-        status["isActiveClient"] = True if state.active_client == client_id else False
 
-    return web.json_response(status)
+@token_auth.authenticate_access_decorator
+async def clear_client_id(req):
+    """API endpoint to reset the active client
+
+    Args:
+        req (HTTPRequest): HTTPRequest Object
+
+    Returns:
+        Response: an empty response in JSON format
+    """
+    # Sleep for one second prior to clearing the client id to ensure that any remaining get_status responses are fully processed first.
+    await asyncio.sleep(1)
+    state = req.app["state"]
+    state.active_client = None
+    # This response is of no relevance to the front-end as the client has already exited
+    return web.json_response({})
 
 
 @token_auth.authenticate_access_decorator
@@ -201,15 +212,17 @@ async def get_status(req):
         JSONResponse: JSONResponse object containing information about the server, MATLAB and MATLAB Licensing.
     """
     # The client sends the CLIENT_ID as a query parameter if the concurrency check has been set to true.
+    state = req.app["state"]
     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)
 
+    generated_client_id, is_active_client = state.get_session_status(
+        is_desktop, client_id, transfer_session
+    )
+
     return await create_status_response(
-        req.app,
-        client_id=client_id,
-        transfer_session=transfer_session,
-        is_desktop=is_desktop,
+        req.app, client_id=generated_client_id, is_active_client=is_active_client
     )
 
 
@@ -773,6 +786,8 @@ async def cleanup_background_tasks(app):
     # Stop any running async tasks
     logger = mwi.logger.get()
     tasks = state.tasks
+    if state.task_detect_client_status:
+        tasks["detect_client_status"] = state.task_detect_client_status
     for task_name, task in tasks.items():
         if not task.cancelled():
             logger.debug(f"Cancelling MWI task: {task_name} : {task} ")
@@ -868,6 +883,7 @@ def create_app(config_name=matlab_proxy.get_default_config_name()):
     app.router.add_route("GET", f"{base_url}/get_auth_token", get_auth_token)
     app.router.add_route("GET", f"{base_url}/get_env_config", get_env_config)
     app.router.add_route("PUT", f"{base_url}/start_matlab", start_matlab)
+    app.router.add_route("POST", f"{base_url}/clear_client_id", clear_client_id)
     app.router.add_route("DELETE", f"{base_url}/stop_matlab", stop_matlab)
     app.router.add_route("PUT", f"{base_url}/set_licensing_info", set_licensing_info)
     app.router.add_route("PUT", f"{base_url}/update_entitlement", update_entitlement)

matlab_proxy/app_state.py

@@ -9,11 +9,13 @@
 from collections import deque
 from datetime import datetime, timedelta, timezone
 from typing import Final, Optional
+import uuid
 
 from matlab_proxy import util
 from matlab_proxy.constants import (
     CONNECTOR_SECUREPORT_FILENAME,
     MATLAB_LOGS_FILE_NAME,
+    IS_CONCURRENCY_CHECK_ENABLED,
 )
 from matlab_proxy.settings import (
     get_process_startup_timeout,
@@ -103,6 +105,12 @@ def __init__(self, settings):
         # connected to the backend
         self.active_client = None
 
+        # Used to detect whether the active client is actively sending out request or is inactive
+        self.active_client_request_detected = False
+
+        # An event loop task to handle the detection of client activity
+        self.task_detect_client_status = None
+
     def __get_cached_config_file(self):
         """Get the cached config file
 
@@ -1304,3 +1312,76 @@ def parsed_errs():
             if err is not None:
                 self.error = err
                 log_error(logger, err)
+
+    def get_session_status(self, is_desktop, client_id, transfer_session):
+        """
+        Determines the session status for a client, potentially generating a new client ID.
+
+        This function is responsible for managing and tracking the session status of a client.
+        It can generate a new client ID if one is not provided and the conditions are met.
+        It also manages the active client status within the session, especially in scenarios
+        involving desktop clients and when concurrency checks are enabled.
+
+        Args:
+            is_desktop (bool): A flag indicating whether the client is a desktop client.
+            client_id (str or None): The client ID. If None, a new client ID may be generated.
+            transfer_session (bool): Indicates whether the session should be transferred to this client.
+
+        Returns:
+            tuple:
+                - A 2-tuple containing the generated client ID (or None if not generated) and
+                a boolean indicating whether the client is considered the active client.
+                - If concurrency checks are not enabled or the client is not a desktop client, it returns None for both
+                the generated client ID and the active client status.
+        """
+        if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
+            generated_client_id = None
+            if not client_id:
+                generated_client_id = str(uuid.uuid4())
+                client_id = generated_client_id
+
+            if not self.active_client or transfer_session:
+                self.active_client = client_id
+
+                if not self.task_detect_client_status:
+                    # Create the loop to detect the active status of the client
+                    loop = util.get_event_loop()
+                    self.task_detect_client_status = loop.create_task(
+                        self.detect_active_client_status()
+                    )
+
+            if self.active_client == client_id:
+                is_active_client = True
+                self.active_client_request_detected = True
+            else:
+                is_active_client = False
+            return generated_client_id, is_active_client
+        return None, None
+
+    async def detect_active_client_status(self, sleep_time=1, max_inactive_count=10):
+        """Detects whether the client is online or not by continuously checking if the active client is making requests
+
+        Args:
+            sleep_time (int): The time in seconds for which the process waits before checking for the next get_status request from the active client.
+            max_inactive_count (int): The maximum number of times the check for the request from the active_client fails before reseting the active client id.
+        """
+        inactive_count = 0
+        while self.active_client:
+            # Check if the get_status request from the active client is received or not
+            await asyncio.sleep(sleep_time)
+            if self.active_client_request_detected:
+                self.active_client_request_detected = False
+                inactive_count = 0
+            else:
+                inactive_count = inactive_count + 1
+            if inactive_count > max_inactive_count:
+                # If no request is received from the active_client for more than 10 seconds then clear the active client id
+                inactive_count = 0
+                self.active_client = None
+        if self.task_detect_client_status:
+            try:
+                # Self cleanup of the task
+                self.task_detect_client_status.cancel()
+                self.task_detect_client_status = None
+            except Exception as e:
+                logger.error("Cleaning of task: 'detect_client_status' failed.")

tests/unit/test_app.py

@@ -284,6 +284,20 @@ async def test_get_status_route(test_server):
     assert resp.status == HTTPStatus.OK
 
 
+async def test_clear_client_id_route(test_server):
+    """Test to check endpoint: "/clear_client_id"
+
+    Args:
+        test_server (aiohttp_client): A aiohttp_client server for sending POST request.
+    """
+
+    state = test_server.server.app["state"]
+    state.active_client = "mock_client_id"
+    resp = await test_server.post("/clear_client_id")
+    assert resp.status == HTTPStatus.OK
+    assert state.active_client is None
+
+
 async def test_get_env_config(test_server):
     """Test to check endpoint : "/get_env_config"
 

tests/unit/test_app_state.py

@@ -584,3 +584,81 @@ async def test_start_matlab_without_xvfb(app_state_fixture, mocker):
     assert app_state_fixture.processes["xvfb"] is None
     # Check if Matlab started
     assert app_state_fixture.processes["matlab"] is mock_matlab
+
+
+@pytest.mark.parametrize(
+    "is_desktop, client_id, is_client_id_present, expected_is_active_client",
+    [
+        (False, None, False, None),
+        (False, "mock_id", False, None),
+        (True, None, True, True),
+        (True, "mock_id", False, True),
+    ],
+    ids=[
+        "request_from_non-desktop_client",
+        "request_from_non-desktop_client_having_mock_id",
+        "request_from_desktop_client",
+        "request_from_desktop_client_having_mock_id",
+    ],
+)
+async def test_get_session_status(
+    app_state_fixture,
+    is_desktop,
+    client_id,
+    is_client_id_present,
+    expected_is_active_client,
+):
+    """Test to check if correnct session response is returned based on various conditions.
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+        is_desktop (bool): A flag indicating whether the client is a desktop client.
+        client_id (str or None): The client ID. If None, a new client ID may be generated.
+        is_client_id_present (bool): Indicates whether the expected value of client_id is string or not.
+        expected_is_active_client (bool): Indicates the expected value of is_active_client
+
+    """
+    # The value of transfer_session is a Don't Care condition as initially the value of client_id is always None.
+    output_client_id, output_is_active_client = app_state_fixture.get_session_status(
+        is_desktop, client_id, transfer_session=False
+    )
+    assert isinstance(output_client_id, str) == is_client_id_present, (
+        "Expected client_id to be a string got None"
+        if is_client_id_present
+        else "Expected client_id to be None got a string value"
+    )
+    assert (
+        output_is_active_client == expected_is_active_client
+    ), f"Expected is_active_client to be {expected_is_active_client} got {output_is_active_client}"
+    # For clean up of task_detect_client_status
+    app_state_fixture.active_client = None
+
+
+async def test_get_session_status_can_transfer_session(app_state_fixture):
+    """Test to check whether transer session changes client id to the new id
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+    """
+    app_state_fixture.active_client = "mock_id"
+    app_state_fixture.get_session_status(
+        is_desktop=True, client_id="new_id", transfer_session=True
+    )
+    assert app_state_fixture.active_client == "new_id"
+    # For clean up of task_detect_client_status
+    app_state_fixture.active_client = None
+
+
+async def test_detect_active_client_status_can_reset_active_client(app_state_fixture):
+    """Test to check whether the value of active client is being reset due to the client inactivity.
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+    """
+    app_state_fixture.active_client = "mock_id"
+    await app_state_fixture.detect_active_client_status(
+        sleep_time=0, max_inactive_count=0
+    )
+    assert (
+        app_state_fixture.active_client == None
+    ), f"Expected the active_client to be None"