111 lines
3.5 KiB
TypeScript
111 lines
3.5 KiB
TypeScript
import * as plugins from '../plugins.js';
|
|
|
|
type IExecutionEnvironment = import('@design.estate/dees-catalog').IExecutionEnvironment;
|
|
type IFileEntry = import('@design.estate/dees-catalog').IFileEntry;
|
|
type IFileWatcher = import('@design.estate/dees-catalog').IFileWatcher;
|
|
type IProcessHandle = import('@design.estate/dees-catalog').IProcessHandle;
|
|
|
|
type TTypedRequestShape = {
|
|
method: string;
|
|
request: Record<string, unknown>;
|
|
response: Record<string, unknown>;
|
|
};
|
|
|
|
export class DeploymentExecutionEnvironment implements IExecutionEnvironment {
|
|
public readonly type = 'backend' as const;
|
|
private readyState = false;
|
|
|
|
constructor(
|
|
private deploymentId: string,
|
|
private identity: plugins.interfaces.data.IIdentity,
|
|
) {}
|
|
|
|
get ready(): boolean {
|
|
return this.readyState;
|
|
}
|
|
|
|
public async init(): Promise<void> {
|
|
const result = await this.fireRequest('deploymentWorkspaceExists', { path: '/' }) as { exists: boolean };
|
|
if (!result.exists) {
|
|
throw new Error(`Cannot access deployment filesystem for ${this.deploymentId}`);
|
|
}
|
|
this.readyState = true;
|
|
}
|
|
|
|
public async destroy(): Promise<void> {
|
|
this.readyState = false;
|
|
}
|
|
|
|
public async readFile(pathArg: string): Promise<string> {
|
|
const result = await this.fireRequest('deploymentWorkspaceReadFile', { path: pathArg }) as { content: string };
|
|
return result.content;
|
|
}
|
|
|
|
public async writeFile(pathArg: string, contentsArg: string): Promise<void> {
|
|
await this.fireRequest('deploymentWorkspaceWriteFile', { path: pathArg, content: contentsArg });
|
|
}
|
|
|
|
public async readDir(pathArg: string): Promise<IFileEntry[]> {
|
|
const result = await this.fireRequest('deploymentWorkspaceReadDir', { path: pathArg }) as { entries: IFileEntry[] };
|
|
return result.entries;
|
|
}
|
|
|
|
public async mkdir(pathArg: string): Promise<void> {
|
|
await this.fireRequest('deploymentWorkspaceMkdir', { path: pathArg });
|
|
}
|
|
|
|
public async rm(pathArg: string, optionsArg?: { recursive?: boolean }): Promise<void> {
|
|
await this.fireRequest('deploymentWorkspaceRm', {
|
|
path: pathArg,
|
|
recursive: optionsArg?.recursive,
|
|
});
|
|
}
|
|
|
|
public async exists(pathArg: string): Promise<boolean> {
|
|
const result = await this.fireRequest('deploymentWorkspaceExists', { path: pathArg }) as { exists: boolean };
|
|
return result.exists;
|
|
}
|
|
|
|
public watch(
|
|
_pathArg: string,
|
|
_callbackArg: (eventArg: 'rename' | 'change', filenameArg: string | null) => void,
|
|
_optionsArg?: { recursive?: boolean },
|
|
): IFileWatcher {
|
|
return { stop: () => {} };
|
|
}
|
|
|
|
public async spawn(commandArg: string, argsArg: string[] = []): Promise<IProcessHandle> {
|
|
const result = await this.fireRequest('deploymentWorkspaceExec', {
|
|
command: commandArg,
|
|
args: argsArg,
|
|
}) as { stdout?: string; stderr?: string; exitCode: number };
|
|
|
|
const output = new ReadableStream<string>({
|
|
start(controllerArg) {
|
|
if (result.stdout) controllerArg.enqueue(result.stdout);
|
|
if (result.stderr) controllerArg.enqueue(result.stderr);
|
|
controllerArg.close();
|
|
},
|
|
});
|
|
|
|
return {
|
|
output,
|
|
input: new WritableStream<string>(),
|
|
exit: Promise.resolve(result.exitCode),
|
|
kill: () => {},
|
|
};
|
|
}
|
|
|
|
private async fireRequest(methodArg: string, dataArg: Record<string, unknown>) {
|
|
const typedRequest = new plugins.typedrequest.TypedRequest<TTypedRequestShape>(
|
|
'/typedrequest',
|
|
methodArg,
|
|
);
|
|
return await typedRequest.fire({
|
|
identity: this.identity,
|
|
deploymentId: this.deploymentId,
|
|
...dataArg,
|
|
});
|
|
}
|
|
}
|