allow disabling rollbacks for Transaction

Author: forman

tests/fsutil/test_transaction.py

@@ -9,7 +9,6 @@
 
 from zappend.fsutil.fileobj import FileObj
 from zappend.fsutil.transaction import Transaction
-from zappend.fsutil.transaction import LOCK_EXT
 from zappend.fsutil.transaction import ROLLBACK_FILE
 from ..helpers import clear_memory_fs
 
@@ -21,12 +20,15 @@ def setUp(self):
         clear_memory_fs()
 
     def test_transaction_success(self):
-        self._run_transaction_test(fail=False)
+        self._run_transaction_test(fail=False, rollback=True)
 
-    def test_transaction_with_rollback(self):
-        self._run_transaction_test(fail=True)
+    def test_transaction_failure_with_rollback(self):
+        self._run_transaction_test(fail=True, rollback=True)
 
-    def _run_transaction_test(self, fail: bool):
+    def test_transaction_failure_without_rollback(self):
+        self._run_transaction_test(fail=True, rollback=False)
+
+    def _run_transaction_test(self, fail: bool, rollback: bool):
 
         test_root = FileObj("memory://test")
         test_root.mkdir()
@@ -42,7 +44,8 @@ def _run_transaction_test(self, fail: bool):
         self.assertFalse(test_file_3.exists())
 
         temp_dir = FileObj("memory://temp")
-        transaction = Transaction(test_root, temp_dir)
+        transaction = Transaction(test_root, temp_dir,
+                                  disable_rollback=not rollback)
 
         self.assertEqual(test_root, transaction.target_dir)
 
@@ -69,25 +72,26 @@ def create_test_folder(rollback_cb: Callable):
 
         try:
             with transaction as rollback_cb:
-                self.assertTrue(rollback_file.exists())
                 self.assertTrue(lock_file.exists())
+                self.assertEqual(rollback, rollback_file.exists())
 
                 change_test_file_1(rollback_cb)
                 create_test_file_2(rollback_cb)
                 create_test_folder(rollback_cb)
 
-                rollback_data = rollback_file.read(mode="rt")
-                rollback_records = [line.split()[:2]
-                                    for line in rollback_data.split("\n")]
-                self.assertEqual(
-                    [
-                        ["replace_file", "file-1.txt"],
-                        ["delete_file", "file-2.txt"],
-                        ["delete_dir", "folder"],
-                        []
-                    ],
-                    rollback_records
-                )
+                if rollback:
+                    rollback_data = rollback_file.read(mode="rt")
+                    rollback_records = [line.split()[:2]
+                                        for line in rollback_data.split("\n")]
+                    self.assertEqual(
+                        [
+                            ["replace_file", "file-1.txt"],
+                            ["delete_file", "file-2.txt"],
+                            ["delete_dir", "folder"],
+                            []
+                        ],
+                        rollback_records
+                    )
 
                 if fail:
                     raise OSError("disk full")
@@ -101,7 +105,7 @@ def create_test_folder(rollback_cb: Callable):
         self.assertFalse(lock_file.exists())
         self.assertFalse(rollback_dir.exists())
 
-        if fail:
+        if fail and rollback:
             self.assertTrue(test_root.exists())
             self.assertTrue(test_file_1.exists())  # replace_file by rollback
             self.assertEqual(b"A-B-C", test_file_1.read())

zappend/fsutil/transaction.py

@@ -27,8 +27,6 @@
 ROLLBACK_ACTIONS = "delete_dir", "delete_file", "replace_file"
 
 
-# TODO: allow disabling rollbacks entirely
-
 class Transaction:
     """
     A filesystem transaction.
@@ -57,17 +55,26 @@ class Transaction:
     Reported paths must be relative to *target_dir*. The empty path ``""``
     refers to *target_dir* itself.
 
+    When entering the context, a lock file will be created which prevents
+    other transactions to modify *target_dir*. The lock file will be placed
+    next to *target_dir* and its name is the filename of *target_dir* with a
+    ``.lock`` extension. The lock file will be removed on context exit.
+
     :param target_dir: The target directory that is subject to this
         transaction. All paths emitted to the rollback callback must be
         relative to *target_dir*. The directory may or may not exist yet.
     :param temp_dir: Temporary directory in which a unique subdirectory
         will be created that will be used to collect
         rollback data during the transaction. The directory must exist.
+    :param disable_rollback: Disable rollback entirely.
+        No rollback data will be written, however a lock file will still
+        be created for the duration of the transaction.
     """
 
     def __init__(self,
                  target_dir: FileObj,
-                 temp_dir: FileObj):
+                 temp_dir: FileObj,
+                 disable_rollback: bool = False):
         transaction_id = f"zappend-{uuid.uuid4()}"
         rollback_dir = temp_dir / transaction_id
         lock_file = target_dir.parent / (target_dir.filename + LOCK_EXT)
@@ -76,6 +83,7 @@ def __init__(self,
         self._rollback_file = rollback_dir / ROLLBACK_FILE
         self._target_dir = target_dir
         self._lock_file = lock_file
+        self._disable_rollback = disable_rollback
         self._entered_ctx = False
 
     @property
@@ -104,8 +112,9 @@ def __enter__(self):
             raise IOError(f"Target is locked: {lock_file.uri}")
         lock_file.write(self._rollback_dir.uri)
 
-        self._rollback_dir.mkdir()
-        self._rollback_file.write("")  # touch
+        if not self._disable_rollback:
+            self._rollback_dir.mkdir()
+            self._rollback_file.write("")  # touch
 
         return self._add_rollback_action
 
@@ -131,7 +140,8 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                     action_method = getattr(self, "_" + action)
                     action_method(*args)
 
-        self._rollback_dir.delete(recursive=True)
+        if not self._disable_rollback:
+            self._rollback_dir.delete(recursive=True)
 
         lock_file = self._lock_file
         try:
@@ -177,6 +187,9 @@ def _add_rollback_action(self,
             if data is not None:
                 raise ValueError(f"Value of 'data' argument must be None")
 
+        if self._disable_rollback:
+            return
+
         assert hasattr(self, "_" + action)
         if data is not None:
             backup_id = str(uuid.uuid4())