btrfs: snapshot --> snapshots

Author: williamstein

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

@@ -14,7 +14,7 @@ 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, type Subvolume } from "./subvolume";
-import { SNAPSHOTS } from "./subvolume-snapshot";
+import { SNAPSHOTS } from "./subvolume-snapshots";
 import { join, normalize } from "path";
 
 // default size of btrfs filesystem if creating an image file.

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

@@ -1,4 +1,4 @@
-import { type SubvolumeSnapshot } from "./subvolume-snapshot";
+import { type SubvolumeSnapshots } from "./subvolume-snapshots";
 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({
-  snapshot,
+  snapshots,
   counts,
 }: {
-  snapshot: SubvolumeSnapshot;
+  snapshots: SubvolumeSnapshots;
   counts?: Partial<SnapshotCounts>;
 }) {
   counts = { ...DEFAULT_SNAPSHOT_COUNTS, ...counts };
 
-  const changed = await snapshot.hasUnsavedChanges();
+  const changed = await snapshots.hasUnsavedChanges();
   logger.debug("updateRollingSnapshots", {
-    name: snapshot.subvolume.name,
+    name: snapshots.subvolume.name,
     counts,
     changed,
   });
@@ -50,18 +50,18 @@ export async function updateRollingSnapshots({
   }
 
   // get exactly the iso timestamp snapshot names:
-  const snapshots = (await snapshot.ls())
+  const snapshotNames = (await snapshots.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();
+  snapshotNames.sort();
+  if (snapshotNames.length > 0) {
+    const age = Date.now() - new Date(snapshotNames.slice(-1)[0]).valueOf();
     for (const key in SNAPSHOT_INTERVALS_MS) {
       if (counts[key]) {
         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: snapshot.subvolume.name,
+            name: snapshots.subvolume.name,
           });
           return;
         }
@@ -73,13 +73,13 @@ export async function updateRollingSnapshots({
 
   // make a new snapshot
   const name = new Date().toISOString();
-  await snapshot.create(name);
+  await snapshots.create(name);
   // delete extra snapshots
-  snapshots.push(name);
-  const toDelete = snapshotsToDelete({ counts, snapshots });
+  snapshotNames.push(name);
+  const toDelete = snapshotsToDelete({ counts, snapshots: snapshotNames });
   for (const expired of toDelete) {
     try {
-      await snapshot.delete(expired);
+      await snapshots.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.snapshot.exists(BUP_SNAPSHOT)) {
+    if (await this.subvolume.snapshots.exists(BUP_SNAPSHOT)) {
       logger.debug(`createBupBackup: deleting existing ${BUP_SNAPSHOT}`);
-      await this.subvolume.snapshot.delete(BUP_SNAPSHOT);
+      await this.subvolume.snapshots.delete(BUP_SNAPSHOT);
     }
     try {
       logger.debug(
         `createBackup: creating ${BUP_SNAPSHOT} to get a consistent backup`,
       );
-      await this.subvolume.snapshot.create(BUP_SNAPSHOT);
+      await this.subvolume.snapshots.create(BUP_SNAPSHOT);
       const target = this.subvolume.normalize(
-        this.subvolume.snapshot.path(BUP_SNAPSHOT),
+        this.subvolume.snapshots.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.snapshot.delete(BUP_SNAPSHOT);
+      await this.subvolume.snapshots.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.snapshot.create();
+    await this.subvolume.snapshots.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 renamed to src/packages/file-server/btrfs/subvolume-snapshots.ts

@@ -6,9 +6,9 @@ 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");
+const logger = getLogger("file-server:storage-btrfs:subvolume-snapshots");
 
-export class SubvolumeSnapshot {
+export class SubvolumeSnapshots {
   public readonly snapshotsDir: string;
 
   constructor(public subvolume: Subvolume) {
@@ -80,7 +80,7 @@ export class SubvolumeSnapshot {
 
   // update the rolling snapshots schedule
   update = async (counts?: Partial<SnapshotCounts>) => {
-    return await updateRollingSnapshots({ snapshot: this, counts });
+    return await updateRollingSnapshots({ snapshots: this, counts });
   };
 
   // has newly written changes since last snapshot

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

@@ -8,7 +8,7 @@ import { exists, listdir, mkdirp, sudo } from "./util";
 import { join, normalize } from "path";
 import { SubvolumeFilesystem } from "./subvolume-fs";
 import { SubvolumeBup } from "./subvolume-bup";
-import { SubvolumeSnapshot } from "./subvolume-snapshot";
+import { SubvolumeSnapshots } from "./subvolume-snapshots";
 import getLogger from "@cocalc/backend/logger";
 
 const SEND_SNAPSHOT_PREFIX = "send-";
@@ -28,15 +28,15 @@ export class Subvolume {
   public readonly path: string;
   public readonly fs: SubvolumeFilesystem;
   public readonly bup: SubvolumeBup;
-  public readonly snapshot: SubvolumeSnapshot;
+  public readonly snapshots: SubvolumeSnapshots;
 
   constructor({ filesystem, name }: Options) {
     this.filesystem = filesystem;
     this.name = name;
     this.path = join(filesystem.opts.mount, name);
     this.fs = new SubvolumeFilesystem(this);
     this.bup = new SubvolumeBup(this);
-    this.snapshot = new SubvolumeSnapshot(this);
+    this.snapshots = new SubvolumeSnapshots(this);
   }
 
   init = async () => {
@@ -187,7 +187,7 @@ export class Subvolume {
     const streams = new Set(
       await listdir(join(this.filesystem.streams, this.name)),
     );
-    const allSnapshots = (await this.snapshot.ls()).map((x) => x.name);
+    const allSnapshots = (await this.snapshots.ls()).map((x) => x.name);
     const snapshots = allSnapshots.filter(
       (x) => x.startsWith(SEND_SNAPSHOT_PREFIX) && streams.has(x),
     );
@@ -207,22 +207,22 @@ export class Subvolume {
     }
     const send = `${SEND_SNAPSHOT_PREFIX}${seq}`;
     if (allSnapshots.includes(send)) {
-      await this.snapshot.delete(send);
+      await this.snapshots.delete(send);
     }
-    await this.snapshot.create(send);
+    await this.snapshots.create(send);
     await sudo({
       command: "btrfs",
       args: [
         "send",
         "--compressed-data",
-        join(this.snapshot.path(), send),
-        ...(last ? ["-p", this.snapshot.path(parent)] : []),
+        join(this.snapshots.path(), send),
+        ...(last ? ["-p", this.snapshots.path(parent)] : []),
         "-f",
         join(this.filesystem.streams, this.name, send),
       ],
     });
     if (parent) {
-      await this.snapshot.delete(parent);
+      await this.snapshots.delete(parent);
     }
   };
 

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

@@ -30,7 +30,7 @@ describe("operations with subvolumes", () => {
     const vol = await fs.subvolume("cocalc");
     expect(vol.name).toBe("cocalc");
     // it has no snapshots
-    expect(await vol.snapshot.ls()).toEqual([]);
+    expect(await vol.snapshots.ls()).toEqual([]);
   });
 
   it("our subvolume is in the list", async () => {

src/packages/file-server/btrfs/test/subvolume-stress.test.ts

@@ -22,23 +22,23 @@ describe(`stress test creating ${numSnapshots} snapshots`, () => {
     const start = Date.now();
     for (let i = 0; i < numSnapshots; i++) {
       await writeFile(join(vol.path, `${i}.txt`), "world");
-      await vol.snapshot.create(`snap${i}`);
+      await vol.snapshots.create(`snap${i}`);
       snaps.push(`snap${i}`);
     }
     log(
       `created ${Math.round((numSnapshots / (Date.now() - start)) * 1000)} snapshots per second in serial`,
     );
     snaps.sort();
-    expect((await vol.snapshot.ls()).map(({ name }) => name).sort()).toEqual(
+    expect((await vol.snapshots.ls()).map(({ name }) => name).sort()).toEqual(
       snaps.sort(),
     );
   });
 
   it(`delete our ${numSnapshots} snapshots`, async () => {
     for (let i = 0; i < numSnapshots; i++) {
-      await vol.snapshot.delete(`snap${i}`);
+      await vol.snapshots.delete(`snap${i}`);
     }
-    expect(await vol.snapshot.ls()).toEqual([]);
+    expect(await vol.snapshots.ls()).toEqual([]);
   });
 });
 

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

@@ -86,8 +86,8 @@ describe("the filesystem operations", () => {
 
   let origStat;
   it("snapshot filesystem and see file is in snapshot", async () => {
-    await vol.snapshot.create("snap");
-    const s = await vol.fs.ls(vol.snapshot.path("snap"));
+    await vol.snapshots.create("snap");
+    const s = await vol.fs.ls(vol.snapshots.path("snap"));
     expect(s).toEqual([{ name: "a.txt", mtime: s[0].mtime, size: 5 }]);
 
     const stat = await vol.fs.stat("a.txt");
@@ -101,11 +101,11 @@ describe("the filesystem operations", () => {
   });
 
   it("snapshot still exists", async () => {
-    expect(await vol.fs.exists(vol.snapshot.path("snap", "a.txt")));
+    expect(await vol.fs.exists(vol.snapshots.path("snap", "a.txt")));
   });
 
   it("copy file from snapshot and note it has the same mode as before (so much nicer than what happens with zfs)", async () => {
-    await vol.fs.copyFile(vol.snapshot.path("snap", "a.txt"), "a.txt");
+    await vol.fs.copyFile(vol.snapshots.path("snap", "a.txt"), "a.txt");
     const stat = await vol.fs.stat("a.txt");
     expect(stat.mode).toEqual(origStat.mode);
   });
@@ -179,50 +179,50 @@ describe("test snapshots", () => {
 
   it("creates a volume and write a file to it", async () => {
     vol = await fs.subvolume("snapper");
-    expect(await vol.snapshot.hasUnsavedChanges()).toBe(false);
+    expect(await vol.snapshots.hasUnsavedChanges()).toBe(false);
     await vol.fs.writeFile("a.txt", "hello");
-    expect(await vol.snapshot.hasUnsavedChanges()).toBe(true);
+    expect(await vol.snapshots.hasUnsavedChanges()).toBe(true);
   });
 
   it("snapshot the volume", async () => {
-    expect(await vol.snapshot.ls()).toEqual([]);
-    await vol.snapshot.create("snap1");
-    expect((await vol.snapshot.ls()).map((x) => x.name)).toEqual(["snap1"]);
-    expect(await vol.snapshot.hasUnsavedChanges()).toBe(false);
+    expect(await vol.snapshots.ls()).toEqual([]);
+    await vol.snapshots.create("snap1");
+    expect((await vol.snapshots.ls()).map((x) => x.name)).toEqual(["snap1"]);
+    expect(await vol.snapshots.hasUnsavedChanges()).toBe(false);
   });
 
   it("create a file see that we know there are unsaved changes", async () => {
     await vol.fs.writeFile("b.txt", "world");
     await sudo({ command: "sync" });
-    expect(await vol.snapshot.hasUnsavedChanges()).toBe(true);
+    expect(await vol.snapshots.hasUnsavedChanges()).toBe(true);
   });
 
   it("delete our file, but then read it in a snapshot", async () => {
     await vol.fs.unlink("a.txt");
     const b = await vol.fs.readFile(
-      vol.snapshot.path("snap1", "a.txt"),
+      vol.snapshots.path("snap1", "a.txt"),
       "utf8",
     );
     expect(b).toEqual("hello");
   });
 
   it("verifies snapshot exists", async () => {
-    expect(await vol.snapshot.exists("snap1")).toBe(true);
-    expect(await vol.snapshot.exists("snap2")).toBe(false);
+    expect(await vol.snapshots.exists("snap1")).toBe(true);
+    expect(await vol.snapshots.exists("snap2")).toBe(false);
   });
 
   it("lock our snapshot and confirm it prevents deletion", async () => {
-    await vol.snapshot.lock("snap1");
+    await vol.snapshots.lock("snap1");
     expect(async () => {
-      await vol.snapshot.delete("snap1");
+      await vol.snapshots.delete("snap1");
     }).rejects.toThrow("locked");
   });
 
   it("unlock our snapshot and delete it", async () => {
-    await vol.snapshot.unlock("snap1");
-    await vol.snapshot.delete("snap1");
-    expect(await vol.snapshot.exists("snap1")).toBe(false);
-    expect(await vol.snapshot.ls()).toEqual([]);
+    await vol.snapshots.unlock("snap1");
+    await vol.snapshots.delete("snap1");
+    expect(await vol.snapshots.exists("snap1")).toBe(false);
+    expect(await vol.snapshots.ls()).toEqual([]);
   });
 });
 
@@ -286,9 +286,9 @@ describe.only("test bup backups", () => {
   });
 
   it("most recent snapshot has a backup before the restore", async () => {
-    const s = await vol.snapshot.ls();
+    const s = await vol.snapshots.ls();
     const recent = s.slice(-1)[0].name;
-    const p = vol.snapshot.path(recent, "mydir", "file.txt");
+    const p = vol.snapshots.path(recent, "mydir", "file.txt");
     expect(await vol.fs.readFile(p, "utf8")).toEqual("changed");
   });
 });