btrfs: refactor snapshot code

Author: williamstein

src/packages/file-server/btrfs/filesystem.ts

@@ -13,7 +13,8 @@ a = require('@cocalc/file-server/storage-btrfs'); fs = await a.filesystem({devic
 
 import refCache from "@cocalc/util/refcache";
 import { exists, isdir, listdir, mkdirp, rmdir, sudo } from "./util";
-import { subvolume, SNAPSHOTS, type Subvolume } from "./subvolume";
+import { subvolume, type Subvolume } from "./subvolume";
+import { SNAPSHOTS } from "./subvolume-snapshot";
 import { join, normalize } from "path";
 
 // default size of btrfs filesystem if creating an image file.
@@ -201,10 +202,13 @@ export class Filesystem {
       command: "mv",
       args: [join(this.opts.mount, source, name), join(this.opts.mount, name)],
     });
-    const snapshots = await listdir(join(this.opts.mount, name, SNAPSHOTS));
-    await rmdir(
-      snapshots.map((x) => join(this.opts.mount, name, SNAPSHOTS, x)),
-    );
+    const snapdir = join(this.opts.mount, name, SNAPSHOTS);
+    if (await exists(snapdir)) {
+      const snapshots = await listdir(snapdir);
+      await rmdir(
+        snapshots.map((x) => join(this.opts.mount, name, SNAPSHOTS, x)),
+      );
+    }
     const src = await this.subvolume(source);
     const vol = await this.subvolume(name);
     const { size } = await src.usage();

src/packages/file-server/btrfs/snapshots.ts

@@ -1,4 +1,4 @@
-import { type Subvolume } from "./subvolume";
+import { type SubvolumeSnapshot } from "./subvolume-snapshot";
 import getLogger from "@cocalc/backend/logger";
 
 const logger = getLogger("file-server:storage-btrfs:snapshots");
@@ -30,17 +30,17 @@ export interface SnapshotCounts {
 }
 
 export async function updateRollingSnapshots({
-  subvolume,
+  snapshot,
   counts,
 }: {
-  subvolume: Subvolume;
+  snapshot: SubvolumeSnapshot;
   counts?: Partial<SnapshotCounts>;
 }) {
   counts = { ...DEFAULT_SNAPSHOT_COUNTS, ...counts };
 
-  const changed = await subvolume.hasUnsavedChanges();
+  const changed = await snapshot.hasUnsavedChanges();
   logger.debug("updateRollingSnapshots", {
-    name: subvolume.name,
+    name: snapshot.subvolume.name,
     counts,
     changed,
   });
@@ -50,9 +50,9 @@ export async function updateRollingSnapshots({
   }
 
   // get exactly the iso timestamp snapshot names:
-  const snapshots = (await subvolume.snapshots()).filter((x) =>
-    DATE_REGEXP.test(x),
-  );
+  const snapshots = (await snapshot.ls())
+    .map((x) => x.name)
+    .filter((name) => DATE_REGEXP.test(name));
   snapshots.sort();
   if (snapshots.length > 0) {
     const age = Date.now() - new Date(snapshots.slice(-1)[0]).valueOf();
@@ -61,7 +61,7 @@ export async function updateRollingSnapshots({
         if (age < SNAPSHOT_INTERVALS_MS[key]) {
           // no need to snapshot since there is already a sufficiently recent snapshot
           logger.debug("updateRollingSnapshots: no need to snapshot", {
-            name: subvolume.name,
+            name: snapshot.subvolume.name,
           });
           return;
         }
@@ -72,14 +72,14 @@ export async function updateRollingSnapshots({
   }
 
   // make a new snapshot
-  const snapshot = new Date().toISOString();
-  await subvolume.createSnapshot(snapshot);
+  const name = new Date().toISOString();
+  await snapshot.create(name);
   // delete extra snapshots
-  snapshots.push(snapshot);
+  snapshots.push(name);
   const toDelete = snapshotsToDelete({ counts, snapshots });
-  for (const snapshot of toDelete) {
+  for (const expired of toDelete) {
     try {
-      await subvolume.deleteSnapshot(snapshot);
+      await snapshot.delete(expired);
     } catch {
       // some snapshots can't be deleted, e.g., they were used for the last send.
     }

src/packages/file-server/btrfs/subvolume-bup.ts

@@ -23,17 +23,17 @@ export class SubvolumeBup {
     // timeout used for bup index and bup save commands
     timeout = 30 * 60 * 1000,
   }: { timeout?: number } = {}) => {
-    if (await this.subvolume.snapshotExists(BUP_SNAPSHOT)) {
+    if (await this.subvolume.snapshot.exists(BUP_SNAPSHOT)) {
       logger.debug(`createBupBackup: deleting existing ${BUP_SNAPSHOT}`);
-      await this.subvolume.deleteSnapshot(BUP_SNAPSHOT);
+      await this.subvolume.snapshot.delete(BUP_SNAPSHOT);
     }
     try {
       logger.debug(
         `createBackup: creating ${BUP_SNAPSHOT} to get a consistent backup`,
       );
-      await this.subvolume.createSnapshot(BUP_SNAPSHOT);
+      await this.subvolume.snapshot.create(BUP_SNAPSHOT);
       const target = this.subvolume.normalize(
-        this.subvolume.snapshotPath(BUP_SNAPSHOT),
+        this.subvolume.snapshot.path(BUP_SNAPSHOT),
       );
 
       logger.debug(`createBupBackup: indexing ${BUP_SNAPSHOT}`);
@@ -67,7 +67,7 @@ export class SubvolumeBup {
       });
     } finally {
       logger.debug(`createBupBackup: deleting temporary ${BUP_SNAPSHOT}`);
-      await this.subvolume.deleteSnapshot(BUP_SNAPSHOT);
+      await this.subvolume.snapshot.delete(BUP_SNAPSHOT);
     }
   };
 
@@ -78,7 +78,7 @@ export class SubvolumeBup {
     }
     path = normalize(path);
     // ... but to avoid potential data loss, we make a snapshot before deleting it.
-    await this.subvolume.createSnapshot();
+    await this.subvolume.snapshot.create();
     const i = path.indexOf("/"); // remove the commit name
     // remove the target we're about to restore
     await this.subvolume.fs.rm(path.slice(i + 1), { recursive: true });

src/packages/file-server/btrfs/subvolume-snapshot.ts

@@ -0,0 +1,111 @@
+import { type Subvolume } from "./subvolume";
+import { btrfs } from "./util";
+import getLogger from "@cocalc/backend/logger";
+import { join } from "path";
+import { type DirectoryListingEntry } from "@cocalc/util/types";
+import { SnapshotCounts, updateRollingSnapshots } from "./snapshots";
+
+export const SNAPSHOTS = ".snapshots";
+const logger = getLogger("file-server:storage-btrfs:subvolume-snapshot");
+
+export class SubvolumeSnapshot {
+  public readonly snapshotsDir: string;
+
+  constructor(public subvolume: Subvolume) {
+    this.snapshotsDir = join(this.subvolume.path, SNAPSHOTS);
+  }
+
+  path = (snapshot?: string, ...segments) => {
+    if (!snapshot) {
+      return SNAPSHOTS;
+    }
+    return join(SNAPSHOTS, snapshot, ...segments);
+  };
+
+  private makeSnapshotsDir = async () => {
+    if (await this.subvolume.fs.exists(SNAPSHOTS)) {
+      return;
+    }
+    await this.subvolume.fs.mkdir(SNAPSHOTS);
+    await this.subvolume.fs.chmod(SNAPSHOTS, "0555");
+  };
+
+  create = async (name?: string) => {
+    if (name?.startsWith(".")) {
+      throw Error("snapshot name must not start with '.'");
+    }
+    name ??= new Date().toISOString();
+    logger.debug("create", { name, subvolume: this.subvolume.name });
+    await this.makeSnapshotsDir();
+    await btrfs({
+      args: [
+        "subvolume",
+        "snapshot",
+        "-r",
+        this.subvolume.path,
+        join(this.snapshotsDir, name),
+      ],
+    });
+  };
+
+  ls = async (): Promise<DirectoryListingEntry[]> => {
+    await this.makeSnapshotsDir();
+    return await this.subvolume.fs.ls(SNAPSHOTS, { hidden: false });
+  };
+
+  lock = async (name: string) => {
+    if (await this.subvolume.fs.exists(this.path(name))) {
+      this.subvolume.fs.writeFile(this.path(`.${name}.lock`), "");
+    } else {
+      throw Error(`snapshot ${name} does not exist`);
+    }
+  };
+
+  unlock = async (name: string) => {
+    await this.subvolume.fs.rm(this.path(`.${name}.lock`));
+  };
+
+  exists = async (name: string) => {
+    return await this.subvolume.fs.exists(this.path(name));
+  };
+
+  delete = async (name) => {
+    if (await this.subvolume.fs.exists(this.path(`.${name}.lock`))) {
+      throw Error(`snapshot ${name} is locked`);
+    }
+    await btrfs({
+      args: ["subvolume", "delete", join(this.snapshotsDir, name)],
+    });
+  };
+
+  // update the rolling snapshots schedule
+  update = async (counts?: Partial<SnapshotCounts>) => {
+    return await updateRollingSnapshots({ snapshot: this, counts });
+  };
+
+  // has newly written changes since last snapshot
+  hasUnsavedChanges = async (): Promise<boolean> => {
+    const s = await this.ls();
+    if (s.length == 0) {
+      // more than just the SNAPSHOTS directory?
+      const v = await this.subvolume.fs.ls("", { hidden: true });
+      if (v.length == 0 || (v.length == 1 && v[0].name == SNAPSHOTS)) {
+        return false;
+      }
+      return true;
+    }
+    const pathGen = await getGeneration(this.subvolume.path);
+    const snapGen = await getGeneration(
+      join(this.snapshotsDir, s[s.length - 1].name),
+    );
+    return snapGen < pathGen;
+  };
+}
+
+async function getGeneration(path: string): Promise<number> {
+  const { stdout } = await btrfs({
+    args: ["subvolume", "show", path],
+    verbose: false,
+  });
+  return parseInt(stdout.split("Generation:")[1].split("\n")[0].trim());
+}