agent-bios 0.10.0 → 0.12.0

package/compose/prune-backups.py

@@ -94,18 +94,29 @@ def prune(state_dir, homes, now=None, dry=False):
     now = time.time() if now is None else now
     removed = []
 
+    # Recorded AFTER the removal is confirmed gone. Both deleters swallow their errors on
+    # purpose — a backup that will not delete must not fail an install — but appending
+    # first made the returned list a record of what was ATTEMPTED, and the caller prints it
+    # as what was removed. A copy still on disk being reported as pruned is the reading
+    # that sends someone looking for space that was never freed.
+    def take(path, remove):
+        if dry:
+            removed.append(path)
+            return
+        remove(path)
+        if path.exists():
+            print(f"  warning: could not remove {path}", file=sys.stderr)
+            return
+        removed.append(path)
+
     backups = state_dir / "backups"
     if backups.is_dir():
         for path in to_delete(_entries([d for d in backups.iterdir() if d.is_dir()]), now):
-            removed.append(path)
-            if not dry:
-                shutil.rmtree(path, ignore_errors=True)
+            take(path, lambda p: shutil.rmtree(p, ignore_errors=True))
 
     for home in homes:
         for path in to_delete(_entries(owned_siblings(home)), now):
-            removed.append(path)
-            if not dry:
-                path.unlink(missing_ok=True)
+            take(path, lambda p: p.unlink(missing_ok=True))
     return removed
 
 
@@ -163,7 +174,46 @@ def self_test():
     if not missed and not grabbed:
         print(f"  ok   ownership: claims {len(ours)} shapes we write, "
               f"refuses {len(theirs)} we do not")
-    print(f"prune-backups self-test: {'OK' if not bad else 'FAIL'} ({len(cases) + 2} checks)")
+    # The reported list is what the caller prints as removed, so it has to be what is GONE.
+    # Both deleters swallow their errors by design — a stuck copy must not fail an install —
+    # and appending before the call made the list a record of attempts instead. Driven on a
+    # real directory, because the defect lives in the deletion and not in the pure retention
+    # rule above; the deletable run beside it is what keeps this from passing on a pruner
+    # that reports nothing at all.
+    import os as os_, tempfile as tempfile_
+
+    def reported_vs_gone(block_one):
+        root = pathlib.Path(tempfile_.mkdtemp())
+        state = root / "state"
+        (state / "backups").mkdir(parents=True)
+        made = []
+        for i in range(KEEP_RECENT + 2):
+            aged = state / "backups" / f"2020{i:04d}-000000"
+            aged.mkdir()
+            (aged / "f.txt").write_text("x")
+            stamp = now - (MAX_AGE_DAYS + 10 + i) * day
+            os_.utime(aged, (stamp, stamp))
+            made.append(aged)
+        stuck = sorted(made, key=lambda q: q.stat().st_mtime)[0]
+        if block_one:
+            stuck.chmod(0o500)
+        count = len(prune(state, [], now=now))
+        gone = len([q for q in made if not q.exists()])
+        if block_one:
+            stuck.chmod(0o700)
+        shutil.rmtree(root, ignore_errors=True)
+        return count, gone
+
+    for label, block_one in (("every aged backup deletable", False),
+                             ("one of them undeletable", True)):
+        count, gone = reported_vs_gone(block_one)
+        if count != gone or (not block_one and gone == 0):
+            print(f"  FAIL {label}: reported {count} removed, {gone} actually gone")
+            bad += 1
+        else:
+            print(f"  ok   {label}: reported {count} == gone {gone}")
+
+    print(f"prune-backups self-test: {'OK' if not bad else 'FAIL'} ({len(cases) + 4} checks)")
     return 1 if bad else 0