Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

3.3 KB
Raw Blame
import { BackupStrategy } from './BackupStrategy';
import { BackupPlanArgs, BackupVerifiedResult, PlanAddRunSettings } from '../../types/plans';
import { BaseBackupManager } from '../../managers/BaseBackupManager';
import { readFile } from 'fs/promises';
import { appPaths } from '../../utils/AppPaths';
import { BackupRunConfig } from '../../types/backups';

export class LocalStrategy implements BackupStrategy {
	constructor(protected localAgent: BaseBackupManager) {}

	async performBackup(backupId: string, runConfig?: BackupRunConfig) {
		return await this.localAgent.performBackup(backupId, runConfig);
	}

	async createBackup(backupId: string, options: BackupPlanArgs, runSettings?: PlanAddRunSettings) {
		return await this.localAgent.createBackup(backupId, options, runSettings);
	}

	async updateBackup(backupId: string, options: BackupPlanArgs) {
		return await this.localAgent.updateBackup(backupId, options);
	}

	async cancelBackup(planId: string, backupId: string) {
		return await this.localAgent.cancelBackup(planId, backupId);
	}

	async removeBackup(
		planId: string,
		options: {
			storageName: string;
			storagePath: string;
			encryption: boolean;
			removeRemoteData: boolean;
			replicationStorages?: { storageName: string; storagePath: string }[];
		}
	) {
		const { storageName, storagePath, removeRemoteData, encryption, replicationStorages } = options;
		return await this.localAgent.removeBackup(planId, {
			storageName,
			storagePath,
			removeRemoteData,
			encryption,
			replicationStorages,
		});
	}

	async removeReplicationStorage(
		planId: string,
		options: {
			storageName: string;
			storagePath: string;
			removeData: boolean;
		}
	) {
		return await this.localAgent.removeReplicationStorage(planId, options);
	}

	async pauseBackup(backupId: string) {
		return await this.localAgent.pauseBackup(backupId);
	}
	async resumeBackup(backupId: string) {
		return await this.localAgent.resumeBackup(backupId);
	}
	async pruneBackups(
		backupId: string,
		replicationStorages?: { storageName: string; storagePath: string }[]
	) {
		return await this.localAgent.pruneBackups(backupId, replicationStorages);
	}

	async unlockRepo(
		planId: string,
		replicationStorages?: { storageName: string; storagePath: string }[]
	) {
		return await this.localAgent.unlockRepo(planId, replicationStorages);
	}

	async updatePlanStorageName(storageId: string, newStorageName: string) {
		return await this.localAgent.updatePlanStorageName(storageId, newStorageName);
	}

	async checkIntegrity(planId: string): Promise<{ success: boolean; result: any }> {
		return await this.localAgent.checkIntegrity(planId);
	}

	async repairRepo(
		planId: string,
		repairType: 'snapshots' | 'index' | 'packs',
		checkRes: BackupVerifiedResult,
		options: { storageName: string; storagePath: string }
	): Promise<{ success: boolean; result: any }> {
		return await this.localAgent.repairRepo(planId, repairType, checkRes, options);
	}

	async getBackupProgress(planId: string, backupId: string) {
		try {
			const filename = `backup-${backupId}.json`;
			const progressFile = `${appPaths.getProgressDir()}/${filename}`;
			const progressData = await readFile(progressFile, 'utf8');
			const progress = JSON.parse(progressData);
			return { success: true, result: progress };
		} catch (error: any) {
			return { success: false, result: error?.message };
		}
	}
}