@datatruck/cli 0.27.0 → 0.29.0

package/Factory/CommandFactory.d.ts

@@ -1,52 +1,45 @@
-import { CleanCacheActionOptionsType } from "../Action/CleanCacheAction";
-import { BackupCommandOptionsType } from "../Command/BackupCommand";
-import { BackupSessionsCommandOptionsType } from "../Command/BackupSessionsCommand";
-import { CleanCacheCommand } from "../Command/CleanCacheCommand";
-import { GlobalOptionsType } from "../Command/CommandAbstract";
-import { ConfigCommandLogType, ConfigCommandOptionsType } from "../Command/ConfigCommand";
-import { InitCommandLogType, InitCommandOptionsType } from "../Command/InitCommand";
-import { PruneCommandOptionsType } from "../Command/PruneCommand";
+import { CleanCacheActionOptions } from "../Action/CleanCacheAction";
+import { BackupCommandOptions, BackupCommandResult } from "../Command/BackupCommand";
+import { GlobalOptions } from "../Command/CommandAbstract";
+import { ConfigCommandResult, ConfigCommandOptions } from "../Command/ConfigCommand";
+import { CopyCommandOptionsType } from "../Command/CopyCommand";
+import { InitCommandResult, InitCommandOptions } from "../Command/InitCommand";
+import { PruneCommandOptions } from "../Command/PruneCommand";
 import { RestoreCommandOptionsType } from "../Command/RestoreCommand";
-import { RestoreSessionsCommandOptionsType } from "../Command/RestoreSessionsCommand";
-import { SnapshotsCommandLogType, SnapshotsCommandOptionsType } from "../Command/SnapshotsCommand";
-import { StartServerCommandOptionsType } from "../Command/StartServerCommand";
+import { SnapshotsCommandResult, SnapshotsCommandOptions } from "../Command/SnapshotsCommand";
+import { StartServerCommand, StartServerCommandOptions } from "../Command/StartServerCommand";
+import { Streams } from "../utils/stream";
 export declare enum CommandEnum {
     config = "config",
     init = "init",
     snapshots = "snapshots",
     prune = "prune",
     backup = "backup",
-    backupSessions = "backup-sessions",
     restore = "restore",
-    restoreSessions = "restore-sessions",
+    copy = "copy",
     cleanCache = "clean-cache",
     startServer = "start-server"
 }
 export type OptionsMapType = {
-    [CommandEnum.config]: ConfigCommandOptionsType;
-    [CommandEnum.init]: InitCommandOptionsType;
-    [CommandEnum.snapshots]: SnapshotsCommandOptionsType;
-    [CommandEnum.prune]: PruneCommandOptionsType;
-    [CommandEnum.backup]: BackupCommandOptionsType;
-    [CommandEnum.backupSessions]: BackupSessionsCommandOptionsType;
+    [CommandEnum.config]: ConfigCommandOptions;
+    [CommandEnum.init]: InitCommandOptions;
+    [CommandEnum.snapshots]: SnapshotsCommandOptions;
+    [CommandEnum.prune]: PruneCommandOptions;
+    [CommandEnum.backup]: BackupCommandOptions;
     [CommandEnum.restore]: RestoreCommandOptionsType;
-    [CommandEnum.restoreSessions]: RestoreSessionsCommandOptionsType;
-    [CommandEnum.cleanCache]: CleanCacheActionOptionsType;
-    [CommandEnum.startServer]: StartServerCommandOptionsType;
+    [CommandEnum.copy]: CopyCommandOptionsType;
+    [CommandEnum.cleanCache]: CleanCacheActionOptions;
+    [CommandEnum.startServer]: StartServerCommandOptions;
 };
 export type LogMapType = {
-    [CommandEnum.config]: ConfigCommandLogType;
-    [CommandEnum.init]: InitCommandLogType;
-    [CommandEnum.snapshots]: SnapshotsCommandLogType;
+    [CommandEnum.config]: ConfigCommandResult;
+    [CommandEnum.init]: InitCommandResult;
+    [CommandEnum.snapshots]: SnapshotsCommandResult;
+    [CommandEnum.backup]: BackupCommandResult;
 };
-export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): CleanCacheCommand;
-export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): Promise<number>;
-export declare function createActionInterface(globalOptions: GlobalOptionsType<false>): {
+export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): StartServerCommand;
+export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): Promise<number>;
+export declare function createActionInterface(globalOptions: GlobalOptions<true>): {
     [K in keyof OptionsMapType as `${K}`]: (options: OptionsMapType[K]) => Promise<K extends keyof LogMapType ? LogMapType[K] : never>;
 };
-export declare function runAndParse<TCommand extends keyof LogMapType>(type: TCommand, run: () => Promise<any>): Promise<{
-    exitCode: any;
-    log: LogMapType[TCommand];
-}>;
-export declare function makeParseLog<TCommand extends keyof LogMapType>(type: TCommand): () => LogMapType[TCommand];
-export declare function CommandConstructorFactory(type: CommandEnum): typeof CleanCacheCommand;
+export declare function CommandConstructorFactory(type: CommandEnum): typeof StartServerCommand;

package/Factory/CommandFactory.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandConstructorFactory = exports.makeParseLog = exports.runAndParse = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
+exports.CommandConstructorFactory = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
 const BackupCommand_1 = require("../Command/BackupCommand");
-const BackupSessionsCommand_1 = require("../Command/BackupSessionsCommand");
 const CleanCacheCommand_1 = require("../Command/CleanCacheCommand");
 const ConfigCommand_1 = require("../Command/ConfigCommand");
+const CopyCommand_1 = require("../Command/CopyCommand");
 const InitCommand_1 = require("../Command/InitCommand");
 const PruneCommand_1 = require("../Command/PruneCommand");
 const RestoreCommand_1 = require("../Command/RestoreCommand");
-const RestoreSessionsCommand_1 = require("../Command/RestoreSessionsCommand");
 const SnapshotsCommand_1 = require("../Command/SnapshotsCommand");
 const StartServerCommand_1 = require("../Command/StartServerCommand");
 const AppError_1 = require("../Error/AppError");
+const stream_1 = require("stream");
 var CommandEnum;
 (function (CommandEnum) {
     CommandEnum["config"] = "config";
@@ -19,72 +19,48 @@ var CommandEnum;
     CommandEnum["snapshots"] = "snapshots";
     CommandEnum["prune"] = "prune";
     CommandEnum["backup"] = "backup";
-    CommandEnum["backupSessions"] = "backup-sessions";
     CommandEnum["restore"] = "restore";
-    CommandEnum["restoreSessions"] = "restore-sessions";
+    CommandEnum["copy"] = "copy";
     CommandEnum["cleanCache"] = "clean-cache";
     CommandEnum["startServer"] = "start-server";
 })(CommandEnum || (exports.CommandEnum = CommandEnum = {}));
-function CommandFactory(type, globalOptions, options) {
+function CommandFactory(type, globalOptions, options, streams) {
     const constructor = CommandConstructorFactory(type);
-    return new constructor(globalOptions, options);
+    return new constructor(globalOptions, options, streams);
 }
 exports.CommandFactory = CommandFactory;
-async function exec(type, globalOptions, options) {
-    return await CommandFactory(type, globalOptions, options).onExec();
+async function exec(type, globalOptions, options, streams) {
+    return await CommandFactory(type, globalOptions, options, streams).onExec();
 }
 exports.exec = exec;
 function createActionInterface(globalOptions) {
     const object = {};
     for (const type of Object.values(CommandEnum)) {
         object[type] = async (options) => {
-            const run = () => exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options);
-            let exitCode;
-            let log;
-            if (["config", "init", "snapshots"].includes(type)) {
-                const parsed = await runAndParse(type, run);
-                exitCode = parsed.exitCode;
-                log = parsed.log;
+            let stdoutData = "";
+            const stdout = new stream_1.Writable({
+                write(chunk, encoding, callback) {
+                    stdoutData += chunk.toString();
+                    process.stdout.write(chunk, encoding, callback);
+                },
+            }).on("data", (chunk) => (stdoutData += chunk.toString()));
+            const end = () => !stdout.closed &&
+                new Promise((resolve) => stdout.end().on("close", resolve));
+            try {
+                const exitCode = await exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options, { stdout });
+                if (exitCode !== 0)
+                    throw new Error(`Invalid exit code: ${exitCode}`);
+                await end();
+                return JSON.parse(stdoutData);
             }
-            else {
-                exitCode = await run();
+            finally {
+                await end();
             }
-            if (exitCode !== 0)
-                throw new Error(`Invalid exit code: ${exitCode}`);
-            return log;
         };
     }
     return object;
 }
 exports.createActionInterface = createActionInterface;
-async function runAndParse(type, run) {
-    const parseLog = makeParseLog(type);
-    try {
-        const exitCode = await run();
-        return { exitCode, log: parseLog() };
-    }
-    catch (error) {
-        try {
-            parseLog();
-        }
-        catch (_) { }
-        throw error;
-    }
-}
-exports.runAndParse = runAndParse;
-function makeParseLog(type) {
-    const data = [];
-    const consoleLog = console.log;
-    console.log = console.info = (...items) => {
-        consoleLog.bind(console)(...items);
-        data.push(...items);
-    };
-    return function parseLog() {
-        console.log = console.info = consoleLog;
-        return JSON.parse(data.flat().join("\n"));
-    };
-}
-exports.makeParseLog = makeParseLog;
 function CommandConstructorFactory(type) {
     if (type === CommandEnum.config) {
         return ConfigCommand_1.ConfigCommand;
@@ -101,14 +77,11 @@ function CommandConstructorFactory(type) {
     else if (type === CommandEnum.backup) {
         return BackupCommand_1.BackupCommand;
     }
-    else if (type === CommandEnum.backupSessions) {
-        return BackupSessionsCommand_1.BackupSessionsCommand;
-    }
     else if (type === CommandEnum.restore) {
         return RestoreCommand_1.RestoreCommand;
     }
-    else if (type === CommandEnum.restoreSessions) {
-        return RestoreSessionsCommand_1.RestoreSessionsCommand;
+    else if (type === CommandEnum.copy) {
+        return CopyCommand_1.CopyCommand;
     }
     else if (type === CommandEnum.cleanCache) {
         return CleanCacheCommand_1.CleanCacheCommand;

package/Factory/RepositoryFactory.d.ts

@@ -1,3 +1,3 @@
 import type { RepositoryConfigType } from "../Config/RepositoryConfig";
 import type { RepositoryAbstract } from "../Repository/RepositoryAbstract";
-export declare function RepositoryFactory(repository: RepositoryConfigType): RepositoryAbstract<any>;
+export declare function createRepo(repository: RepositoryConfigType): RepositoryAbstract<any>;

package/Factory/RepositoryFactory.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RepositoryFactory = void 0;
+exports.createRepo = void 0;
 const AppError_1 = require("../Error/AppError");
 const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
 const GitRepository_1 = require("../Repository/GitRepository");
 const ResticRepository_1 = require("../Repository/ResticRepository");
-function RepositoryFactory(repository) {
+function createRepo(repository) {
     const type = repository.type;
     if (type === GitRepository_1.gitRepositoryName) {
         return new GitRepository_1.GitRepository(repository);
@@ -20,4 +20,4 @@ function RepositoryFactory(repository) {
         throw new AppError_1.AppError(`Invalid repository type: ${type}`);
     }
 }
-exports.RepositoryFactory = RepositoryFactory;
+exports.createRepo = createRepo;

package/Factory/TaskFactory.d.ts

@@ -1,3 +1,3 @@
 import { TaskConfigType } from "../Config/TaskConfig";
 import type { TaskAbstract } from "../Task/TaskAbstract";
-export declare function TaskFactory(task: TaskConfigType): TaskAbstract;
+export declare function createTask(task: TaskConfigType): TaskAbstract;

package/Factory/TaskFactory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskFactory = void 0;
+exports.createTask = void 0;
 const AppError_1 = require("../Error/AppError");
 const GitTask_1 = require("../Task/GitTask");
 const MariadbTask_1 = require("../Task/MariadbTask");
@@ -8,7 +8,7 @@ const MssqlTask_1 = require("../Task/MssqlTask");
 const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
 const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
 const ScriptTask_1 = require("../Task/ScriptTask");
-function TaskFactory(task) {
+function createTask(task) {
     if (task.name === GitTask_1.gitTaskName) {
         return new GitTask_1.GitTask(task.config ?? {});
     }
@@ -31,4 +31,4 @@ function TaskFactory(task) {
         throw new AppError_1.AppError(`Invalid task name: ${task["name"]}`);
     }
 }
-exports.TaskFactory = TaskFactory;
+exports.createTask = createTask;

package/Repository/DatatruckRepository.d.ts

@@ -1,5 +1,5 @@
 import { CompressOptions } from "../utils/tar";
-import { RepositoryAbstract, BackupDataType, InitDataType, RestoreDataType, SnapshotsDataType, SnapshotResultType, PruneDataType, CopyBackupType } from "./RepositoryAbstract";
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
 import type { JSONSchema7 } from "json-schema";
 export type MetaDataType = {
     id: string;
@@ -12,6 +12,7 @@ export type MetaDataType = {
     tarStats?: Record<string, {
         files: number;
         size: number;
+        checksum: string;
     }>;
 };
 export type DatatruckRepositoryConfigType = {
@@ -47,12 +48,13 @@ export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRep
         sourcePath: string;
     } | null;
     static parseMetaData(data: string): Promise<MetaDataType>;
-    onGetSource(): string;
-    onInit(data: InitDataType): Promise<void>;
-    onPrune(data: PruneDataType): Promise<void>;
-    onSnapshots(data: SnapshotsDataType): Promise<SnapshotResultType[]>;
-    onBackup(data: BackupDataType<DatatruckPackageRepositoryConfigType>): Promise<void>;
-    onCopyBackup(data: CopyBackupType<DatatruckRepositoryConfigType>): Promise<void>;
-    onRestore(data: RestoreDataType<DatatruckPackageRepositoryConfigType>): Promise<void>;
+    getSource(): string;
+    fetchDiskStats(config: DatatruckRepositoryConfigType): Promise<import("../utils/fs").DiskStats>;
+    init(data: RepoInitData): Promise<void>;
+    prune(data: RepoPruneData): Promise<void>;
+    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
+    backup(data: RepoBackupData<DatatruckPackageRepositoryConfigType>): Promise<void>;
+    copy(data: RepoCopyData<DatatruckRepositoryConfigType>): Promise<void>;
+    restore(data: RepoRestoreData<DatatruckPackageRepositoryConfigType>): Promise<void>;
 }
 export {};

package/Repository/DatatruckRepository.js

@@ -4,11 +4,14 @@ exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exp
 const AppError_1 = require("../Error/AppError");
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
+const crypto_1 = require("../utils/crypto");
 const client_1 = require("../utils/datatruck/client");
 const paths_1 = require("../utils/datatruck/paths");
 const fs_1 = require("../utils/fs");
+const math_1 = require("../utils/math");
 const string_1 = require("../utils/string");
 const tar_1 = require("../utils/tar");
+const temp_1 = require("../utils/temp");
 const RepositoryAbstract_1 = require("./RepositoryAbstract");
 const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
@@ -73,14 +76,18 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static async parseMetaData(data) {
         return JSON.parse(data.toString());
     }
-    onGetSource() {
+    getSource() {
         return this.config.backend;
     }
-    async onInit(data) {
+    fetchDiskStats(config) {
+        const fs = (0, client_1.createFs)(config.backend);
+        return fs.fetchDiskStats(".");
+    }
+    async init(data) {
         const fs = (0, client_1.createFs)(this.config.backend);
         await fs.mkdir(".");
     }
-    async onPrune(data) {
+    async prune(data) {
         const fs = (0, client_1.createFs)(this.config.backend);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, {
             name: data.snapshot.packageName,
@@ -90,7 +97,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         if (await fs.existsDir(snapshotName))
             await fs.rmAll(snapshotName);
     }
-    async onSnapshots(data) {
+    async fetchSnapshots(data) {
         const fs = (0, client_1.createFs)(this.config.backend);
         if (!(await fs.existsDir(".")))
             throw new Error(`Repository (${this.repository.name}) out path does not exist: ${fs.resolvePath(".")}`);
@@ -132,26 +139,25 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         }
         return snapshots;
     }
-    async onBackup(data) {
+    async backup(data) {
         const fs = (0, client_1.createFs)(this.config.backend);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
         const outPath = fs.isLocal()
             ? fs.resolvePath(snapshotName)
-            : await this.mkTmpDir("datatruck-backup");
+            : await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "backup", "fs-remote");
         const pkg = data.package;
-        const sourcePath = data.targetPath ?? pkg.path;
-        (0, assert_1.ok)(sourcePath);
+        const path = pkg.path;
         await fs.mkdir(snapshotName);
         const backupPathsOptions = {
             package: data.package,
             snapshot: data.snapshot,
-            targetPath: sourcePath,
+            path: path,
             verbose: data.options.verbose,
         };
         const scanner = await (0, fs_1.createFileScanner)({
             onProgress: data.onProgress,
             glob: {
-                cwd: sourcePath,
+                cwd: path,
                 onlyFiles: false,
                 include: await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions),
                 ignore: pkg.exclude
@@ -170,7 +176,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const packs = [defaultsPack, ...configPacks];
         const defaultsPackIndex = packs.findIndex((p) => p === defaultsPack);
         const stream = (0, fs_1.createWriteStreamPool)({
-            path: await this.mkTmpDir("files"),
+            path: await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "backup", "stream-pool"),
             onStreamPath: (key) => `files-${key}.txt`,
         });
         scanner.total++;
@@ -192,7 +198,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 scanner.total++;
                 stream.writeLine(packIndex, ".");
             }
-            stream.writeLine(packIndex, entry.path);
+            stream.writeLine(packIndex, (0, tar_1.normalizeTarPath)(entry.path));
             return true;
         });
         await stream.end();
@@ -208,25 +214,29 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 tarStats[packBasename] = {
                     files: stream.lines(packIndex),
                     size: 0,
+                    checksum: "",
                 };
                 const tarPath = (0, path_1.join)(outPath, packBasename);
                 await (0, tar_1.createTar)({
                     compress: pack.compress,
                     verbose: data.options.verbose,
                     includeList,
-                    path: sourcePath,
+                    path: path,
                     output: tarPath,
-                    onEntry: async (data) => await scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
+                    onEntry: async (data) => scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
                 });
+                scanner.progress("Fetching tar stats", (0, path_1.basename)(tarPath));
+                tarStats[packBasename].checksum = await (0, crypto_1.calcFileHash)(tarPath, "sha1");
                 tarStats[packBasename].size = (await (0, promises_1.stat)(tarPath)).size;
                 if (!fs.isLocal()) {
+                    scanner.progress("Uploading tar", (0, path_1.basename)(tarPath));
                     await fs.upload(tarPath, `${snapshotName}/${packBasename}`);
                     await (0, promises_1.rm)(tarPath);
                 }
             }
             packIndex++;
         }
-        await scanner.end();
+        scanner.end();
         // Meta
         const metaPath = `${snapshotName}/meta.json`;
         const nodePkg = (0, fs_1.parsePackageFile)();
@@ -244,7 +254,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             (0, cli_1.logExec)(`Writing metadata into ${fs.resolvePath(metaPath)}`);
         await fs.writeFile(`${snapshotName}/meta.json`, JSON.stringify(meta));
     }
-    async onCopyBackup(data) {
+    async copy(data) {
         const sourceFs = (0, client_1.createFs)(this.config.backend);
         const targetFs = (0, client_1.createFs)(data.mirrorRepositoryConfig.backend);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
@@ -253,13 +263,25 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await targetFs.mkdir(snapshotName);
         await targetFs.ensureEmptyDir(snapshotName);
         const entries = await sourceFs.readdir(snapshotName);
+        const total = entries.length;
+        let current = 0;
         for (const entry of entries) {
+            data.onProgress({
+                absolute: {
+                    current,
+                    description: "Copying",
+                    payload: entry,
+                    total,
+                    percent: (0, math_1.progressPercent)(total, current),
+                },
+            });
+            current++;
             const sourceEntry = `${snapshotName}/${entry}`;
             if (targetFs.isLocal()) {
                 await sourceFs.download(sourceEntry, targetFs.resolvePath(sourceEntry));
             }
             else {
-                const tempDir = await this.mkTmpDir("remote-copy", entry);
+                const tempDir = await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "remote-copy", entry);
                 const tempFile = (0, path_1.join)(tempDir, entry);
                 try {
                     await sourceFs.download(sourceEntry, tempFile);
@@ -271,12 +293,12 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             }
         }
     }
-    async onRestore(data) {
+    async restore(data) {
         const fs = (0, client_1.createFs)(this.config.backend);
-        const relRestorePath = data.targetPath ?? data.package.restorePath;
+        const relRestorePath = data.snapshotPath;
         (0, assert_1.ok)(relRestorePath);
         const restorePath = (0, path_1.resolve)(relRestorePath);
-        const [snapshot] = await this.onSnapshots({
+        const [snapshot] = await this.fetchSnapshots({
             options: {
                 ids: [data.options.snapshotId],
             },
@@ -286,12 +308,12 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const snapshotName = DatatruckRepository.buildSnapshotName(snapshot, data.package);
         const meta = await DatatruckRepository.parseMetaData(await fs.readFile(`${snapshotName}/meta.json`));
         const progress = (0, fs_1.createProgress)({ onProgress: data.onProgress });
-        await progress.update("Scanning files");
+        progress.update("Scanning files");
         const entries = (await fs.readdir(snapshotName)).filter((v) => v.endsWith(".tar") || v.endsWith(".tar.gz"));
         const tarStats = meta?.tarStats || {};
         for (const file in tarStats)
             progress.total += tarStats[file].files;
-        await progress.update(`Scanned files: ${progress.total}`);
+        progress.update(`Scanned files: ${progress.total}`);
         if (data.options.verbose)
             (0, cli_1.logExec)(`Unpacking files to ${restorePath}`);
         for (const entry of entries) {
@@ -299,7 +321,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             try {
                 const sourceEntry = `${snapshotName}/${entry}`;
                 if (!fs.isLocal()) {
-                    const tempDir = await this.mkTmpDir("remote-restore", entry);
+                    const tempDir = await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "restore", "remote-fs", entry);
                     tempEntry = `${tempDir}/${entry}`;
                     await fs.download(sourceEntry, tempEntry);
                 }
@@ -309,7 +331,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                     output: restorePath,
                     decompress: entry.endsWith(".tar.gz"),
                     verbose: data.options.verbose,
-                    onEntry: async (data) => await progress.update(entry.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
+                    onEntry: (data) => progress.update(entry.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
                 });
             }
             finally {
@@ -317,7 +339,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                     await (0, fs_1.tryRm)(tempEntry);
             }
         }
-        await progress.update("Finished");
+        progress.update("Finished");
     }
 }
 exports.DatatruckRepository = DatatruckRepository;

package/Repository/GitRepository.d.ts

@@ -1,4 +1,4 @@
-import { RepositoryAbstract, BackupDataType, InitDataType, RestoreDataType, SnapshotsDataType, SnapshotResultType, SnapshotTagEnum, SnapshotTagObjectType, PruneDataType, CopyBackupType } from "./RepositoryAbstract";
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagEnum, SnapshotTagObjectType, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
 import { JSONSchema7 } from "json-schema";
 export type GitRepositoryConfigType = {
     repo: string;
@@ -10,7 +10,8 @@ export declare const gitRepositoryDefinition: JSONSchema7;
 export declare const gitPackageRepositoryDefinition: JSONSchema7;
 export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfigType> {
     static refPrefix: string;
-    onGetSource(): string;
+    getSource(): string;
+    fetchDiskStats(config: GitRepositoryConfigType): Promise<import("../utils/fs").DiskStats | undefined>;
     static buildSnapshotTagName(tag: Pick<SnapshotTagObjectType, SnapshotTagEnum.PACKAGE | SnapshotTagEnum.ID>): string;
     static buildSnapshotTag(tag: SnapshotTagObjectType): {
         name: string;
@@ -21,10 +22,10 @@ export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfi
         tags: string[];
     }) | null;
     static buildBranchName(packageName: string): string;
-    onInit(data: InitDataType): Promise<void>;
-    onPrune(data: PruneDataType): Promise<void>;
-    onSnapshots(data: SnapshotsDataType): Promise<SnapshotResultType[]>;
-    onBackup(data: BackupDataType<GitPackageRepositoryConfigType>): Promise<void>;
-    onCopyBackup(data: CopyBackupType<GitRepositoryConfigType>): Promise<void>;
-    onRestore(data: RestoreDataType<GitPackageRepositoryConfigType>): Promise<void>;
+    init(data: RepoInitData): Promise<void>;
+    prune(data: RepoPruneData): Promise<void>;
+    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
+    backup(data: RepoBackupData<GitPackageRepositoryConfigType>): Promise<void>;
+    copy(data: RepoCopyData<GitRepositoryConfigType>): Promise<void>;
+    restore(data: RepoRestoreData<GitPackageRepositoryConfigType>): Promise<void>;
 }