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

feat: Implentation of the daemons

Browse Source
This commit is contained in:
BluJ
2023-04-11 17:05:52 -06:00
parent f3c1cea0b9
commit 77a9c6d20e
5 changed files with 370 additions and 525 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/health/trigger/TriggerInput.ts
View File

@@ -1,4 +1,4 @@
export type TriggerInput = {
lastResult: "success" | "failure" | null;
hadSuccess: boolean;
lastResult?: "success" | "failure" | null;
hadSuccess?: boolean;
};

53
lib/mainFn/Daemons.ts
View File

@@ -1,13 +1,10 @@
import { HealthReceipt, ReadyProof } from "../health";
import { CheckResult } from "../health/checkFns";
import { Trigger } from "../health/trigger";
import { Effects, ValidIfNoStupidEscape } from "../types";
import { defaultTrigger } from "../health/trigger/defaultTrigger";
import { DaemonReturned, Effects, ValidIfNoStupidEscape } from "../types";
import { InterfaceReceipt } from "./interfaceReceipt";
type Daemon<
Ids extends string | never,
Command extends string,
Id extends string
> = {
type Daemon<Ids extends string | never, Command extends string, Id extends string> = {
id: Id;
command: ValidIfNoStupidEscape<Command> | [string, ...string[]];
@@ -20,11 +17,9 @@ type Daemon<
trigger?: Trigger;
};
requires?: Exclude<Ids, Id>[];
intervalTime?: number;
};
const todo = <A>(): A => {
throw new Error("TODO");
};
/**
* Used during the main of a function, it allows us to describe and ensure a set of daemons are running.
* With the dependency, we are using this like an init system, where we can ensure that a daemon is running
@@ -53,7 +48,7 @@ export class Daemons<Ids extends string | never> {
private constructor(
readonly effects: Effects,
readonly started: (onTerm: () => void) => null,
readonly daemons?: Daemon<Ids, "command", any>[]
readonly daemons?: Daemon<Ids, "command", Ids>[]
) {}
static of(config: {
@@ -64,15 +59,39 @@ export class Daemons<Ids extends string | never> {
}) {
return new Daemons<never>(config.effects, config.started);
}
addDaemon<Id extends string, Command extends string>(
newDaemon: Daemon<Ids, Command, Id>
) {
const daemons = [...(this?.daemons ?? [])];
daemons.push(newDaemon as any);
addDaemon<Id extends string, Command extends string>(newDaemon: Daemon<Ids, Command, Id>) {
const daemons = ((this?.daemons ?? []) as any[]).concat(newDaemon);
return new Daemons<Ids | Id>(this.effects, this.started, daemons);
}
build() {
return todo<any>();
async build() {
const daemonsStarted = {} as Record<Ids, Promise<DaemonReturned>>;
const { effects } = this;
const daemons = this.daemons ?? [];
const _config = await effects.getServiceConfig();
for (const daemon of daemons) {
const requiredPromise = Promise.all(daemon.requires?.map((id) => daemonsStarted[id]) ?? []);
daemonsStarted[daemon.id] = requiredPromise.then(async () => {
const { command } = daemon;
const child = effects.runDaemon(command);
const trigger = (daemon.ready.trigger ?? defaultTrigger)();
for (let res = await trigger.next({}); !res.done; res = await trigger.next({})) {
const response = await daemon.ready.fn();
if (response.status === "passing") {
return child;
}
}
return child;
});
}
return {
async term() {
await Promise.all(Object.values<Promise<DaemonReturned>>(daemonsStarted).map((x) => x.then((x) => x.term())));
},
async wait() {
await Promise.all(Object.values<Promise<DaemonReturned>>(daemonsStarted).map((x) => x.then((x) => x.wait())));
},
};
}
}

9
lib/mainFn/index.ts
View File

@@ -22,13 +22,10 @@ export { Daemons } from "./Daemons";
* @returns
*/
export const runningMain: (
fn: (o: {
effects: Effects;
started(onTerm: () => void): null;
}) => Promise<Daemons<any>>
fn: (o: { effects: Effects; started(onTerm: () => void): null }) => Promise<Daemons<any>>
) => ExpectedExports.main = (fn) => {
return async (options) => {
/// TODO BLUJ
return null as any;
const result = await fn(options);
await result.build().then((x) => x.wait());
};
};

116
lib/types.ts
View File

@@ -4,39 +4,24 @@ import { InputSpec } from "./config/configTypes";
export namespace ExpectedExports {
version: 1;
/** Set configuration is called after we have modified and saved the configuration in the embassy ui. Use this to make a file for the docker to read from for configuration. */
export type setConfig = (options: {
effects: Effects;
input: Record<string, unknown>;
}) => Promise<unknown>;
export type setConfig = (options: { effects: Effects; input: Record<string, unknown> }) => Promise<unknown>;
/** Get configuration returns a shape that describes the format that the embassy ui will generate, and later send to the set config */
export type getConfig = (options: {
effects: Effects;
config: unknown;
}) => Promise<ConfigRes>;
export type getConfig = (options: { effects: Effects; config: unknown }) => Promise<ConfigRes>;
/** These are how we make sure the our dependency configurations are valid and if not how to fix them. */
export type dependencies = Dependencies;
/** For backing up service data though the embassyOS UI */
export type createBackup = (options: {
effects: Effects;
}) => Promise<unknown>;
export type createBackup = (options: { effects: Effects }) => Promise<unknown>;
/** For restoring service data that was previously backed up using the embassyOS UI create backup flow. Backup restores are also triggered via the embassyOS UI, or doing a system restore flow during setup. */
export type restoreBackup = (options: {
effects: Effects;
}) => Promise<unknown>;
export type restoreBackup = (options: { effects: Effects }) => Promise<unknown>;
/** Properties are used to get values from the docker, like a username + password, what ports we are hosting from */
export type properties = (options: {
effects: Effects;
}) => Promise<Properties>;
export type properties = (options: { effects: Effects }) => Promise<Properties>;
/** Health checks are used to determine if the service is working properly after starting
* A good use case is if we are using a web server, seeing if we can get to the web server.
*/
export type health = {
/** Should be the health check id */
[id: string]: (options: {
effects: Effects;
input: TimeMs;
}) => Promise<unknown>;
[id: string]: (options: { effects: Effects; input: TimeMs }) => Promise<unknown>;
};
/**
@@ -45,43 +30,29 @@ export namespace ExpectedExports {
* service starting, and that file would indicate that it would rescan all the data.
*/
export type action = {
[id: string]: (options: {
effects: Effects;
input?: Record<string, unknown>;
}) => Promise<ActionResult>;
[id: string]: (options: { effects: Effects; input?: Record<string, unknown> }) => Promise<ActionResult>;
};
/**
* This is the entrypoint for the main container. Used to start up something like the service that the
* package represents, like running a bitcoind in a bitcoind-wrapper.
*/
export type main = (options: {
effects: Effects;
started(onTerm: () => void): null;
}) => Promise<unknown>;
export type main = (options: { effects: Effects; started(onTerm: () => void): null }) => Promise<unknown>;
/**
* Every time a package completes an install, this function is called before the main.
* Can be used to do migration like things.
*/
export type init = (options: {
effects: Effects;
previousVersion: null | string;
}) => Promise<unknown>;
export type init = (options: { effects: Effects; previousVersion: null | string }) => Promise<unknown>;
/** This will be ran during any time a package is uninstalled, for example during a update
* this will be called.
*/
export type uninit = (options: {
effects: Effects;
nextVersion: null | string;
}) => Promise<unknown>;
export type uninit = (options: { effects: Effects; nextVersion: null | string }) => Promise<unknown>;
}
export type TimeMs = number;
export type VersionString = string;
export type ValidIfNoStupidEscape<A> = A extends
| `${string}'"'"'${string}`
| `${string}\\"${string}`
export type ValidIfNoStupidEscape<A> = A extends `${string}'"'"'${string}` | `${string}\\"${string}`
? never
: "" extends A & ""
? never
@@ -106,18 +77,17 @@ export type Daemon = {
export type HealthStatus = "passing" | "warning" | "failing" | "disabled";
export type CommandType<A extends string> =
| ValidIfNoStupidEscape<A>
| [string, ...string[]];
export type CommandType<A extends string> = ValidIfNoStupidEscape<A> | [string, ...string[]];
export type DaemonReturned = {
wait(): Promise<string>;
term(): Promise<void>;
};
/** Used to reach out from the pure js runtime */
export type Effects = {
/** Usable when not sandboxed */
writeFile(input: {
path: string;
volumeId: string;
toWrite: string;
}): Promise<void>;
writeFile(input: { path: string; volumeId: string; toWrite: string }): Promise<void>;
readFile(input: { volumeId: string; path: string }): Promise<string>;
metadata(input: { volumeId: string; path: string }): Promise<Metadata>;
/** Create a directory. Usable when not sandboxed */
@@ -129,17 +99,10 @@ export type Effects = {
removeFile(input: { volumeId: string; path: string }): Promise<void>;
/** Write a json file into an object. Usable when not sandboxed */
writeJsonFile(input: {
volumeId: string;
path: string;
toWrite: Record<string, unknown>;
}): Promise<void>;
writeJsonFile(input: { volumeId: string; path: string; toWrite: Record<string, unknown> }): Promise<void>;
/** Read a json file into an object */
readJsonFile(input: {
volumeId: string;
path: string;
}): Promise<Record<string, unknown>>;
readJsonFile(input: { volumeId: string; path: string }): Promise<Record<string, unknown>>;
runCommand<A extends string>(
command: ValidIfNoStupidEscape<A> | [string, ...string[]],
@@ -151,13 +114,7 @@ export type Effects = {
wait(): Promise<string>;
term(): Promise<void>;
};
runDaemon<A extends string>(
command: ValidIfNoStupidEscape<A> | [string, ...string[]]
): {
wait(): Promise<string>;
term(): Promise<void>;
[DaemonProof]: never;
};
runDaemon<A extends string>(command: ValidIfNoStupidEscape<A> | [string, ...string[]]): DaemonReturned;
/** Uses the chown on the system */
chown(input: { volumeId: string; path: string; uid: string }): Promise<null>;
@@ -185,11 +142,7 @@ export type Effects = {
/** Declaring that we are opening a interface on some protocal for local network */
bindLan(options: { internalPort: number; name: string }): Promise<string[]>;
/** Declaring that we are opening a interface on some protocal for tor network */
bindTor(options: {
internalPort: number;
name: string;
externalPort: number;
}): Promise<string>;
bindTor(options: { internalPort: number; name: string; externalPort: number }): Promise<string>;
/** Similar to the fetch api via the mdn, this is simplified but the point is
* to get something from some website, and return the response.
@@ -239,17 +192,11 @@ export type Effects = {
getLocalHostname(): Promise<string>;
getIPHostname(): Promise<string>;
/** Get the address for another service for tor interfaces */
getServiceTorHostname(
interfaceId: string,
packageId?: string
): Promise<string>;
getServiceTorHostname(interfaceId: string, packageId?: string): Promise<string>;
/**
* Get the port address for another service
*/
getServicePortForward(
internalPort: number,
packageId?: string
): Promise<number>;
getServicePortForward(internalPort: number, packageId?: string): Promise<number>;
/** When we want to create a link in the front end interfaces, and example is
* exposing a url to view a web service
@@ -319,20 +266,13 @@ export type Effects = {
*
* @returns PEM encoded fullchain (ecdsa)
*/
getSslCertificate: (
packageId: string,
algorithm?: "ecdsa" | "ed25519"
) => [string, string, string];
getSslCertificate: (packageId: string, algorithm?: "ecdsa" | "ed25519") => [string, string, string];
/**
* @returns PEM encoded ssl key (ecdsa)
*/
getSslKey: (packageId: string, algorithm?: "ecdsa" | "ed25519") => string;
setHealth(o: {
name: string;
status: HealthStatus;
message?: string;
}): Promise<void>;
setHealth(o: { name: string; status: HealthStatus; message?: string }): Promise<void>;
};
/* rsync options: https://linux.die.net/man/1/rsync
@@ -456,6 +396,4 @@ export type Dependencies = {
};
};
export type DeepPartial<T> = T extends {}
? { [P in keyof T]?: DeepPartial<T[P]> }
: T;
export type DeepPartial<T> = T extends {} ? { [P in keyof T]?: DeepPartial<T[P]> } : T;