@milaboratories/pl-deployments 2.15.16 → 2.15.18

package/dist/local/pl.d.ts

@@ -1,81 +1,81 @@
-import type { ProcessOptions } from "./process";
-import type { PlBinarySource } from "../common/pl_binary";
-import type { MiLogger } from "@milaboratories/ts-helpers";
-import type { SpawnOptions } from "node:child_process";
-import type { Trace } from "./trace";
-import type { Required } from "utility-types";
-import type { ProxySettings } from "@milaboratories/pl-http";
-export declare const LocalConfigYaml = "config-local.yaml";
+import { ProcessOptions } from "./process.js";
+import { PlBinarySource } from "../common/pl_binary.js";
+import { Trace } from "./trace.js";
+import { SpawnOptions } from "node:child_process";
+import { MiLogger } from "@milaboratories/ts-helpers";
+import { ProxySettings } from "@milaboratories/pl-http";
+import { Required } from "utility-types";
+
+//#region src/local/pl.d.ts
+declare const LocalConfigYaml = "config-local.yaml";
 /**
  * Represents a local running pl-core,
  * and has methods to start, check if it's running, stop and wait for stopping it.
  * Also, a hook on pl-core closed can be provided.
  */
-export declare class LocalPl {
-    private readonly logger;
-    private readonly workingDir;
-    private readonly startOptions;
-    private readonly initialStartHistory;
-    private readonly onClose?;
-    private readonly onError?;
-    private readonly onCloseAndError?;
-    private readonly onCloseAndErrorNoStop?;
-    private instance?;
-    pid?: number;
-    private nRuns;
-    private lastRunHistory;
-    private wasStopped;
-    constructor(logger: MiLogger, workingDir: string, startOptions: ProcessOptions, initialStartHistory: Trace, onClose?: ((pl: LocalPl) => Promise<void>) | undefined, onError?: ((pl: LocalPl) => Promise<void>) | undefined, onCloseAndError?: ((pl: LocalPl) => Promise<void>) | undefined, onCloseAndErrorNoStop?: ((pl: LocalPl) => Promise<void>) | undefined);
-    start(): Promise<void>;
-    stop(): void;
-    waitStopped(): Promise<void>;
-    stopped(): boolean;
-    isAlive(): Promise<boolean>;
-    debugInfo(): {
-        lastRunHistory: Trace;
-        nRuns: number;
-        pid: number | undefined;
-        workingDir: string;
-        initialStartHistory: Trace;
-        wasStopped: boolean;
-    };
+declare class LocalPl {
+  private readonly logger;
+  private readonly workingDir;
+  private readonly startOptions;
+  private readonly initialStartHistory;
+  private readonly onClose?;
+  private readonly onError?;
+  private readonly onCloseAndError?;
+  private readonly onCloseAndErrorNoStop?;
+  private instance?;
+  pid?: number;
+  private nRuns;
+  private lastRunHistory;
+  private wasStopped;
+  constructor(logger: MiLogger, workingDir: string, startOptions: ProcessOptions, initialStartHistory: Trace, onClose?: ((pl: LocalPl) => Promise<void>) | undefined, onError?: ((pl: LocalPl) => Promise<void>) | undefined, onCloseAndError?: ((pl: LocalPl) => Promise<void>) | undefined, onCloseAndErrorNoStop?: ((pl: LocalPl) => Promise<void>) | undefined);
+  start(): Promise<void>;
+  stop(): void;
+  waitStopped(): Promise<void>;
+  stopped(): boolean;
+  isAlive(): Promise<boolean>;
+  debugInfo(): {
+    lastRunHistory: Trace;
+    nRuns: number;
+    pid: number | undefined;
+    workingDir: string;
+    initialStartHistory: Trace;
+    wasStopped: boolean;
+  };
 }
 /** Options to start a local pl-core. */
-export type LocalPlOptions = {
-    /** From what directory start a process. */
-    readonly workingDir: string;
-    /** A string representation of yaml config. */
-    readonly config: string;
-    /** How to get a binary, download it or get an existing one (default: download latest version) */
-    readonly plBinary?: PlBinarySource;
-    /** Additional options for a process, environments, stdout, stderr etc. */
-    readonly spawnOptions?: SpawnOptions;
-    /**
-     * If the previous pl-core was started from the same directory,
-     * we can check if it's still running and then stop it before starting a new one.
-     * (default: true)
-     */
-    readonly closeOld?: boolean;
-    /**
-     * Proxy settings to use to fetch the binary and pass it down
-     * as a HTTPS_PROXY/HTTP_PROXY environment variable;
-     * Backend only supports Basic auth.
-     */
-    readonly proxy?: ProxySettings;
-    readonly onClose?: (pl: LocalPl) => Promise<void>;
-    readonly onError?: (pl: LocalPl) => Promise<void>;
-    readonly onCloseAndError?: (pl: LocalPl) => Promise<void>;
-    readonly onCloseAndErrorNoStop?: (pl: LocalPl) => Promise<void>;
+type LocalPlOptions = {
+  /** From what directory start a process. */readonly workingDir: string; /** A string representation of yaml config. */
+  readonly config: string; /** How to get a binary, download it or get an existing one (default: download latest version) */
+  readonly plBinary?: PlBinarySource; /** Additional options for a process, environments, stdout, stderr etc. */
+  readonly spawnOptions?: SpawnOptions;
+  /**
+   * If the previous pl-core was started from the same directory,
+   * we can check if it's still running and then stop it before starting a new one.
+   * (default: true)
+   */
+  readonly closeOld?: boolean;
+  /**
+   * Proxy settings to use to fetch the binary and pass it down
+   * as a HTTPS_PROXY/HTTP_PROXY environment variable;
+   * Backend only supports Basic auth.
+   */
+  readonly proxy?: ProxySettings;
+  readonly onClose?: (pl: LocalPl) => Promise<void>;
+  readonly onError?: (pl: LocalPl) => Promise<void>;
+  readonly onCloseAndError?: (pl: LocalPl) => Promise<void>;
+  readonly onCloseAndErrorNoStop?: (pl: LocalPl) => Promise<void>;
 };
-export type LocalPlOptionsFull = Required<LocalPlOptions, "plBinary" | "spawnOptions" | "closeOld">;
+type LocalPlOptionsFull = Required<LocalPlOptions, "plBinary" | "spawnOptions" | "closeOld">;
 /**
  * Starts pl-core, if the option was provided downloads a binary, reads license environments etc.
  */
-export declare function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions): Promise<LocalPl>;
+declare function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions): Promise<LocalPl>;
 /** Gets default options for the whole init process
  * and overrides them with the provided options. */
-export declare function mergeDefaultOps(ops: LocalPlOptions, numCpu: number): LocalPlOptionsFull;
+declare function mergeDefaultOps(ops: LocalPlOptions, numCpu: number): LocalPlOptionsFull;
 /** Gets default options for a platforma local binary
  * and overrides them with the provided options. */
-export declare function plProcessOps(binaryPath: any, configPath: string, ops: LocalPlOptionsFull, workDir: string, defaultEnv: Record<string, string | undefined>): ProcessOptions;
+declare function plProcessOps(binaryPath: any, configPath: string, ops: LocalPlOptionsFull, workDir: string, defaultEnv: Record<string, string | undefined>): ProcessOptions;
+//#endregion
+export { LocalConfigYaml, LocalPl, LocalPlOptions, LocalPlOptionsFull, localPlatformaInit, mergeDefaultOps, plProcessOps };
 //# sourceMappingURL=pl.d.ts.map

package/dist/local/pl.js

@@ -1,221 +1,209 @@
-import { processStop, processWaitStopped, isProcessAlive, processRun } from './process.js';
-import { newDefaultPlBinarySource, resolveLocalPlBinaryPath } from '../common/pl_binary.js';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import { filePid, writePid, readPid } from './pid.js';
-import { withTrace } from './trace.js';
-import upath from 'upath';
-import fsp from 'node:fs/promises';
-import * as os from 'node:os';
-import { defaultHttpDispatcher } from '@milaboratories/pl-http';
-import { parseHttpAuth } from '@milaboratories/pl-model-common';
+import { isProcessAlive, processRun, processStop, processWaitStopped } from "./process.js";
+import { newDefaultPlBinarySource, resolveLocalPlBinaryPath } from "../common/pl_binary.js";
+import { filePid, readPid, writePid } from "./pid.js";
+import { withTrace } from "./trace.js";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import fsp from "node:fs/promises";
+import upath from "upath";
+import * as os$1 from "node:os";
+import { defaultHttpDispatcher } from "@milaboratories/pl-http";
+import { parseHttpAuth } from "@milaboratories/pl-model-common";
 
+//#region src/local/pl.ts
 const LocalConfigYaml = "config-local.yaml";
 /**
- * Represents a local running pl-core,
- * and has methods to start, check if it's running, stop and wait for stopping it.
- * Also, a hook on pl-core closed can be provided.
- */
-class LocalPl {
-    logger;
-    workingDir;
-    startOptions;
-    initialStartHistory;
-    onClose;
-    onError;
-    onCloseAndError;
-    onCloseAndErrorNoStop;
-    instance;
-    pid;
-    nRuns = 0;
-    lastRunHistory = {};
-    wasStopped = false;
-    constructor(logger, workingDir, startOptions, initialStartHistory, onClose, onError, onCloseAndError, onCloseAndErrorNoStop) {
-        this.logger = logger;
-        this.workingDir = workingDir;
-        this.startOptions = startOptions;
-        this.initialStartHistory = initialStartHistory;
-        this.onClose = onClose;
-        this.onError = onError;
-        this.onCloseAndError = onCloseAndError;
-        this.onCloseAndErrorNoStop = onCloseAndErrorNoStop;
-    }
-    async start() {
-        await withTrace(this.logger, async (trace, t) => {
-            this.wasStopped = false;
-            const instance = processRun(this.logger, this.startOptions);
-            instance.on("error", (e) => {
-                this.logger.error(`error '${e}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`);
-                // keep in mind there are no awaits here, it will be asynchronous
-                if (this.onError !== undefined)
-                    void this.onError(this);
-                if (this.onCloseAndError !== undefined)
-                    void this.onCloseAndError(this);
-                if (this.onCloseAndErrorNoStop !== undefined && !this.wasStopped)
-                    void this.onCloseAndErrorNoStop(this);
-            });
-            instance.on("close", () => {
-                this.logger.warn(`platforma was closed, started opts: ${JSON.stringify(this.debugInfo())}`);
-                // keep in mind there are no awaits here, it will be asynchronous
-                if (this.onClose !== undefined)
-                    void this.onClose(this);
-                if (this.onCloseAndError !== undefined)
-                    void this.onCloseAndError(this);
-                if (this.onCloseAndErrorNoStop !== undefined && !this.wasStopped)
-                    void this.onCloseAndErrorNoStop(this);
-            });
-            trace("started", true);
-            const pidFile = trace("pidFile", filePid(this.workingDir));
-            trace("pid", notEmpty(instance.pid));
-            trace("pidWritten", await writePid(pidFile, notEmpty(instance.pid)));
-            this.nRuns++;
-            this.instance = instance;
-            this.pid = instance.pid;
-            this.lastRunHistory = t;
-        });
-    }
-    stop() {
-        // TODO use this.instance to stop the process
-        this.wasStopped = true;
-        processStop(notEmpty(this.pid));
-    }
-    async waitStopped() {
-        await processWaitStopped(notEmpty(this.pid), 15000);
-    }
-    stopped() {
-        return this.wasStopped;
-    }
-    async isAlive() {
-        return await isProcessAlive(notEmpty(this.pid));
-    }
-    debugInfo() {
-        return {
-            lastRunHistory: this.lastRunHistory,
-            nRuns: this.nRuns,
-            pid: this.pid,
-            workingDir: this.workingDir,
-            initialStartHistory: this.initialStartHistory,
-            wasStopped: this.wasStopped,
-        };
-    }
-}
+* Represents a local running pl-core,
+* and has methods to start, check if it's running, stop and wait for stopping it.
+* Also, a hook on pl-core closed can be provided.
+*/
+var LocalPl = class {
+	instance;
+	pid;
+	nRuns = 0;
+	lastRunHistory = {};
+	wasStopped = false;
+	constructor(logger, workingDir, startOptions, initialStartHistory, onClose, onError, onCloseAndError, onCloseAndErrorNoStop) {
+		this.logger = logger;
+		this.workingDir = workingDir;
+		this.startOptions = startOptions;
+		this.initialStartHistory = initialStartHistory;
+		this.onClose = onClose;
+		this.onError = onError;
+		this.onCloseAndError = onCloseAndError;
+		this.onCloseAndErrorNoStop = onCloseAndErrorNoStop;
+	}
+	async start() {
+		await withTrace(this.logger, async (trace, t) => {
+			this.wasStopped = false;
+			const instance = processRun(this.logger, this.startOptions);
+			instance.on("error", (e) => {
+				this.logger.error(`error '${e}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`);
+				if (this.onError !== void 0) this.onError(this);
+				if (this.onCloseAndError !== void 0) this.onCloseAndError(this);
+				if (this.onCloseAndErrorNoStop !== void 0 && !this.wasStopped) this.onCloseAndErrorNoStop(this);
+			});
+			instance.on("close", () => {
+				this.logger.warn(`platforma was closed, started opts: ${JSON.stringify(this.debugInfo())}`);
+				if (this.onClose !== void 0) this.onClose(this);
+				if (this.onCloseAndError !== void 0) this.onCloseAndError(this);
+				if (this.onCloseAndErrorNoStop !== void 0 && !this.wasStopped) this.onCloseAndErrorNoStop(this);
+			});
+			trace("started", true);
+			const pidFile = trace("pidFile", filePid(this.workingDir));
+			trace("pid", notEmpty(instance.pid));
+			trace("pidWritten", await writePid(pidFile, notEmpty(instance.pid)));
+			this.nRuns++;
+			this.instance = instance;
+			this.pid = instance.pid;
+			this.lastRunHistory = t;
+		});
+	}
+	stop() {
+		this.wasStopped = true;
+		processStop(notEmpty(this.pid));
+	}
+	async waitStopped() {
+		await processWaitStopped(notEmpty(this.pid), 15e3);
+	}
+	stopped() {
+		return this.wasStopped;
+	}
+	async isAlive() {
+		return await isProcessAlive(notEmpty(this.pid));
+	}
+	debugInfo() {
+		return {
+			lastRunHistory: this.lastRunHistory,
+			nRuns: this.nRuns,
+			pid: this.pid,
+			workingDir: this.workingDir,
+			initialStartHistory: this.initialStartHistory,
+			wasStopped: this.wasStopped
+		};
+	}
+};
 /**
- * Starts pl-core, if the option was provided downloads a binary, reads license environments etc.
- */
+* Starts pl-core, if the option was provided downloads a binary, reads license environments etc.
+*/
 async function localPlatformaInit(logger, _ops) {
-    // filling-in default values
-    // Backend could consume a lot of CPU power,
-    // we want to keep at least a couple for UI and other apps to work.
-    const numCpu = Math.max(os.cpus().length - 2, 1);
-    const ops = mergeDefaultOps(_ops, numCpu);
-    return await withTrace(logger, async (trace, t) => {
-        trace("startOptions", { ...ops, config: "too wordy" });
-        const workDir = upath.resolve(ops.workingDir);
-        if (ops.closeOld) {
-            trace("closeOld", await localPlatformaReadPidAndStop(logger, workDir));
-        }
-        const configPath = upath.join(workDir, LocalConfigYaml);
-        logger.info(`writing configuration '${configPath}'...`);
-        await fsp.writeFile(configPath, ops.config);
-        const plBinPath = upath.join(workDir, "binaries");
-        const baseBinaryPath = await resolveLocalPlBinaryPath({
-            logger,
-            downloadDir: plBinPath,
-            src: ops.plBinary,
-            dispatcher: defaultHttpDispatcher(ops.proxy),
-        });
-        const binaryPath = trace("binaryPath", upath.join("binaries", baseBinaryPath));
-        const env = { ...process.env };
-        if (ops.proxy?.url) {
-            const url = new URL(ops.proxy.url);
-            if (ops.proxy.auth) {
-                const parsed = parseHttpAuth(ops.proxy.auth);
-                if (parsed.scheme !== "Basic") {
-                    throw new Error(`\
+	const ops = mergeDefaultOps(_ops, Math.max(os$1.cpus().length - 2, 1));
+	return await withTrace(logger, async (trace, t) => {
+		trace("startOptions", {
+			...ops,
+			config: "too wordy"
+		});
+		const workDir = upath.resolve(ops.workingDir);
+		if (ops.closeOld) trace("closeOld", await localPlatformaReadPidAndStop(logger, workDir));
+		const configPath = upath.join(workDir, LocalConfigYaml);
+		logger.info(`writing configuration '${configPath}'...`);
+		await fsp.writeFile(configPath, ops.config);
+		const baseBinaryPath = await resolveLocalPlBinaryPath({
+			logger,
+			downloadDir: upath.join(workDir, "binaries"),
+			src: ops.plBinary,
+			dispatcher: defaultHttpDispatcher(ops.proxy)
+		});
+		const binaryPath = trace("binaryPath", upath.join("binaries", baseBinaryPath));
+		const env = { ...process.env };
+		if (ops.proxy?.url) {
+			const url = new URL(ops.proxy.url);
+			if (ops.proxy.auth) {
+				const parsed = parseHttpAuth(ops.proxy.auth);
+				if (parsed.scheme !== "Basic") throw new Error(`\
 Unsupported auth scheme: ${parsed.scheme}. \
 Only Basic auth is supported by the backend.`);
-                }
-                url.username = parsed.username;
-                url.password = parsed.password;
-            }
-            env.http_proxy = url.toString();
-            env.https_proxy = url.toString();
-        }
-        const processOpts = plProcessOps(binaryPath, configPath, ops, workDir, env);
-        trace("processOpts", {
-            cmd: processOpts.cmd,
-            args: processOpts.args,
-            cwd: processOpts.opts.cwd,
-        });
-        const pl = new LocalPl(logger, ops.workingDir, processOpts, t, ops.onClose, ops.onError, ops.onCloseAndError, ops.onCloseAndErrorNoStop);
-        await pl.start();
-        return pl;
-    });
+				url.username = parsed.username;
+				url.password = parsed.password;
+			}
+			env.http_proxy = url.toString();
+			env.https_proxy = url.toString();
+		}
+		const processOpts = plProcessOps(binaryPath, configPath, ops, workDir, env);
+		trace("processOpts", {
+			cmd: processOpts.cmd,
+			args: processOpts.args,
+			cwd: processOpts.opts.cwd
+		});
+		const pl = new LocalPl(logger, ops.workingDir, processOpts, t, ops.onClose, ops.onError, ops.onCloseAndError, ops.onCloseAndErrorNoStop);
+		await pl.start();
+		return pl;
+	});
 }
 /** Reads a pid of the old pl-core if it was started in the same working directory,
- * and closes it. */
+* and closes it. */
 async function localPlatformaReadPidAndStop(logger, workingDir) {
-    return await withTrace(logger, async (trace, t) => {
-        const file = trace("pidFilePath", filePid(workingDir));
-        const oldPid = trace("pid", await readPid(file));
-        const alive = trace("wasAlive", await isProcessAlive(oldPid));
-        if (oldPid !== undefined && alive) {
-            trace("stopped", processStop(oldPid));
-            try {
-                trace("waitStopped", await processWaitStopped(oldPid, 15_000)); // larger, that 10s we provide to backend in config.
-            }
-            catch {
-                trace("forceStopped", processStop(oldPid, true));
-                trace("waitForceStopped", await processWaitStopped(oldPid, 5_000));
-            }
-        }
-        return t;
-    });
+	return await withTrace(logger, async (trace, t) => {
+		const oldPid = trace("pid", await readPid(trace("pidFilePath", filePid(workingDir))));
+		const alive = trace("wasAlive", await isProcessAlive(oldPid));
+		if (oldPid !== void 0 && alive) {
+			trace("stopped", processStop(oldPid));
+			try {
+				trace("waitStopped", await processWaitStopped(oldPid, 15e3));
+			} catch {
+				trace("forceStopped", processStop(oldPid, true));
+				trace("waitForceStopped", await processWaitStopped(oldPid, 5e3));
+			}
+		}
+		return t;
+	});
 }
 /** Gets default options for the whole init process
- * and overrides them with the provided options. */
+* and overrides them with the provided options. */
 function mergeDefaultOps(ops, numCpu) {
-    const result = {
-        plBinary: newDefaultPlBinarySource(),
-        spawnOptions: {
-            env: {
-                GOMAXPROCS: String(numCpu),
-            },
-        },
-        closeOld: true,
-    };
-    if (ops.spawnOptions?.env) {
-        result.spawnOptions.env = { ...result.spawnOptions.env, ...ops.spawnOptions.env };
-    }
-    if (ops.spawnOptions) {
-        const withoutEnv = { ...ops.spawnOptions };
-        delete withoutEnv["env"];
-        result.spawnOptions = { ...result.spawnOptions, ...withoutEnv };
-    }
-    const withoutSpawnOps = { ...ops };
-    delete withoutSpawnOps["spawnOptions"];
-    return { ...result, ...withoutSpawnOps };
+	const result = {
+		plBinary: newDefaultPlBinarySource(),
+		spawnOptions: { env: { GOMAXPROCS: String(numCpu) } },
+		closeOld: true
+	};
+	if (ops.spawnOptions?.env) result.spawnOptions.env = {
+		...result.spawnOptions.env,
+		...ops.spawnOptions.env
+	};
+	if (ops.spawnOptions) {
+		const withoutEnv = { ...ops.spawnOptions };
+		delete withoutEnv["env"];
+		result.spawnOptions = {
+			...result.spawnOptions,
+			...withoutEnv
+		};
+	}
+	const withoutSpawnOps = { ...ops };
+	delete withoutSpawnOps["spawnOptions"];
+	return {
+		...result,
+		...withoutSpawnOps
+	};
 }
 /** Gets default options for a platforma local binary
- * and overrides them with the provided options. */
+* and overrides them with the provided options. */
 function plProcessOps(binaryPath, configPath, ops, workDir, defaultEnv) {
-    const result = {
-        cmd: binaryPath,
-        args: ["--config", configPath],
-        opts: {
-            env: { ...defaultEnv },
-            cwd: workDir,
-            stdio: ["pipe", "ignore", "inherit"],
-            windowsHide: true, // hide a terminal on Windows
-        },
-    };
-    if (ops.spawnOptions?.env) {
-        result.opts.env = { ...result.opts.env, ...ops.spawnOptions.env };
-    }
-    const withoutEnv = { ...ops.spawnOptions };
-    delete withoutEnv["env"];
-    result.opts = { ...result.opts, ...withoutEnv };
-    return result;
+	const result = {
+		cmd: binaryPath,
+		args: ["--config", configPath],
+		opts: {
+			env: { ...defaultEnv },
+			cwd: workDir,
+			stdio: [
+				"pipe",
+				"ignore",
+				"inherit"
+			],
+			windowsHide: true
+		}
+	};
+	if (ops.spawnOptions?.env) result.opts.env = {
+		...result.opts.env,
+		...ops.spawnOptions.env
+	};
+	const withoutEnv = { ...ops.spawnOptions };
+	delete withoutEnv["env"];
+	result.opts = {
+		...result.opts,
+		...withoutEnv
+	};
+	return result;
 }
 
+//#endregion
 export { LocalConfigYaml, LocalPl, localPlatformaInit, mergeDefaultOps, plProcessOps };
-//# sourceMappingURL=pl.js.map
+//# sourceMappingURL=pl.js.map