ECS-5104 Hutch-python feature: auto-close after timeout

docs/source/upcoming_release_notes/385-ECS-5104_Hutch-python_feature:_auto-close_after_timeout.rst

@@ -0,0 +1,22 @@
+385 ECS-5104 Hutch-python feature: auto-close after timeout
+#################
+
+API Changes
+-----------
+- Created an IPython extension that launches a daemon thread that runs an instance of IPythonSessionTimer class object.
+
+Features
+--------
+- Automatically timeout and closes hutch-python sessions after the user has been idle for a certain number of hours. The number of hours can be set in conf.yml for each hutch. If no value is set the default timeout duration is 48 hours.
+
+Bugfixes
+--------
+- N/A
+
+Maintenance
+-----------
+- N/A
+
+Contributors
+------------
+- janeliu-slac

hutch_python/cli.py

@@ -121,6 +121,7 @@ def configure_ipython_session(args: HutchPythonArgs):
     # Important Utilities
     ipy_config.InteractiveShellApp.extensions = [
         "hutch_python.ipython_log",
+        "hutch_python.ipython_session_timer",
         "hutch_python.bug",
         "hutch_python.pt_app_config"
     ]

hutch_python/constants.py

@@ -38,6 +38,7 @@
     'daq_type',
     'daq_host',
     'obj_config',
+    'session_timer',
 )
 NO_LOG_EXCEPTIONS = (KeyboardInterrupt, SystemExit)
 LOG_DOMAINS = {".pcdsn", ".slac.stanford.edu"}

hutch_python/ipython_session_timer.py

@@ -0,0 +1,113 @@
+"""
+This module modifies an ``ipython`` shell to automatically close if it has been
+idle for a certain number of hours. Each hutch can configure their conf.yml
+file to set a timeout duration. The default duration is 48 hours.
+"""
+
+import time
+from threading import Thread
+
+from IPython import get_ipython
+
+max_idle_time = 172800.0  # number of seconds in 48 hours
+
+
+def configure_timeout(session_timer):
+    global max_idle_time
+    if isinstance(session_timer, int) and session_timer > 0:
+        max_idle_time = session_timer
+
+
+class IPythonSessionTimer:
+    '''
+    Class tracks the amount of time the current `InteractiveShell` instance (henceforth
+    called 'user session') has been idle and closes the session if more than 48
+    hours have passed.
+
+    Time is in seconds (floating point) since the epoch began. (In UNIX the
+    epoch started on January 1, 1970, 00:00:00 UTC)
+
+    Parameters
+    ----------
+    ipython : ``IPython.terminal.interactiveshell.TerminalInteractiveShell``
+        The active ``ipython`` ``Shell``, perhaps the one returned by
+        ``IPython.get_ipython()``.
+
+    Attributes
+    ----------
+    curr_time: float
+        The current time in seconds.
+
+    max_idle_time: float
+        The maximum number of seconds a user session can be idle (default is
+        172800.0 seconds or 48 hours).
+
+    last_active_time: float
+        The time of the last user activity in this session.
+
+    idle_time: float
+        The amount of time the user session has been idle.
+    '''
+
+    def __init__(self, ipython):
+        global max_idle_time
+        self.curr_time = 0.0
+        self.max_idle_time = 20.0  # max_idle_time
+        self.last_active_time = 0.0
+        self.idle_time = 0.0
+        self.user_active = False
+
+        ipython.events.register('pre_run_cell', self._set_user_active)
+        ipython.events.register('post_run_cell', self._set_user_inactive)
+
+    def _set_user_active(self):
+        self.user_active = True
+        self.last_active_time = time.monotonic()
+
+    def _set_user_inactive(self):
+        self.user_active = False
+        self.last_active_time = time.monotonic()
+
+    def _set_idle_time(self):
+        self.curr_time = time.monotonic()
+        self.idle_time = self.curr_time - self.last_active_time
+
+    def _timer(self, sleep_time):
+        time.sleep(sleep_time)
+
+    def _start_session(self):
+        # Check if idle_time has exceeded max_idle_time
+        while (self.idle_time < self.max_idle_time):
+
+            # Check if user is active once every minute
+            while (self.user_active):
+                time.sleep(6)
+                self.idle_time = 0
+
+            self._timer(self.max_idle_time - self.idle_time)
+            self._set_idle_time()
+
+        # Close the ipython session
+        print("This hutch-python session has timed out. Please start a new session.")
+
+        ip = get_ipython()
+        ip.ask_exit()
+        ip.pt_app.app.exit()
+
+
+def load_ipython_extension(ipython):
+    """
+    Initialize the `IPythonSessionTimer`.
+
+    This starts a timer that checks if the user session has been
+    idle for 48 hours or longer. If so, close the user session.
+
+    Parameters
+    ----------
+    ipython: IPython.terminal.interactiveshell.TerminalInteractiveShell
+        The active ``ipython`` ``Shell``, the one returned by
+        ``IPython.get_ipython()``.
+    """
+    UserSessionTimer = IPythonSessionTimer(ipython)
+    t1 = Thread(target=UserSessionTimer._start_session, daemon=True)
+    t1.start()

hutch_python/load_conf.py

@@ -21,6 +21,7 @@
 from pcdsdaq.sim import set_sim_mode as set_daq_sim
 from pcdsdevices.interface import setup_preset_paths
 
+import hutch_python.ipython_session_timer
 
 from . import calc_defaults, plan_defaults, sim, log_setup
 from .cache import LoadCache
@@ -202,7 +203,8 @@ def load_conf(conf, hutch_dir=None, args=None):
             db = None
     except KeyError:
         db = None
-        logger.info('Missing db from conf. Will skip loading from shared database.')
+        logger.info(
+            'Missing db from conf. Will skip loading from shared database.')
 
     try:
         load_level_setting = conf['load_level']
@@ -295,6 +297,15 @@ def load_conf(conf, hutch_dir=None, args=None):
         daq_platform = 0
         logger.info('Selected default hutch-python daq platform: 0')
 
+    # Set the session timeout duration
+    try:
+        hutch_python.ipython_session_timer.configure_timeout(
+            conf['session_timer'])
+    except KeyError:
+        hutch_python.ipython_session_timer.configure_timeout(172800)
+        logger.info(
+            'Missing session_timer value from conf. Set default value to 172800 seconds (48 hours).')
+
     # Make cache namespace
     cache = LoadCache((hutch or 'hutch') + '.db', hutch_dir=hutch_dir)
 
@@ -366,8 +377,8 @@ def load_conf(conf, hutch_dir=None, args=None):
                 logger.warning('Sim mode not implemented for lcls2 DAQ!')
                 logger.warning('Instantiating live DAQ!')
             # Optional dependency
-            from psdaq.control.DaqControl import DaqControl # NOQA
-            from psdaq.control.BlueskyScan import BlueskyScan # NOQA
+            from psdaq.control.DaqControl import DaqControl  # NOQA
+            from psdaq.control.BlueskyScan import BlueskyScan  # NOQA
             daq_control = DaqControl(
                 host=daq_host,
                 platform=daq_platform,