迁移备份

COPY --from=docker.io/cloudflare/sandbox:1.0.1 /usr/local/bin/sandbox-shim /usr/local/bin/sandbox-shim

import {
    DirectoryBackup,
    type DirectoryBackupRecord,
} from "@cloudflare/sandbox";

// Gives the Durable Object this.ctx.exports.DirectoryBackupGateway,
// which moves each backup between the container and the bucket
export { DirectoryBackupGateway } from "@cloudflare/sandbox";

// 0.12 kept a backup for three days unless you set ttl.
const DEFAULT_TTL_SECONDS = 3 * 24 * 60 * 60;

// The record your code stores in place of the 0.12 backup object.
type Backup = DirectoryBackupRecord & { expiresAt: number };

// Restores read the expiry time from this object, because a caller
// can change the expiresAt field of a record.
const metaKey = (id: string) => `backups/${id}.meta.json`;

// Like 0.12, refuse a backup that expires within a minute.
const EXPIRY_MARGIN_MS = 60 * 1000;

export class MySandbox extends DurableObject<Env> {
    // ...

    private readonly backups = new DirectoryBackup(
        this.container,
        this.ctx.exports.DirectoryBackupGateway,
        { binding: "BACKUP_BUCKET", prefix: "backups/" },
    );
}

const sandbox = getSandbox(env.Sandbox, "ada");
const backup = await sandbox.createBackup({
    dir: "/workspace/project",
    excludes: ["node_modules"],
    ttl: 24 * 60 * 60,
});

export class MySandbox extends DurableObject<Env> {
    // ...

    async createBackup(options: {
        dir: string;
        name?: string;
        excludes?: string[];
        gitignore?: boolean;
        ttl?: number;
    }): Promise<Backup> {
        await this.ensureRunning();
        const { excludes, ttl = DEFAULT_TTL_SECONDS, ...rest } = options;
        const backup = await this.backups.backup({
            ...rest,
            // 0.12 matched each pattern at any depth in the directory.
            exclude: excludes?.map((pattern) => `**/${pattern}`),
        });
        const expiresAt = Date.now() + ttl * 1000;
        await this.env.BACKUP_BUCKET.put(
            metaKey(backup.id),
            JSON.stringify({ expiresAt }),
        );

        return { ...backup, expiresAt };
    }
}

export class MySandbox extends DurableObject<Env> {
    // ...

    async restoreBackup(backup: DirectoryBackupRecord) {
        const meta = await this.env.BACKUP_BUCKET.get(metaKey(backup.id));

        if (!meta) {
            throw new Error(`Backup ${backup.id} was not found`);
        }

        const { expiresAt } = await meta.json<{ expiresAt: number }>();

        if (Date.now() + EXPIRY_MARGIN_MS > expiresAt) {
            throw new Error(`Backup ${backup.id} has expired`);
        }

        await this.ensureRunning();
        await this.backups.restore(backup);
        return { success: true, dir: backup.dir, id: backup.id };
    }
}

RUN apt-get update && apt-get install -y --no-install-recommends squashfs-tools && rm -rf /var/lib/apt/lists/*

// 0.12 restored only backups with a UUID, into one of these directories.
const BACKUP_ID =
    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
const BACKUP_ROOTS = ["/workspace", "/home", "/tmp", "/var/tmp", "/app"];

function checkOldBackup(old: { id: string; dir: string }) {
    const segments = old.dir.split("/").slice(1);
    const inRoot = BACKUP_ROOTS.some(
        (root) => old.dir === root || old.dir.startsWith(`${root}/`),
    );

    if (
        !BACKUP_ID.test(old.id) ||
        !inRoot ||
        segments.some((part) => part === "" || part === "." || part === "..") ||
        old.dir.includes("\0")
    ) {
        throw new TypeError(`Invalid 0.12 backup ${old.id} for ${old.dir}`);
    }
}

export class MySandbox extends DurableObject<Env> {
    // ...

    async convert(old: { id: string; dir: string }): Promise<Backup> {
        checkOldBackup(old);

        const meta = await this.env.BACKUP_BUCKET.get(`backups/${old.id}/meta.json`);
        const image = await this.env.BACKUP_BUCKET.get(`backups/${old.id}/data.sqsh`);

        if (!meta || !image) {
            throw new Error(`Backup ${old.id} was not found`);
        }

        const { createdAt, ttl } = await meta.json<{ createdAt: string; ttl: number }>();
        const expiresAt = Date.parse(createdAt) + ttl * 1000;

        if (Date.now() + EXPIRY_MARGIN_MS > expiresAt) {
            await image.body.cancel();
            throw new Error(`Backup ${old.id} has expired`);
        }

        await this.ensureRunning();

        // Refuses a path through a symbolic link. unsquashfs needs the whole
        // image on disk, so it goes to /var/tmp first. The files replace the
        // directory only after they are all extracted.
        const script =
            '[ "$(realpath -m -- "$2")" = "$2" ] || exit 2;' +
            ' mkdir -p -- "$(dirname -- "$2")" && rm -rf -- "$2.convert" &&' +
            ' cat > "$1" && unsquashfs -no-progress -d "$2.convert" "$1" > /dev/null &&' +
            ' rm -rf -- "$2" && mv -- "$2.convert" "$2";' +
            ' code=$?; rm -rf -- "$1" "$2.convert"; exit $code';
        const process = await this.container.exec(
            ["sh", "-c", script, "sh", `/var/tmp/${old.id}.sqsh`, old.dir],
            { stdin: image.body },
        );
        const output = await process.output();

        if (output.exitCode !== 0) {
            throw new Error(new TextDecoder().decode(output.stderr));
        }

        const backup = await this.backups.backup({ dir: old.dir });
        await this.env.BACKUP_BUCKET.put(
            metaKey(backup.id),
            JSON.stringify({ expiresAt }),
        );
        return { ...backup, expiresAt };
    }
}

await this.env.BACKUP_BUCKET.delete([
    `backups/${old.id}/data.sqsh`,
    `backups/${old.id}/meta.json`,
]);