Change from threads to asyncio

bulletmark · bulletmark · commit 77a1fda3231e · 2023-06-04T14:52:56.000+10:00
Each plugin is run as an asyncio task rather than a slightly more
resource heavy system thread.

Also make a couple of minor improvements and add a test directory.
diff --git a/Makefile b/Makefile
@@ -19,7 +19,7 @@ upload: sdist
 	twine3 upload --skip-existing dist/*
 
 check:
-	flake8 $(PYNAME).py setup.py
+	ruff .
 	vermin --no-tips -i $(PYNAME).py setup.py
 	python3 setup.py check
 	shellcheck plugins/*
diff --git a/README.md b/README.md
@@ -74,7 +74,7 @@ to execute the sleep inhibition lock.
 AUR](https://aur.archlinux.org/packages/sleep-inhibitor) then skip to
 the next Configuration section.
 
-Python 3.6 or later is required. The 3rd party ruamel.yaml package is
+Python 3.7 or later is required. The 3rd party ruamel.yaml package is
 also required. Note [_sleep-inhibitor_ is on
 PyPI](https://pypi.org/project/sleep-inhibitor/) so just ensure that
 `python3-pip` and `python3-wheel` are installed then type the following
diff --git a/setup.py b/setup.py
@@ -11,7 +11,7 @@
 
 setup(
     name=name,
-    version='1.16',
+    version='1.17',
     description='Program to run plugins to inhibit system '
     'sleep/suspend/hibernate',
     long_description=here.joinpath('README.md').read_text(),
@@ -22,7 +22,7 @@
     keywords='bash',
     license='GPLv3',
     py_modules=[module],
-    python_requires='>=3.6',
+    python_requires='>=3.7',
     install_requires=['ruamel.yaml'],
     classifiers=[
         'Programming Language :: Python :: 3',
diff --git a/sleep-inhibitor.conf b/sleep-inhibitor.conf
@@ -22,6 +22,7 @@
 # Default global check period, while ON/INHIBITING, in minutes. Can be
 # specified for each plugin, or if not specified will be the global
 # default you define here, or is "period" above if not specified at all.
+# Will be limited to "period" value so can not be larger.
 #
 # period_on:
 #
diff --git a/sleep_inhibitor.py b/sleep_inhibitor.py
@@ -1,15 +1,14 @@
-#!/usr/bin/python3
+#!/usr/bin/python3 -u
 'Program to run plugins to inhibit system sleep/suspend.'
 # Requires python 3.6+
 # Mark Blakeney, Jul 2020.
 
-# Standard packages
-import sys
 import argparse
+import asyncio
+import shlex
 import subprocess
-import threading
+import sys
 import time
-import shlex
 from pathlib import Path
 
 # Return code which indicates plugin wants to inhibit suspend
@@ -22,32 +21,26 @@
     'systemd-inhibit',
 )
 
-def gettime(conf, field, default=None):
-    'Read time value from given conf.'
-    val = conf.get(field, default)
-    if val is None:
-        return None
-
+def conv_to_secs(val):
+    'Convert given time string to float seconds'
     if isinstance(val, str):
         if val.endswith('s'):
-            num = float(val[:-1]) / 60
-        elif val.endswith('m'):
             num = float(val[:-1])
-        elif val.endswith('h'):
+        elif val.endswith('m'):
             num = float(val[:-1]) * 60
+        elif val.endswith('h'):
+            num = float(val[:-1]) * 60 * 60
         else:
-            sys.exit(f'Invalid time value "{field}: {val}".')
+            sys.exit(f'Invalid time string "{val}".')
     else:
-        num = float(val)
+        # Default time entry is minutes
+        num = float(val) * 60
 
     return num
 
 class Plugin:
     'Class to manage each plugin'
-    loglock = threading.Lock()
-    threads = []
-
-    def __init__(self, index, prog, progname, def_period, def_period_on,
+    def __init__(self, index, prog, progname, period, period_on,
             def_what, conf, plugin_dir, inhibitor_prog):
         'Constructor'
         pathstr = conf.get('path')
@@ -69,15 +62,15 @@ def __init__(self, index, prog, progname, def_period, def_period_on,
         if not path.exists():
             sys.exit(f'{self.name}: "{path}" does not exist')
 
-        period = gettime(conf, 'period')
-        if period is None:
-            period = def_period
-            period_on_def = def_period_on
-        else:
-            period_on_def = period
+        period_str = conf.get('period', period)
+        self.period = conv_to_secs(period_str)
+
+        period_on_str = conf.get('period_on', period_on)
+        period_on = conv_to_secs(period_on_str)
+        if period_on > self.period:
+            period_on = self.period
+            period_on_str = period_str
 
-        period_on = gettime(conf, 'period_on', period_on_def)
-        self.period = period * 60
         self.is_inhibiting = None
 
         cmd = str(path)
@@ -95,46 +88,31 @@ def __init__(self, index, prog, progname, def_period, def_period_on,
         # run the plugin in a loop which keeps the inhibit on while the
         # inhibit state is returned.
         self.icmd = shlex.split(f'{inhibitor_prog}{what} --who="{progname}" '
-                f'--why="{self.name}" {prog} -s {period_on * 60} -i "{cmd}"')
+                f'--why="{self.name}" {prog} -s {period_on} -i "{cmd}"')
 
-        per = round(period, 3)
-        per_on = round(period_on, 3)
-        print(f'{self.name} [{path}] configured @ {per}/{per_on} minutes')
+        print(f'{self.name} [{path}] configured @ {period_str}/{period_on_str}')
 
-        # Each plugin periodic check runs in it's own thread
-        thread = threading.Thread(target=self.run)
-        thread.daemon = True
-        thread.start()
-        self.threads.append(thread)
-
-    def run(self):
-        'Worker function which runs it its own thread'
+    async def run(self):
+        'Worker function which runs as a asyncio task for each plugin'
         while True:
-            res = subprocess.run(self.cmd)
-            while res.returncode == SUSP_CODE:
+            proc = await asyncio.create_subprocess_exec(*self.cmd)
+            await proc.wait()
+
+            while proc.returncode == SUSP_CODE:
                 if not self.is_inhibiting:
                     self.is_inhibiting = True
-                    self.log(f'{self.name} is inhibiting '
-                            f'suspend (return={res.returncode})')
+                    print(f'{self.name} is inhibiting '
+                          f'suspend (return={proc.returncode})')
 
-                res = subprocess.run(self.icmd)
+                proc = await asyncio.create_subprocess_exec(*self.icmd)
+                await proc.wait()
 
             if self.is_inhibiting is not False:
                 self.is_inhibiting = False
-                self.log(f'{self.name} is not inhibiting '
-                        f'suspend (return={res.returncode})')
-
-            time.sleep(self.period)
-
-    @classmethod
-    def log(cls, msg):
-        'Thread locked print()'
-        if not msg.endswith('\n'):
-            msg += '\n'
+                print(f'{self.name} is not inhibiting '
+                      f'suspend (return={proc.returncode})')
 
-        # Use a lock so thread messages do not get interleaved
-        with cls.loglock:
-            sys.stdout.write(msg)
+            await asyncio.sleep(self.period)
 
 def init():
     'Program initialisation'
@@ -214,22 +192,21 @@ def init():
     plugin_dir = args.plugin_dir or conf.get('plugin_dir', plugin_dir)
 
     # Get some global defaults
-    period = gettime(conf, 'period', 5)
-    period_on = gettime(conf, 'period_on', period)
+    period = conf.get('period', '5m')
+    period_on = conf.get('period_on', period)
     what = conf.get('what')
 
     # Iterate to create each configured plugins
-    for index, plugin in enumerate(plugins, 1):
-        Plugin(index, prog, progname, period, period_on, what, plugin,
-                plugin_dir, inhibitor_prog)
+    return [Plugin(index, prog, progname, period, period_on, what, plugin,
+                   plugin_dir, inhibitor_prog)
+            for index, plugin in enumerate(plugins, 1)]
 
-def main():
+async def main():
     'Main entry'
-    init()
+    tasks = init()
 
-    # Wait for each thread to finish (i.e. wait forever)
-    for thread in Plugin.threads:
-        thread.join()
+    # Wait for each plugin task to finish (i.e. wait forever)
+    await asyncio.gather(*(t.run() for t in tasks))
 
 if __name__ == '__main__':
-    sys.exit(main())
+    asyncio.run(main(), debug=True)
diff --git a/test/.gitignore b/test/.gitignore
@@ -0,0 +1,3 @@
+1
+2
+3
diff --git a/test/run-test b/test/run-test
@@ -0,0 +1,4 @@
+#!/bin/bash
+# Runs with a simple test configuration.
+# E.g. touch 1 2 3 to set all on, rm 1 2 3 to turn all off.
+../sleep_inhibitor.py -c test.conf -p $PWD | ts
diff --git a/test/test.conf b/test/test.conf
@@ -0,0 +1,16 @@
+period: 2s
+
+plugins:
+  - path: test.sh
+    name: Test 1
+    args: 1
+
+  - path: test.sh
+    name: Test 2
+    args: 2
+
+  - path: test.sh
+    name: Test 3
+    args: 3
+
+# vim:se sw=2 syn=yaml et ai:
diff --git a/test/test.sh b/test/test.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+# Checks if jellyfin server is currently serving media to any user.
+# Mark Blakeney, Nov 2020.
+
+TOKEN="$1"
+TDIR="$(dirname $0)"
+
+if [[ -f $TDIR/$TOKEN ]]; then
+    exit 254
+fi
+
+exit 0

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`# Default global check period, while ON/INHIBITING, in minutes. Can be`
`23`	`23`	`# specified for each plugin, or if not specified will be the global`
`24`	`24`	`# default you define here, or is "period" above if not specified at all.`
	`25`	`+# Will be limited to "period" value so can not be larger.`
`25`	`26`	`#`
`26`	`27`	`# period_on:`
`27`	`28`	`#`