Start9/start-sdk
2
0
Fork 0
mirror of https://github.com/Start9Labs/start-sdk.git synced 2026-03-30 12:21:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: Update the backups

Browse Source
This commit is contained in:
BluJ
2023-04-24 14:07:13 -06:00
parent 0be8d9d5bc
commit 75ec297be1
7 changed files with 271 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
lib/backup/Backups.ts Normal file
View File

@@ -0,0 +1,172 @@
import { GenericManifest } from "../manifest/ManifestTypes";
import * as T from "../types";
export const DEFAULT_OPTIONS: T.BackupOptions = {
delete: true,
force: true,
ignoreExisting: false,
exclude: [],
};
type BackupSet = {
srcPath: string;
srcVolume: string;
dstPath: string;
dstVolume: string;
options?: Partial<T.BackupOptions>;
};
/**
* This utility simplifies the volume backup process.
* ```ts
* export const { createBackup, restoreBackup } = Backups.volumes("main").build();
* ```
*
* Changing the options of the rsync, (ie exludes) use either
* ```ts
* Backups.volumes("main").set_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
* // or
* Backups.with_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
* ```
*
* Using the more fine control, using the addSets for more control
* ```ts
* Backups.addSets({
* srcVolume: 'main', srcPath:'smallData/', dstPath: 'main/smallData/', dstVolume: : Backups.BACKUP
* }, {
* srcVolume: 'main', srcPath:'bigData/', dstPath: 'main/bigData/', dstVolume: : Backups.BACKUP, options: {exclude:['bigData/excludeThis']}}
* ).build()q
* ```
*/
export class Backups<M extends GenericManifest> {
static BACKUP = "BACKUP" as const;
constructor(
private options = DEFAULT_OPTIONS,
private backupSet = [] as BackupSet[],
) {}
static volumes<M extends GenericManifest>(
...volumeNames: Array<keyof M["volumes"] & string>
) {
return new Backups().addSets(
...volumeNames.map((srcVolume) => ({
srcVolume,
srcPath: "./",
dstPath: `./${srcVolume}/`,
dstVolume: Backups.BACKUP,
})),
);
}
static addSets(...options: BackupSet[]) {
return new Backups().addSets(...options);
}
static with_options(options?: Partial<T.BackupOptions>) {
return new Backups({ ...DEFAULT_OPTIONS, ...options });
}
set_options(options?: Partial<T.BackupOptions>) {
this.options = {
...this.options,
...options,
};
return this;
}
volumes(...volumeNames: Array<keyof M["volumes"] & string>) {
return this.addSets(
...volumeNames.map((srcVolume) => ({
srcVolume,
srcPath: "./",
dstPath: `./${srcVolume}/`,
dstVolume: Backups.BACKUP,
})),
);
}
addSets(...options: BackupSet[]) {
options.forEach((x) =>
this.backupSet.push({ ...x, options: { ...this.options, ...x.options } }),
);
return this;
}
build() {
const createBackup: T.ExpectedExports.createBackup = async ({
effects,
}) => {
const previousItems = (
await effects
.readDir({
volumeId: Backups.BACKUP,
path: ".",
})
.catch(() => [])
).map((x) => `${x}`);
const backupPaths = this.backupSet
.filter((x) => x.dstVolume === Backups.BACKUP)
.map((x) => x.dstPath)
.map((x) => x.replace(/\.\/([^]*)\//, "$1"));
const filteredItems = previousItems.filter(
(x) => backupPaths.indexOf(x) === -1,
);
for (const itemToRemove of filteredItems) {
effects.error(`Trying to remove ${itemToRemove}`);
await effects
.removeDir({
volumeId: Backups.BACKUP,
path: itemToRemove,
})
.catch(() =>
effects.removeFile({
volumeId: Backups.BACKUP,
path: itemToRemove,
}),
)
.catch(() => {
effects.warn(`Failed to remove ${itemToRemove} from backup volume`);
});
}
for (const item of this.backupSet) {
if (notEmptyPath(item.dstPath)) {
await effects.createDir({
volumeId: item.dstVolume,
path: item.dstPath,
});
}
await effects
.runRsync({
...item,
options: {
...this.options,
...item.options,
},
})
.wait();
}
return;
};
const restoreBackup: T.ExpectedExports.restoreBackup = async ({
effects,
}) => {
for (const item of this.backupSet) {
if (notEmptyPath(item.srcPath)) {
await effects.createDir({
volumeId: item.srcVolume,
path: item.srcPath,
});
}
await effects
.runRsync({
options: {
...this.options,
...item.options,
},
srcVolume: item.dstVolume,
dstVolume: item.srcVolume,
srcPath: item.dstPath,
dstPath: item.srcPath,
})
.wait();
}
return;
};
return { createBackup, restoreBackup };
}
}
function notEmptyPath(file: string) {
return ["", ".", "./"].indexOf(file) === -1;
}

170
lib/backup/index.ts
View File

@@ -1,169 +1,3 @@
import * as T from "../types"; export { Backups } from "./Backups";
export const DEFAULT_OPTIONS: T.BackupOptions = { export { setupBackups } from "./setupBackups";
delete: true,
force: true,
ignoreExisting: false,
exclude: [],
};
type BackupSet = {
srcPath: string;
srcVolume: string;
dstPath: string;
dstVolume: string;
options?: Partial<T.BackupOptions>;
};
/**
* This utility simplifies the volume backup process.
* ```ts
* export const { createBackup, restoreBackup } = Backups.volumes("main").build();
* ```
*
* Changing the options of the rsync, (ie exludes) use either
* ```ts
* Backups.volumes("main").set_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
* // or
* Backups.with_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
* ```
*
* Using the more fine control, using the addSets for more control
* ```ts
* Backups.addSets({
* srcVolume: 'main', srcPath:'smallData/', dstPath: 'main/smallData/', dstVolume: : Backups.BACKUP
* }, {
* srcVolume: 'main', srcPath:'bigData/', dstPath: 'main/bigData/', dstVolume: : Backups.BACKUP, options: {exclude:['bigData/excludeThis']}}
* ).build()q
* ```
*/
export class Backups {
static BACKUP = "BACKUP" as const;
constructor(
private options = DEFAULT_OPTIONS,
private backupSet = [] as BackupSet[],
) {}
static volumes(...volumeNames: string[]) {
return new Backups().addSets(
...volumeNames.map((srcVolume) => ({
srcVolume,
srcPath: "./",
dstPath: `./${srcVolume}/`,
dstVolume: Backups.BACKUP,
})),
);
}
static addSets(...options: BackupSet[]) {
return new Backups().addSets(...options);
}
static with_options(options?: Partial<T.BackupOptions>) {
return new Backups({ ...DEFAULT_OPTIONS, ...options });
}
set_options(options?: Partial<T.BackupOptions>) {
this.options = {
...this.options,
...options,
};
return this;
}
volumes(...volumeNames: string[]) {
return this.addSets(
...volumeNames.map((srcVolume) => ({
srcVolume,
srcPath: "./",
dstPath: `./${srcVolume}/`,
dstVolume: Backups.BACKUP,
})),
);
}
addSets(...options: BackupSet[]) {
options.forEach((x) =>
this.backupSet.push({ ...x, options: { ...this.options, ...x.options } }),
);
return this;
}
build() {
const createBackup: T.ExpectedExports.createBackup = async ({
effects,
}) => {
const previousItems = (
await effects
.readDir({
volumeId: Backups.BACKUP,
path: ".",
})
.catch(() => [])
).map((x) => `${x}`);
const backupPaths = this.backupSet
.filter((x) => x.dstVolume === Backups.BACKUP)
.map((x) => x.dstPath)
.map((x) => x.replace(/\.\/([^]*)\//, "$1"));
const filteredItems = previousItems.filter(
(x) => backupPaths.indexOf(x) === -1,
);
for (const itemToRemove of filteredItems) {
effects.error(`Trying to remove ${itemToRemove}`);
await effects
.removeDir({
volumeId: Backups.BACKUP,
path: itemToRemove,
})
.catch(() =>
effects.removeFile({
volumeId: Backups.BACKUP,
path: itemToRemove,
}),
)
.catch(() => {
effects.warn(`Failed to remove ${itemToRemove} from backup volume`);
});
}
for (const item of this.backupSet) {
if (notEmptyPath(item.dstPath)) {
await effects.createDir({
volumeId: item.dstVolume,
path: item.dstPath,
});
}
await effects
.runRsync({
...item,
options: {
...this.options,
...item.options,
},
})
.wait();
}
return;
};
const restoreBackup: T.ExpectedExports.restoreBackup = async ({
effects,
}) => {
for (const item of this.backupSet) {
if (notEmptyPath(item.srcPath)) {
await effects.createDir({
volumeId: item.srcVolume,
path: item.srcPath,
});
}
await effects
.runRsync({
options: {
...this.options,
...item.options,
},
srcVolume: item.dstVolume,
dstVolume: item.srcVolume,
srcPath: item.dstPath,
dstPath: item.srcPath,
})
.wait();
}
return;
};
return { createBackup, restoreBackup };
}
}
function notEmptyPath(file: string) {
return ["", ".", "./"].indexOf(file) === -1;
}

30
lib/backup/setupBackups.ts Normal file
View File

@@ -0,0 +1,30 @@
import { string } from "ts-matches";
import { Backups } from ".";
import { GenericManifest } from "../manifest/ManifestTypes";
import { BackupOptions } from "../types";
export type SetupBackupsParams<M extends GenericManifest> =
| [Partial<BackupOptions>, ...Array<keyof M["volumes"] & string>]
| Array<keyof M["volumes"] & string>;
export function setupBackups<M extends GenericManifest>(
...args: SetupBackupsParams<M>
) {
const [options, volumes] = splitOptions(args);
if (!options) {
return Backups.volumes(...volumes).build();
}
return Backups.with_options(options)
.volumes(...volumes)
.build();
}
function splitOptions<M extends GenericManifest>(
args: SetupBackupsParams<M>,
): [null | Partial<BackupOptions>, Array<keyof M["volumes"] & string>] {
if (args.length > 0 && !string.test(args[0])) {
const [options, ...restVolumes] = args;
return [options, restVolumes as Array<keyof M["volumes"] & string>];
}
return [null, args as Array<keyof M["volumes"] & string>];
}

1
lib/index.ts
View File

@@ -14,3 +14,4 @@ export * as YAML from "yaml";
export * as properties from "./properties"; export * as properties from "./properties";
export * as autoconfig from "./autoconfig"; export * as autoconfig from "./autoconfig";
export * as actions from "./actions"; export * as actions from "./actions";
export * as manifest from "./manifest";

56
lib/manifest/ManifestTypes.ts Normal file
View File

@@ -0,0 +1,56 @@
export interface Container {
image: string;
mounts: Record<string, string>;
shmSizeMb?: number; // if greater
sigtermTimeout?: string; // if more than 30s to shutdown
}
export interface GenericManifest {
id: string;
title: string;
version: string;
releaseNotes: string;
license: string; // name of license
replaces: string[];
wrapperRepo: string;
upstreamRepo: string;
supportSite: string;
marketingSite: string;
donationUrl: string | null;
description: {
short: string;
long: string;
};
assets: {
icon: string; // file path
instructions: string; // file path
license: string; // file path
};
containers: Record<string, Container>;
volumes: Record<string, string>;
alerts: {
install: string | null;
uninstall: string | null;
restore: string | null;
start: string | null;
stop: string | null;
};
dependencies: Record<string, Dependency>;
}
export interface Dependency {
version: string;
description: string | null;
requirement:
| {
type: "opt-in";
how: string;
}
| {
type: "opt-out";
how: string;
}
| {
type: "required";
};
}

2
lib/manifest/index.ts Normal file
View File

@@ -0,0 +1,2 @@
export { setupManifest } from "./setupManifest";
export * as ManifestTypes from "./ManifestTypes";

8
lib/manifest/setupManifest.ts Normal file
View File

@@ -0,0 +1,8 @@
import { GenericManifest } from "./ManifestTypes";
export function setupManifest<
M extends GenericManifest & { id: Id },
Id extends string,
>(manifest: M): M {
return manifest;
}