Merge branch 'main' into sysdiagnose_date

Author: cvandeplas

src/sysdiagnose/__init__.py

@@ -22,8 +22,9 @@ def cases(self, force: bool = False) -> dict:
         # pseudo singleton, so it's not loaded unless necessary
         # load cases + migration of old cases format to new format
         if not self._cases or force:
+            lock = FileLock(self.config.cases_file)
             try:
-                FileLock.acquire_lock(self.config.cases_file)
+                lock.acquire()
                 with open(self.config.cases_file, 'r+') as f:
                     self._cases = json.load(f)
                     if 'cases' in self._cases:  # conversion is needed
@@ -41,7 +42,7 @@ def cases(self, force: bool = False) -> dict:
                 with open(self.config.cases_file, 'w') as f:
                     json.dump(self._cases, f, indent=4)
             finally:
-                FileLock.release_lock(self.config.cases_file)
+                lock.release()
 
         return self._cases
 
@@ -65,16 +66,17 @@ def delete_case(self, case_id: str) -> None:
                 raise Exception(f"Error while deleting case folder: {str(e)}")
 
         # delete case from the cases
+        lock = FileLock(self.config.cases_file)
         try:
-            FileLock.acquire_lock(self.config.cases_file)
+            lock.acquire()
             with open(self.config.cases_file, 'r+') as f:
                 self._cases = json.load(f)           # load latest version
                 self._cases.pop(case_id, None)       # delete case
                 f.seek(0)                            # go back to the beginning of the file
                 json.dump(self._cases, f, indent=4, sort_keys=True)  # save the updated version
                 f.truncate()                         # truncate the rest of the file ensuring no old data is left
         finally:
-            FileLock.release_lock(self.config.cases_file)
+            lock.release()
 
     def create_case(self, sysdiagnose_file: str, force: bool = False, case_id: bool | str = False, tags: list[str] = None) -> int:
         '''
@@ -161,16 +163,17 @@ def create_case(self, sysdiagnose_file: str, force: bool = False, case_id: bool
         self.extract_sysdiagnose_files(sysdiagnose_file, case_data_folder)
 
         # update case with new data
+        lock = FileLock(self.config.cases_file)
         try:
-            FileLock.acquire_lock(self.config.cases_file)
+            lock.acquire()
             with open(self.config.cases_file, 'r+') as f:
                 self._cases = json.load(f)           # load latest version
                 self._cases[case['case_id']] = case  # update own case
                 f.seek(0)                            # go back to the beginning of the file
                 json.dump(self._cases, f, indent=4, sort_keys=True)  # save the updated version
                 f.truncate()                         # truncate the rest of the file ensuring no old data is left
         finally:
-            FileLock.release_lock(self.config.cases_file)
+            lock.release()
 
         print(f"Sysdiagnose file has been processed: {sysdiagnose_file}")
         return case

src/sysdiagnose/parsers/accessibility_tcc.py

@@ -31,7 +31,7 @@ def execute(self) -> list | dict:
         # only one file to parse
         try:
             result = []
-            apollo = Apollo(logger=logger, os_version='yolo')  # FIXME get right OS version, but also update the Apollo modules to be aware of the latest OS versions
+            apollo = Apollo(logger=logger, os_version='yolo', saf_module=self.module_name)  # FIXME get right OS version, but also update the Apollo modules to be aware of the latest OS versions
             for logfile in self.get_log_files():
                 result.extend(apollo.parse_db(db_fname=logfile, db_type='TCC.db'))
             return result

src/sysdiagnose/utils/apollo.py

@@ -166,7 +166,7 @@ def parse_db(self, db_fname: str, db_type: str = None) -> list:
                     item['timestamp'] = timestamp.timestamp()
                     item['datetime'] = timestamp.isoformat(timespec='microseconds')
                     item['timestamp_desc'] = module_query['activity']
-                    item['module_name'] = module_query['name']
+                    item['apollo_module'] = module_query['name']
                     item['saf_module'] = self.saf_module
                     item['message'] = module_query['activity'] + ': ' + ', '.join([f"{k}={v}" for k, v in list(zip(headers, row)) if k != key_timestamp and 'time' not in k and 'id' not in k])
                     results.append(item)

src/sysdiagnose/utils/lock.py

@@ -12,24 +12,48 @@ class FileLock:
     to be locked. The lock is released when the file is deleted.
     This is useful for ensuring that only one process can access a resource at a time.
 
-    Make sure to use try, finally and always release the lock.
+    Make sure to use try, finally and always release the lock if a lock was acquired.
+
+    Usage:
+    lock = FileLock("myfile.txt")
+    try:
+        lock.acquire()
+        # Perform operations on the file
+    except TimeoutError as e:
+        print(f"Could not acquire lock: {e}")
+    finally:
+        lock.release()
     '''
-    @staticmethod
-    def acquire_lock(filename: str, timeout: int = 5):
-        """Create a lock file for the given filename, waiting for the lock to be available."""
-        lock_file = Path(f"{filename}.lock")
-        start_time = time.time()
+    def __init__(self, filename: str, timeout: int = 5):
+        self.filename = filename
+        self.timeout = timeout
+        self.locked = False
+        self.lock_file = Path(f"{filename}.lock")
+
+    def acquire(self):
+        """
+        Acquire the lock for the given filename.
+        Waits until the lock is available or raises a TimeoutError if it cannot be acquired within the specified timeout.
+        """
+        if self.locked:
+            return  # Already locked, no need to acquire again
 
-        while lock_file.exists():
-            if time.time() - start_time > timeout:
-                raise TimeoutError(f"Could not acquire lock for {filename} within {timeout} seconds.")
+        start_time = time.time()
+        while self.lock_file.exists():
+            if time.time() - start_time > self.timeout:
+                self.locked = False
+                raise TimeoutError(f"Could not acquire lock for {self.filename} within {self.timeout} seconds.")
             time.sleep(0.1)
 
-        lock_file.touch()
-
-    @staticmethod
-    def release_lock(filename: str):
-        """Release the lock by deleting the lock file."""
-        lock_file = Path(f"{filename}.lock")
-        if lock_file.exists():
-            lock_file.unlink()
+        self.lock_file.touch()
+        self.locked = True
+
+    def release(self):
+        """
+        Release the lock by deleting the lock file.
+        If the lock file does not exist, it does nothing.
+        """
+        if self.locked:
+            self.locked = False
+            if self.lock_file.exists():
+                self.lock_file.unlink()

tests/test_lock.py

@@ -0,0 +1,45 @@
+
+from tests import SysdiagnoseTestCase
+from sysdiagnose.utils.lock import FileLock
+import unittest
+
+
+class TestLock(SysdiagnoseTestCase):
+
+    def test_lock(self):
+        lock = FileLock('foo.txt', timeout=1)
+        # first remove any existing lock file
+        lock.lock_file.unlink(missing_ok=True)
+        # do the real test
+        lock.acquire()
+        self.assertTrue(lock.locked)
+        lock.release()
+        self.assertFalse(lock.locked)
+        self.assertFalse(lock.lock_file.exists())
+
+    def test_lock_timeout(self):
+        lock = FileLock('foo.txt', timeout=1)
+        # first remove any existing lock file
+        lock.lock_file.unlink(missing_ok=True)
+        lock.acquire()
+        self.assertTrue(lock.locked)
+
+        # Try to acquire the lock again, should raise TimeoutError
+        with self.assertRaises(TimeoutError):
+            lock2 = FileLock('foo.txt', timeout=1)
+            lock2.acquire()
+
+        # Release the first lock
+        lock.release()
+        self.assertFalse(lock.locked)
+        self.assertFalse(lock.lock_file.exists())
+
+        # Now we can acquire the lock again
+        lock2.acquire()
+        self.assertTrue(lock2.locked)
+        lock2.release()
+        self.assertFalse(lock2.lock_file.exists())
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_parsers_accessibility_tcc.py

@@ -17,7 +17,7 @@ def test_get_accessibility_tcc(self):
 
             result = p.get_result()
             for item in result:
-                self.assertTrue('module_name' in item)
+                self.assertTrue('apollo_module' in item)
                 self.assert_has_required_fields_jsonl(item)
 
 

tests/test_parsers_powerlogs.py

@@ -18,7 +18,7 @@ def test_get_powerlogs(self):
             result = p.get_result()
             if result:  # some files are empty
                 for item in result:
-                    self.assertTrue('module_name' in item)
+                    self.assertTrue('apollo_module' in item)
                     self.assert_has_required_fields_jsonl(item)