ekfsm 0.13.0a168.post1__py3-none-any.whl → 0.13.0a183.post1__py3-none-any.whl

ekfsm/__init__.py

@@ -3,6 +3,7 @@ from .system import System
 from .core import HwModule
 from .core.slots import SlotType
 from .exceptions import ConfigError
+from .lock import locking_cleanup, locking_configure
 
 __all__ = (
     "System",
@@ -10,4 +11,6 @@ __all__ = (
     "HwModule",
     "Slot",
     "SlotType",
+    "locking_cleanup",
+    "locking_configure",
 )

ekfsm/boards/oem/hitron/hdrc-300s.yaml

@@ -1,4 +1,4 @@
-id: HDRC300S-110J-D120E(N)
+id: HDRC300S.*
 name: "Hitron HDRC-300S"
 slot_type: CPCI_S0_PSU
 children:

ekfsm/devices/ekf_ccu_uc.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Tuple
 from ekfsm.core.components import SysTree
 from ..exceptions import AcquisitionError
+from ..lock import Locker
 from .imu import ImuSample
 import struct
 
@@ -292,21 +293,18 @@ class EKFCcuUc(Device):
         progress_callback
             A callback function that is called with the current progress in bytes.
 
-        Warning
-        ---------
-        Do not call this method at the same time from multiple threads or processes.
-
         """
-        offset = 0
-        max_chunk_len = 28
-        while len(firmware) > 0:
-            chunk, firmware = firmware[:max_chunk_len], firmware[max_chunk_len:]
-            self._load_firmware_chunk(offset, len(firmware) == 0, chunk)
-            offset += len(chunk)
-            if len(firmware) != 0:
-                self._nop()
-            if progress_callback is not None:
-                progress_callback(offset)
+        with Locker(self.name + "-load_firmware").lock():
+            offset = 0
+            max_chunk_len = 28
+            while len(firmware) > 0:
+                chunk, firmware = firmware[:max_chunk_len], firmware[max_chunk_len:]
+                self._load_firmware_chunk(offset, len(firmware) == 0, chunk)
+                offset += len(chunk)
+                if len(firmware) != 0:
+                    self._nop()
+                if progress_callback is not None:
+                    progress_callback(offset)
 
     def _load_firmware_chunk(self, offset: int, is_last: bool, data: bytes) -> None:
         if is_last:
@@ -369,22 +367,20 @@ class EKFCcuUc(Device):
         str
             The parameterset in JSON format.
 
-        Warning
-        ---------
-        Do not call this method at the same time from multiple threads or processes.
         """
-        json = b""
-        begin = True
-        while True:
-            chunk = self._get_parameterset_chunk(begin)
-            if len(chunk) < 32:
-                break
-            # if chunk ends with zero byte, remove it (workaround for I2C slave bug)
-            if chunk[-1] == 0:
-                chunk = chunk[:-1]
-            json += chunk
-            begin = False
-        return json.decode("utf-8")
+        with Locker(self.name + "-parameterset").lock():
+            json = b""
+            begin = True
+            while True:
+                chunk = self._get_parameterset_chunk(begin)
+                if len(chunk) < 32:
+                    break
+                # if chunk ends with zero byte, remove it (workaround for I2C slave bug)
+                if chunk[-1] == 0:
+                    chunk = chunk[:-1]
+                json += chunk
+                begin = False
+            return json.decode("utf-8")
 
     def _get_parameterset_chunk(self, begin: bool) -> bytes:
         data = self._smbus.read_block_data(
@@ -423,19 +419,16 @@ class EKFCcuUc(Device):
         _cfg
             The parameterset in JSON format.
 
-        Warning
-        ---------
-        Do not call this method at the same time from multiple threads or processes.
-
         """
-        cfg = _cfg.encode("utf-8")
-        offset = 0
-        max_chunk_len = 28
-        while len(cfg) > 0:
-            chunk, cfg = cfg[:max_chunk_len], cfg[max_chunk_len:]
-            self._load_parameterset_chunk(offset, len(cfg) == 0, chunk)
-            offset += len(chunk)
-            self._nop()
+        with Locker(self.name + "-parameterset").lock():
+            cfg = _cfg.encode("utf-8")
+            offset = 0
+            max_chunk_len = 28
+            while len(cfg) > 0:
+                chunk, cfg = cfg[:max_chunk_len], cfg[max_chunk_len:]
+                self._load_parameterset_chunk(offset, len(cfg) == 0, chunk)
+                offset += len(chunk)
+                self._nop()
 
     def _load_parameterset_chunk(self, offset: int, is_last: bool, data: bytes) -> None:
         if is_last:

ekfsm/devices/pmbus.py

@@ -12,6 +12,7 @@ from time import sleep
 from functools import wraps
 from ekfsm.log import ekfsm_logger
 from threading import Lock
+import re
 
 __all__ = ["PsuStatus", "PmBus", "retry"]
 
@@ -118,7 +119,8 @@ class PmBus(Device, ProbeableDevice):
         from ekfsm.core import HwModule
 
         assert isinstance(self.hw_module, HwModule)
-        return self.hw_module.id == self.model()
+        # compare the regexp from the board yaml file with the model
+        return re.match(self.hw_module.id, self.model()) is not None
 
     # Voltage and Current Interfaces
     def _conversion(self, in_file: str) -> float:

ekfsm/lock.py

@@ -0,0 +1,94 @@
+import fcntl
+import os
+from pathlib import Path
+from contextlib import contextmanager
+
+#
+# Some devices or device functions don't allow concurrent access.
+# The locking mechanism is used to ensure that only one process/thread can
+# access the device (function) at a time.
+#
+# Locking granularity is defined by the device.
+# It may be at the device level or function level.
+#
+# Application can choose to use the locking mechanism or not.
+# By default, the locking mechanism is enabled and uses the default
+# lockfile root directory /var/lock/ekfsm.
+#
+# Use locking_configure() to enable or disable the locking mechanism or to change
+# the lockfile root directory.
+
+USE_LOCK = True
+LOCKFILE_ROOT = "/var/lock/ekfsm"
+ALL_LOCKERS: list["Locker"] = []  # List of all locker instances
+
+
+def locking_configure(enable: bool, lockfile_root: str = LOCKFILE_ROOT):
+    """
+    Configures the locking mechanism.
+
+    :param enable: Whether to enable or disable locking.
+    :param lockfile_root: The root directory for lockfiles. (default: /var/lock/ekfsm)
+    """
+    global USE_LOCK, LOCKFILE_ROOT
+    USE_LOCK = enable
+    LOCKFILE_ROOT = lockfile_root
+
+
+def locking_cleanup():
+    """
+    Cleans up all lockfiles and closes all lock file descriptors.
+    Should be called at the end of the program to ensure all locks are released.
+    """
+    for locker in ALL_LOCKERS:
+        locker.cleanup()
+
+
+class Locker:
+    """
+    A class that implements a locking mechanism using file locks.
+
+    Parameters
+    ----------
+    module
+        The name of the module or resource to lock. This will be used to create a unique lock file.
+
+    Example
+    -------
+    with Locker("mysharedresourcename").lock():
+        # Access the shared resource here
+        pass
+    """
+
+    def __init__(self, module: str):
+        if not USE_LOCK:
+            return
+
+        self.lockfile_path = Path(LOCKFILE_ROOT) / module
+        self.lock_fd = None
+        # Ensure lockfile exists
+        os.makedirs(LOCKFILE_ROOT, exist_ok=True)
+        open(self.lockfile_path, "a").close()
+        ALL_LOCKERS.append(self)
+
+    def cleanup(self):
+        if not USE_LOCK:
+            return
+        if self.lock_fd is not None:
+            try:
+                fcntl.flock(self.lock_fd, fcntl.LOCK_UN)
+                os.close(self.lock_fd)
+                self.lock_fd = None
+            except (OSError, AttributeError):
+                pass
+
+    @contextmanager
+    def lock(self):
+        if not USE_LOCK:
+            yield
+        self.lock_fd = os.open(self.lockfile_path, os.O_RDWR)
+        try:
+            fcntl.flock(self.lock_fd, fcntl.LOCK_EX)
+            yield
+        finally:
+            self.cleanup()

{ekfsm-0.13.0a168.post1.dist-info → ekfsm-0.13.0a183.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ekfsm
-Version: 0.13.0a168.post1
+Version: 0.13.0a183.post1
 Summary: The EKF System Management Library (ekfsm) is a sensor monitoring suite for Compact PCI Serial devices.
 Author-email: Klaus Popp <klaus.popp@ci4rail.com>, Jan Jansen <jan@ekf.de>, Felix Päßler <fp@ekf.de>
 Requires-Python: >=3.10

{ekfsm-0.13.0a168.post1.dist-info → ekfsm-0.13.0a183.post1.dist-info}/RECORD

@@ -1,7 +1,8 @@
-ekfsm/__init__.py,sha256=RF5mSVhkFWVsbJgYk-qMKb9eVHAcQ7WbJCunGBim4Ig,244
+ekfsm/__init__.py,sha256=UQljpq-to0fUnfzSlYJ-jdfv8CCc6ZQKBXoTnss67i8,345
 ekfsm/cli.py,sha256=ElaIx49lujDM-XCE0R29pv1AsqqnMcNCPZ1-S5XOpSw,2931
 ekfsm/config.py,sha256=FTk47f3qA05Zv6Cy_L_5XlGmmbC9z_kPdQJKpVoHkWs,924
 ekfsm/exceptions.py,sha256=25P677GxfBTdBWHRngPce0bmhcLg7MFeTtuAvguxd90,1310
+ekfsm/lock.py,sha256=qmWkW6OA-NLiDrtSsQn-K10tZJ19t-h4iFB5zyL97Vw,2682
 ekfsm/log.py,sha256=_GC8Y7a4fFV4_DNicbwQ-5rRzNQU6WSotXd2etXSrZk,866
 ekfsm/py.typed,sha256=1gNRtmxvYcVqDDEyAzBLnD8dAOweUfYxW2ZPdJzN1fg,102
 ekfsm/simctrl.py,sha256=NkmjvqOym9Wruh0f14Od6gHfEgPMAkxUzMQ-nvzcM3Q,6681
@@ -16,7 +17,7 @@ ekfsm/boards/oem/ekf/sq1-track.yaml,sha256=YU83BQjGu-4ejirwnGxd38sJme859kdRovkZy
 ekfsm/boards/oem/ekf/sq3-quartet.yaml,sha256=pBB7Tv0IWLkFUYBs3tFvZriA-uqPuPIgzjaN0aHT4e4,1052
 ekfsm/boards/oem/ekf/srf-fan.yaml,sha256=Mcu1Q8B1Ih10hoc_hbkGlppBmbOFcufsVUR42iW4Rwc,1368
 ekfsm/boards/oem/ekf/sur-uart.yaml,sha256=VaNP2BSlNTi1lDco16Ma9smPEAMaVKvx-ZNDcm3QptM,1890
-ekfsm/boards/oem/hitron/hdrc-300s.yaml,sha256=Cji2ZmYsEUvHQ0m04iKkPlzDNRwJgqj8y2lzQzkAWd4,560
+ekfsm/boards/oem/hitron/hdrc-300s.yaml,sha256=E567QsRPvyAEXpXOeF1OvX2AoQK8BTxI0C7QVBFlT_k,548
 ekfsm/core/__init__.py,sha256=nv3Rs-E953M9PBFV9ryejRY-KM6xG1NMlQTWwzCEQwo,212
 ekfsm/core/components.py,sha256=dh71jM_OJ8QhTzou-5L6RaF3abXgE470KJfxQRqq1CY,3836
 ekfsm/core/probe.py,sha256=DgJvkvMjVk09n0Rzn13ybRvidrmFn_D2PD56XS-KgxU,262
@@ -26,7 +27,7 @@ ekfsm/core/utils.py,sha256=EoPOuRmLlvHvGneDcKjP7Qbjfsc4XlMbLeaSFRObt_E,3145
 ekfsm/devices/__init__.py,sha256=UtFLCtAdpDJ3OaY7fedk13bx90NMsfxhyVAHV13t2U4,936
 ekfsm/devices/coretemp.py,sha256=s0qUoVR90hr9O7Yp7AecXc_LAfrd0LUIJSm2Wh7AJZY,2012
 ekfsm/devices/eeprom.py,sha256=8z0eWs4ljRtoLoS3rLbMiGcSxWmNmXeJ8zB6hRGZXis,32042
-ekfsm/devices/ekf_ccu_uc.py,sha256=Jmy2HiXPG39MHmD9JGtIR5U9UoeyIQnIbiz9VPZteEk,15252
+ekfsm/devices/ekf_ccu_uc.py,sha256=a1vztQQfRVNVikJ-jBNTV9lgtm_i8056J6UMi6qiDcg,15211
 ekfsm/devices/ekf_sur_led.py,sha256=dY2EIqUx4-LV7ipCEIg8DfXWlGxpspRmEtEhVfHY6LI,1871
 ekfsm/devices/generic.py,sha256=Xii1fkV8R2kRvWCe9Pg-uOVDWXa-Ow5AM6CbUYKcxSI,9494
 ekfsm/devices/gpio.py,sha256=hlJ3yJ8jSGUIkPpjymani0EcxYJX2iEybGbnV8N0O5E,9552
@@ -34,11 +35,11 @@ ekfsm/devices/iio.py,sha256=gMOJGdg2PvFbAvlBpLfDTIc_-9i1Z3OLpuabTke6N3I,1480
 ekfsm/devices/iio_thermal_humidity.py,sha256=4Qod31hhnUIHP6ojv_cf2JLld8OCN1McFOPTJL-Ue-A,1196
 ekfsm/devices/imu.py,sha256=bnSaTjGSLV90FyUbkK9oTon0dmF7N_JQ4uGmBPFA5Co,414
 ekfsm/devices/mux.py,sha256=CV5ECUiEvaxXNoozMFchsuLD4FpYD_7uFp62DNWVFJ0,1026
-ekfsm/devices/pmbus.py,sha256=Tgve-a_-9SvlaPUGZw87Ulh3Z5wIBxBPLap3zzsgr2Q,6383
+ekfsm/devices/pmbus.py,sha256=rdhVvwuV0pQs7DvQgluoKLVPHBRa13HpJiU6oVwkLRg,6482
 ekfsm/devices/smbios.py,sha256=gDDYtfCd7njzqxJBKJxIR2BMCK6-uZxUVxC9y0hnz4g,1009
 ekfsm/devices/smbus.py,sha256=zD9b6PehipMw-xoaOMC-oorDVxBoo30hc98gyFxFLs0,500
 ekfsm/devices/utils.py,sha256=4-0Kmvy4ou8R71afNj6RqdBTjLW4SMWPHqVrzB2RUZw,397
-ekfsm-0.13.0a168.post1.dist-info/METADATA,sha256=dd-yEslD64NYfCMidSe2G61CMwVaCwDlaaSLu1jvdA8,6552
-ekfsm-0.13.0a168.post1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ekfsm-0.13.0a168.post1.dist-info/entry_points.txt,sha256=WhUR4FzuxPoGrbTOKLsNJO7NAnk2qd4T30fqzN1yLw8,45
-ekfsm-0.13.0a168.post1.dist-info/RECORD,,
+ekfsm-0.13.0a183.post1.dist-info/METADATA,sha256=yqILFbdhxfGAZHHpNwDa7rT2SRYJME8GpJMNsmy89YA,6552
+ekfsm-0.13.0a183.post1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ekfsm-0.13.0a183.post1.dist-info/entry_points.txt,sha256=WhUR4FzuxPoGrbTOKLsNJO7NAnk2qd4T30fqzN1yLw8,45
+ekfsm-0.13.0a183.post1.dist-info/RECORD,,