tnp-helpers 19.0.65 → 19.0.67

package/lib/base/classes/base-cli-worker/base-cli-worker.js

@@ -1,66 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCliWorker = void 0;
-const lib_1 = require("tnp-core/lib");
+//#region imports
+const rxjs_1 = require("rxjs");
+const lib_1 = require("tnp-config/lib");
+const lib_2 = require("tnp-core/lib");
 const index_1 = require("../../../index");
 const base_cli_worker_config_1 = require("./base-cli-worker-config");
 const base_cli_worker_terminal_ui_1 = require("./base-cli-worker-terminal-ui");
+const base_cli_worker_models_1 = require("./base-cli-worker.models");
+const base_cli_worker_utils_1 = require("./base-cli-worker.utils");
 //#endregion
 //#region constants
 const WORKER_INIT_START_TIME_LIMIT = 25; // 15 seconds max to start worker
 const START_PORT_FOR_SERVICES = 3600;
-//#endregion
 class BaseCliWorker {
     serviceID;
     startCommand;
     serviceVersion;
+    /**
+     * Indicates if worker is part of cloud
+     * and should use cloud ip address
+     */
+    static isCloudEnable = new rxjs_1.BehaviorSubject(false);
+    /**
+     * Cloud ip address of the worker (if part of cloud)
+     */
+    static cloudIp = new rxjs_1.BehaviorSubject(null);
+    static workers = new Map();
     //#region fields & getters
-    SPECIAL_WORKER_READY_MESSAGE = lib_1.CoreModels.SPECIAL_WORKER_READY_MESSAGE;
+    SPECIAL_WORKER_READY_MESSAGE = lib_2.CoreModels.SPECIAL_WORKER_READY_MESSAGE;
+    /**
+     * dependency workers that should be started before this worker
+     */
+    dependencyWorkers = new Map();
     // @ts-ignore TODO weird inheritance problem
     terminalUI = new base_cli_worker_terminal_ui_1.BaseCliWorkerTerminalUI(this);
     workerContextTemplate;
-    workerMainContext;
-    // private workerRemoteContextFor: {
-    //   [ipAddressOfTaonInstance: string]: ReturnType<typeof Taon.createContext>;
-    // } = {};
-    async getRemoteControllerFor(ipAddressOfTaonInstance, port) {
-        // this.workerRemoteContextFor[ipAddressOfTaonInstance] = remoteCtx;
-        const useHttps = ipAddressOfTaonInstance !== lib_1.CoreModels.localhostIp127;
-        const protocol = useHttps ? 'https' : 'http';
-        const remoteCtx = this.workerContextTemplate().cloneAsRemote({
-            overrideRemoteHost: `${protocol}://${ipAddressOfTaonInstance}${port ? `:${port}` : ''}`,
-        });
-        const contextForRemoteConnection = await remoteCtx.initialize();
-        const taonProjectsController = contextForRemoteConnection.getInstanceBy(this.controllerClass);
-        return taonProjectsController;
+    /**
+     * Name of the worker context
+     */
+    get contextName() {
+        return this.workerContextTemplate().contextName;
     }
-    workerRemoteContext;
-    controllerClass;
-    contextForRemoteConnection;
-    //#region fields & getters / path to process local info
-    get pathToProcessLocalInfoJson() {
-        //#region @backendFunc
-        // console.log('os.userInfo()', os.userInfo());
-        return (0, lib_1.crossPlatformPath)([
-            lib_1.UtilsOs.getRealHomeDir(),
-            `.taon`,
-            '__workers-service-process-info__',
-            `${this.serviceID}.json`,
-        ]);
-        //#endregion
+    /**
+     * Port where worker is running
+     * (getter only accessible from host machine)
+     */
+    get port() {
+        return this.processLocalInfoObj.port;
     }
-    //#endregion
-    //#region fields & getters / process local info json object
-    get processLocalInfoObj() {
+    getWorkerInfoGuiUrl(options) {
         //#region @backendFunc
-        const configJson = index_1.Helpers.readJson5(this.pathToProcessLocalInfoJson) || {};
-        if (lib_1._.isObject(configJson)) {
-            return lib_1._.merge(new base_cli_worker_config_1.BaseCliWorkerConfig(), configJson);
+        options = options || {};
+        options.domain = options.domain || lib_2.CoreModels.localhostDomain;
+        options.useHttps = lib_2._.isBoolean(options.useHttps) ? options.useHttps : false;
+        // console.log({
+        //   isCloudEnable: BaseCliWorker.isCloudEnable.getValue(),
+        //   cloudIp: BaseCliWorker.cloudIp.getValue(),
+        // })
+        if (BaseCliWorker.isCloudEnable.getValue()) {
+            options.domain = BaseCliWorker.cloudIp.getValue();
+            options.useHttps = true;
+            options.port = null;
         }
-        return new base_cli_worker_config_1.BaseCliWorkerConfig();
+        return (`${options.useHttps ? 'https' : 'http'}://${options.domain}` +
+            `${!lib_2._.isUndefined(options.port)
+                ? `${options.port === null ? '' : `:${options.port}`}`
+                : `:${this.processLocalInfoObj.port}`}` +
+            `/api/${this.workerContextTemplate().contextName}` +
+            `/${'info'}`);
         //#endregion
     }
-    //#endregion
+    controllerClass;
     //#endregion
     //#region constructor
     constructor(
@@ -79,85 +91,35 @@ class BaseCliWorker {
         this.serviceID = serviceID;
         this.startCommand = startCommand;
         this.serviceVersion = serviceVersion;
+        BaseCliWorker.workers.set(this.serviceID, this);
     }
     //#endregion
-    //#region methods / start normally in current process
-    /**
-     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
-     * for production use startDetachedIfNeedsToBeStarted()
-     * start normally process
-     * this will crash if process already started
-     */
-    async startNormallyInCurrentProcess(options) {
+    //#region public
+    static getAllWorkersStartedInSystemFromCurrentCli() {
         //#region @backendFunc
-        options = options || {};
-        index_1.Helpers.taskStarted(`[${this.serviceID}] Process start in current process...`);
-        await this.killWorkerWithLowerVersion();
-        await this.preventStartIfAlreadyStarted();
-        const port = await this.getServicePort();
-        this.workerMainContext = this.workerContextTemplate().cloneAsNormal({
-            overrideHost: `http://localhost:${port}`,
-        });
-        await this.workerMainContext.initialize();
-        await this.initializeWorkerMetadata();
-        index_1.Helpers.info(`Service started !`);
-        this.preventExternalConfigChange();
-        if (lib_1._.isFunction(options.actionBeforeTerminalUI)) {
-            await options.actionBeforeTerminalUI();
-        }
-        this.terminalUI.displaySpecialWorkerReadyMessage();
-        await this.terminalUI.infoScreen();
+        return Array.from(BaseCliWorker.workers.values());
         //#endregion
     }
-    //#endregion
-    //#region methods / get controller for remote connection
-    async getControllerForRemoteConnection(options) {
+    //#region public fields & getters / process local info json object
+    get processLocalInfoObj() {
         //#region @backendFunc
-        options = options || {};
-        // ! TODO this waiting is called for every generated port in app.host.ts
-        // ! this may be expensive in future
-        // if (!options.skipWaitingForWorkerProcessPortToBeSaved) {
-        await this.waitForProcessPortSavedToDisk(options);
-        // }
-        if (this.contextForRemoteConnection &&
-            !lib_1._.isNaN(this.contextForRemoteConnection.port) &&
-            !lib_1._.isNaN(this.processLocalInfoObj.port) &&
-            this.contextForRemoteConnection.port !== this.processLocalInfoObj.port) {
-            index_1.Helpers.logInfo('Destroying old context for remote connection...');
-            // debugger;
-            await this.contextForRemoteConnection.destroy();
-            delete this.contextForRemoteConnection;
-        }
-        if (!this.contextForRemoteConnection) {
-            index_1.Helpers.logInfo('Creating new context for remote connection...');
-            this.workerRemoteContext = this.workerContextTemplate().cloneAsRemote({
-                overrideRemoteHost: `http://localhost:${this.processLocalInfoObj.port}`,
-            });
-            this.contextForRemoteConnection =
-                await this.workerRemoteContext.initialize();
+        const configJson = index_1.Helpers.readJson5(this.pathToProcessLocalInfoJson) || {};
+        if (lib_2._.isObject(configJson)) {
+            return lib_2._.merge(new base_cli_worker_config_1.BaseCliWorkerConfig(), configJson);
         }
-        const taonProjectsController = this.contextForRemoteConnection.getInstanceBy(this.controllerClass);
-        return taonProjectsController;
+        return new base_cli_worker_config_1.BaseCliWorkerConfig();
         //#endregion
     }
     //#endregion
-    //#region public methods / start if needs to be started
-    async startDetachedIfNeedsToBeStarted(options) {
-        //#region @backendFunc
-        if (this.processLocalInfoObj.isEmpty) {
-            // not started ever yet
-            await this.startDetached(options);
-            return;
-        }
-        const serviceIsHealthy = await this.isServiceHealthy({
-            healthCheckRequestTrys: 1, // just quick check
-        });
-        if (!serviceIsHealthy) {
-            await this.startDetached(options);
-            return;
-        }
-        index_1.Helpers.log(`Service "${this.serviceID}" is already started/healthy...`);
-        //#endregion
+    //#region public methods / get remote controller
+    async getRemoteControllerFor(options) {
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        const remoteEndpointContext = await this.getRemoteContextFor(options);
+        const taonProjectsController = remoteEndpointContext.getInstanceBy(options.controllerClass
+            ? options.controllerClass
+            : this.controllerClass);
+        return taonProjectsController;
     }
     //#endregion
     //#region public methods / kill
@@ -167,19 +129,31 @@ class BaseCliWorker {
     async kill(options) {
         //#region @backendFunc
         options = options || {};
-        index_1.Helpers.log(`Killing service "${this.serviceID}"...`);
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (this.dependencyWorkers.size > 0) {
+            for (const [serviceId, worker] of this.dependencyWorkers) {
+                index_1.Helpers.info(`Killing dependency worker "${serviceId}"...`);
+                await worker.kill({
+                    methodOptions: options.methodOptions,
+                    dontRemoveConfigFile: options.dontRemoveConfigFile,
+                });
+            }
+        }
+        index_1.Helpers.info(`Killing service "${this.serviceID}"...`);
         if (this.processLocalInfoObj.isEmpty) {
             index_1.Helpers.log(`Service "${this.serviceID}" not started - nothing to kill...`);
             return;
         }
-        const ctrl = await this.getControllerForRemoteConnection({
-            calledFrom: 'kill',
+        const ctrl = await this.getRemoteControllerFor({
+            methodOptions: options.methodOptions.clone(opt => {
+                opt.calledFrom = `${opt.calledFrom}.kill`;
+                return opt;
+            }),
         });
         try {
-            if (!options.dontRemoveConfigFile) {
-                index_1.Helpers.removeFileIfExists(this.pathToProcessLocalInfoJson);
-            }
-            await ctrl.baseCLiWorkerCommand_kill().request();
+            await ctrl
+                .baseCLiWorkerCommand_kill(options.dontRemoveConfigFile)
+                .request();
             index_1.Helpers.log(`Service "${this.serviceID}" killed...`);
         }
         catch (error) {
@@ -196,16 +170,23 @@ class BaseCliWorker {
      */
     async restart(options) {
         options = options || {};
-        options.detached = lib_1._.isUndefined(options.detached) ? true : false;
-        await this.kill();
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        await this.kill({
+            methodOptions: options.methodOptions,
+        });
         //longer because os is disposing process previous process
-        if (options.detached) {
-            index_1.Helpers.info(`Restarting service "${this.serviceID}" in detached mode...`);
-            await this.startDetached(options);
+        index_1.Helpers.info(`Restarting service "${this.serviceID}" ` +
+            `in ${options.methodOptions.cliParams.mode} mode...`);
+        if (options.methodOptions.cliParams.mode ===
+            base_cli_worker_models_1.BaseCLiWorkerStartMode.IN_CURRENT_PROCESS) {
+            await this.startNormallyInCurrentProcess({
+                methodOptions: options.methodOptions,
+            });
         }
         else {
-            index_1.Helpers.info(`Restarting service "${this.serviceID}" in current process...`);
-            await this.startNormallyInCurrentProcess();
+            await this.startDetached({
+                methodOptions: options.methodOptions,
+            });
         }
     }
     //#endregion
@@ -214,50 +195,212 @@ class BaseCliWorker {
      * only for cli start
      * @param cliParams on from cli
      */
-    async cliStartProcedure(cliParams) {
-        const detached = !!cliParams['detached'] || !!cliParams['detach'];
+    async cliStartProcedure(options) {
         //#region @backendFunc
-        if (cliParams['restart']) {
+        options = options || {};
+        const methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (methodOptions.cliParams.restart) {
             index_1.Helpers.logInfo(`--- RESTARTING ----`);
             await this.restart({
-                detached,
+                methodOptions,
             });
             process.exit(0);
         }
-        if (cliParams['kill']) {
-            await this.kill();
+        if (methodOptions.cliParams.kill) {
+            await this.kill({
+                methodOptions,
+            });
             process.exit(0);
         }
-        if (detached) {
-            await this.startDetachedIfNeedsToBeStarted();
-            process.exit(0);
+        if (options.methodOptions.cliParams.mode ===
+            base_cli_worker_models_1.BaseCLiWorkerStartMode.IN_CURRENT_PROCESS) {
+            await this.startNormallyInCurrentProcess({
+                methodOptions,
+            });
         }
         else {
-            await this.startNormallyInCurrentProcess();
+            await this.startDetachedIfNeedsToBeStarted({
+                methodOptions,
+            });
         }
+        const controller = await this.getRemoteControllerFor({
+            methodOptions: methodOptions.clone(opt => {
+                opt.calledFrom = `${opt.calledFrom}.cliStartProcedure`;
+                return opt;
+            }),
+        });
+        return { controller, worker: this, serviceId: this.serviceID };
         //#endregion
     }
     //#endregion
-    //#region prevent external config change
+    //#endregion
+    //#region protected
+    //#region protected methods / get remote context
+    async getRemoteContextFor(options) {
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        const ipAddressOfTaonInstance = options.methodOptions.connectionOptions.ipAddressOfTaonInstance ||
+            lib_2.CoreModels.localhostDomain;
+        // on localhost read data from  processLocalInfoObj json
+        let port = options.methodOptions.connectionOptions.port ||
+            this.processLocalInfoObj.port;
+        if (ipAddressOfTaonInstance === lib_2.CoreModels.localhostDomain && !port) {
+            if (this.workerIsStarting) {
+                try {
+                    await this.waitForProcessPortSavedToDisk({
+                        methodOptions: options.methodOptions.clone(opt => {
+                            opt.calledFrom = `${opt.calledFrom}.getRemoteContextFor.localhost`;
+                            return opt;
+                        }),
+                    });
+                }
+                catch (error) {
+                    console.error(`[getRemoteContextFor] Error while waiting for process port saved to disk`);
+                }
+            }
+            if (this.processLocalInfoPortNotInited) {
+                throw new Error(`Can't connect to remote context on localhost - port is not defined.
+        This can happen when the worker process is not started yet.
+      `);
+            }
+            else {
+                port = this.processLocalInfoObj.port;
+            }
+        }
+        // this.workerRemoteContextFor[ipAddressOfTaonInstance] = remoteCtx;
+        const useHttps = ipAddressOfTaonInstance !== lib_2.CoreModels.localhostDomain &&
+            ipAddressOfTaonInstance !== lib_2.CoreModels.localhostIp127;
+        const protocol = useHttps ? 'https' : 'http';
+        const overrideRemoteHost = `${protocol}://${ipAddressOfTaonInstance}${port ? `:${port}` : ''}`;
+        const remoteCtx = this.workerContextTemplate().cloneAsRemote({
+            overrideRemoteHost,
+        });
+        // @LAST chache remote context per ipAddressOfTaonInstance
+        const remoteEndpoitnContext = await remoteCtx.initialize();
+        return remoteEndpoitnContext;
+    }
+    //#endregion
+    //#region protected fields & getters / path to process local info
+    get pathToProcessLocalInfoJson() {
+        //#region @backendFunc
+        // console.log('os.userInfo()', os.userInfo());
+        return base_cli_worker_utils_1.BaseCliWorkerUtils.getPathToProcessLocalInfoJson(this.serviceID);
+        //#endregion
+    }
+    //#endregion
+    //#region protected fields & getters / should wait for process port saved to disk
+    get processLocalInfoPortNotInited() {
+        return (!this.processLocalInfoObj.port ||
+            isNaN(Number(this.processLocalInfoObj.port)));
+    }
+    //#endregion
+    //#region protected fields & getters / worker is starting
+    get workerIsStarting() {
+        return !!this.processLocalInfoObj.startTimestamp;
+    }
+    //#endregion
+    //#region protected methods / start if needs to be started
+    async startDetachedIfNeedsToBeStarted(options) {
+        //#region @backendFunc
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (this.processLocalInfoObj.isEmpty) {
+            // not started ever yet
+            await this.startDetached({
+                methodOptions: options.methodOptions,
+            });
+            return;
+        }
+        const serviceIsHealthy = await this.isServiceHealthy({
+            healthCheckRequestTrys: 1, // just quick check
+            methodOptions: options.methodOptions,
+        });
+        if (!serviceIsHealthy) {
+            await this.startDetached({
+                methodOptions: options.methodOptions,
+            });
+            return;
+        }
+        index_1.Helpers.log(`Service "${this.serviceID}" is already started/healthy...`);
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / start normally in current process
+    /**
+     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
+     * for production use startDetachedIfNeedsToBeStarted()
+     * start normally process
+     * this will crash if process already started
+     */
+    async startNormallyInCurrentProcess(options) {
+        //#region @backendFunc
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        index_1.Helpers.taskStarted(`[${this.serviceID}] Process start in current process...`);
+        await this.killWorkerWithLowerVersion({
+            methodOptions: options.methodOptions,
+        });
+        await this.preventStartIfAlreadyStarted({
+            methodOptions: options.methodOptions,
+        });
+        const port = await this.getServicePort();
+        this.saveProcessInfo({
+            port,
+            serviceID: this.serviceID,
+            pid: process.pid,
+            startTimestamp: Date.now(),
+            version: this.serviceVersion,
+        });
+        const workerMainContext = this.workerContextTemplate().cloneAsNormal({
+            overrideHost: `http://localhost:${port}`,
+        });
+        await workerMainContext.initialize();
+        await this.initializeWorkerMetadata({
+            methodOptions: options.methodOptions,
+        });
+        index_1.Helpers.info(`Service started !`);
+        this.preventExternalConfigChange();
+        if (lib_2._.isFunction(options.actionBeforeTerminalUI)) {
+            await options.actionBeforeTerminalUI();
+        }
+        if (this.terminalUI) {
+            this.terminalUI.displaySpecialWorkerReadyMessage();
+            await this.terminalUI.infoScreen();
+        }
+        else {
+            console.log(`
+      [${lib_1.config.frameworkName}-helpers] No terminal UI configured. Not displaying anything.
+      `);
+        }
+        //#endregion
+    }
+    //#endregion
+    //#region protected methods / prevent external config change
     preventExternalConfigChange() {
         //#region @backendFunc
         index_1.Helpers.info(`watching: ${this.pathToProcessLocalInfoJson}`);
         const currentConfig = this.processLocalInfoObj;
-        lib_1.chokidar.watch(this.pathToProcessLocalInfoJson).on('change', () => {
+        lib_2.chokidar.watch(this.pathToProcessLocalInfoJson).on('change', () => {
             index_1.Helpers.log(`Service data changed...`);
             if (!this.processLocalInfoObj.isEquals(currentConfig)) {
-                lib_1.UtilsTerminal.clearConsole();
+                lib_2.UtilsTerminal.clearConsole();
                 index_1.Helpers.error(`Service config data externally changed... killing service`, false, true);
             }
         });
         //#endregion
     }
     //#endregion
-    //#region prevent prevent start if already started
-    async preventStartIfAlreadyStarted() {
+    //#region protected methods / prevent prevent start if already started
+    async preventStartIfAlreadyStarted(options) {
         //#region @backendFunc
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (!this.processLocalInfoObj.pid || this.processLocalInfoPortNotInited) {
+            return;
+        }
         try {
             const isHealthy = await this.isServiceHealthy({
+                methodOptions: options.methodOptions,
                 healthCheckRequestTrys: 2, // check only twice
             });
             if (isHealthy) {
@@ -268,18 +411,27 @@ class BaseCliWorker {
         //#endregion
     }
     //#endregion
-    //#region prevent kill worker with lower version
-    async killWorkerWithLowerVersion() {
+    //#region protected methods / prevent kill worker with lower version
+    async killWorkerWithLowerVersion(options) {
         //#region @backendFunc
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (!this.processLocalInfoObj.pid) {
+            index_1.Helpers.logInfo(`No pid found - skipping version check...`);
+            return;
+        }
         index_1.Helpers.taskStarted(`[${this.serviceID}] Checking if current working version is up to date...`);
         try {
-            const ctrl = await this.getControllerForRemoteConnection({
-                calledFrom: 'killWorkerWithLowerVersion',
+            const ctrl = await this.getRemoteControllerFor({
+                methodOptions: options.methodOptions.clone(opt => {
+                    opt.calledFrom = `${opt.calledFrom}.killWorkerWithLowerVersion`;
+                    return opt;
+                }),
             });
             index_1.Helpers.logInfo(`[${this.serviceID}] Checking if current working version is up to date...`);
             // console.log('this.processLocalInfoObj', this.processLocalInfoObj);
             const req = await ctrl
-                .baseCLiWorkerCommand_hasUpToDateVersion(lib_1._.merge(this.processLocalInfoObj, {
+                .baseCLiWorkerCommand_hasUpToDateVersion(lib_2._.merge(this.processLocalInfoObj, {
                 version: this.serviceVersion,
             }))
                 .request();
@@ -289,16 +441,19 @@ class BaseCliWorker {
                 index_1.Helpers.info(`[${this.serviceID}] Killing service with lower version...`);
                 await this.kill({
                     dontRemoveConfigFile: true,
+                    methodOptions: options.methodOptions,
                 });
-                await lib_1.UtilsTerminal.wait(1);
+                await lib_2.UtilsTerminal.wait(1);
             }
         }
-        catch (error) { }
+        catch (error) {
+            index_1.Helpers.logInfo(`Probably no need to kill worker with lower version`);
+        }
         index_1.Helpers.taskDone(`[${this.serviceID}] Current working version is up to date !`);
         //#endregion
     }
     //#endregion
-    //#region is service healthy
+    //#region protected methods / is service healthy
     /**
      * This has 2 purposes:
      * - infinite check when when detached process finished starting
@@ -307,13 +462,15 @@ class BaseCliWorker {
     async isServiceHealthy(options) {
         //#region @backendFunc
         options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
         const healthCheckRequestTrys = options.healthCheckRequestTrys || 1;
+        //#region timestamp checking
         let i = 0; // 15 seconds to start worker
         while (true) {
             i++;
-            index_1.Helpers.logInfo(`[${this.serviceID}][timestamp-checking] Checking if service "${this.serviceID}" is starting...`);
-            const workerIsStarting = !!this.processLocalInfoObj.startTimestamp;
-            if (!workerIsStarting) {
+            index_1.Helpers.logInfo(`[${this.serviceID}][timestamp-checking][${options.methodOptions.calledFrom}]
+         Checking if service "${this.serviceID}" is starting...`);
+            if (!this.workerIsStarting) {
                 // initialized worker does not have startTimestamp
                 break;
             }
@@ -327,15 +484,15 @@ class BaseCliWorker {
                 return false;
             }
             index_1.Helpers.log('[timestamp-checking] Waiting 500 miliseonds for service to start...');
-            await lib_1.UtilsTerminal.wait(1);
+            await lib_2.UtilsTerminal.wait(1);
         }
+        //#endregion
         i = 0;
-        const isWaitingNotCheckingWhen = 10;
+        const isWaitingNotCheckingWhen = 40;
         while (true) {
             i++;
             try {
-                // const isWaitingNotChecking = i >= isWaitingNotCheckingWhen;
-                // TODO: check why this is may not work
+                //#region initial message
                 if (isWaitingNotCheckingWhen === i) {
                     index_1.Helpers.info(`[${this.serviceID}] Waiting for service "${this.serviceID}" ` +
                         `to start...`);
@@ -344,14 +501,21 @@ class BaseCliWorker {
                     index_1.Helpers.log(`[${this.serviceID}] Checking if service "${this.serviceID}" ` +
                         `is healthy...`);
                 }
-                const ctrl = await this.getControllerForRemoteConnection({
-                    calledFrom: 'isServiceHealthy',
+                //#endregion
+                //#region request check
+                const ctrl = await this.getRemoteControllerFor({
+                    methodOptions: options.methodOptions.clone(opt => {
+                        opt.calledFrom = `${opt.calledFrom}.isServiceHealthy`;
+                        return opt;
+                    }),
                 });
                 index_1.Helpers.log(`Sending is healthy request...`);
                 // console.log('this.processLocalInfoObj', this.processLocalInfoObj);
                 const req = await ctrl
                     .baseCLiWorkerCommand_isHealthy(this.processLocalInfoObj)
-                    .request();
+                    .request({
+                // timeout: 1000,
+                });
                 const isHealthy = req.body.booleanValue;
                 // console.log('isHealthy', { isHealthy });
                 if (isHealthy) {
@@ -360,16 +524,13 @@ class BaseCliWorker {
                 else {
                     index_1.Helpers.log(`Service "${this.serviceID}" is not healthy (response is false)...`);
                 }
+                //#endregion
                 if (isHealthy || i === healthCheckRequestTrys) {
                     return isHealthy;
                 }
-                else {
-                    index_1.Helpers.log('Trying again...');
-                    await lib_1.UtilsTerminal.wait(1);
-                    continue;
-                }
             }
             catch (error) {
+                //#region error handling
                 if (i >= isWaitingNotCheckingWhen && error?.message) {
                     console.error(error.message);
                 }
@@ -377,26 +538,28 @@ class BaseCliWorker {
                 if (i === healthCheckRequestTrys) {
                     return false;
                 }
-                else {
-                    index_1.Helpers.log('Trying again...');
-                    await lib_1.UtilsTerminal.wait(1);
-                    continue;
-                }
+                //#endregion
             }
+            index_1.Helpers.log('Trying again...');
+            await lib_2.UtilsTerminal.wait(1);
         }
         //#endregion
     }
     //#endregion
-    //#region start detached
+    //#region protected methods / start detached
     /**
      * start if not started detached process
      */
     async startDetached(options) {
         //#region @backendFunc
         options = options || {};
-        if (options.useCurrentWindowForDetach) {
-            index_1.Helpers.logInfo(`[${this.serviceID}][startDetached]  Starting in current terminal "${lib_1.chalk.bold(this.startCommand)}"...`);
-            await lib_1.UtilsProcess.startAsyncChildProcessCommandUntil(this.startCommand, {
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        if (options.methodOptions.cliParams.mode ===
+            base_cli_worker_models_1.BaseCLiWorkerStartMode.CHILD_PROCESS) {
+            index_1.Helpers.logInfo(`[${this.serviceID}][startDetached] ` +
+                ` Starting in current terminal
+          "${lib_2.chalk.bold(this.startCommand)}"...`);
+            await lib_2.UtilsProcess.startAsyncChildProcessCommandUntil(this.startCommand, {
                 untilOptions: {
                     stdout: [this.SPECIAL_WORKER_READY_MESSAGE],
                     stderr: [this.SPECIAL_WORKER_READY_MESSAGE],
@@ -405,44 +568,52 @@ class BaseCliWorker {
             });
         }
         else {
-            index_1.Helpers.logInfo(`[${this.serviceID}][startDetached] Starting in new terminal "${lib_1.chalk.bold(this.startCommand)}"...`);
-            await lib_1.UtilsProcess.startInNewTerminalWindow(this.startCommand);
+            index_1.Helpers.logInfo(`[${this.serviceID}][startDetached] ` +
+                `Starting in new terminal
+          "${lib_2.chalk.bold(this.startCommand)}"...`);
+            await lib_2.UtilsProcess.startInNewTerminalWindow(this.startCommand);
         }
-        index_1.Helpers.logInfo(`"${lib_1.chalk.bold(this.serviceID)}" - waiting until healthy (Infinite health check trys )...`);
+        index_1.Helpers.logInfo(`"${lib_2.chalk.bold(this.serviceID)}" - waiting until healthy (Infinite health check trys )...`);
         const isServiceHealthy = await this.isServiceHealthy({
+            methodOptions: options.methodOptions,
             healthCheckRequestTrys: Infinity, // wait infinity until started
         });
         if (!isServiceHealthy) {
-            index_1.Helpers.throw(`Not able to start service "${this.serviceID}"...`);
-            return;
+            throw `Not able to start service "${this.serviceID}"...`;
         }
-        index_1.Helpers.logInfo(`Healthy service "${lib_1.chalk.bold(this.serviceID)}" started.`);
+        index_1.Helpers.logInfo(`Healthy service "${lib_2.chalk.bold(this.serviceID)}" started.`);
         //#endregion
     }
     //#endregion
-    //#region save process info
+    //#region protected methods / save process info
     saveProcessInfo(processConfig) {
         //#region @backendFunc
         processConfig = processConfig || {};
         if (index_1.Helpers.exists(this.pathToProcessLocalInfoJson)) {
             const jsonConfig = index_1.Helpers.readJson(this.pathToProcessLocalInfoJson);
-            if (lib_1._.isObject(jsonConfig) && Object.keys(jsonConfig).length > 0) {
-                processConfig = lib_1._.merge(jsonConfig, processConfig);
+            if (lib_2._.isObject(jsonConfig) && Object.keys(jsonConfig).length > 0) {
+                processConfig = lib_2._.merge(jsonConfig, processConfig);
             }
         }
         index_1.Helpers.log(`Saving process info to "${this.pathToProcessLocalInfoJson}"...`);
-        index_1.Helpers.log(processConfig);
+        // Helpers.log(processConfig);
+        processConfig.pathToFile = this.pathToProcessLocalInfoJson;
         index_1.Helpers.writeJson(this.pathToProcessLocalInfoJson, processConfig);
         //#endregion
     }
     //#endregion
-    //#region initialize worker
-    async initializeWorkerMetadata() {
+    //#region protected methods / initialize worker
+    async initializeWorkerMetadata(options) {
         //#region @backendFunc
+        options = options || {};
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
         while (true) {
             try {
-                const portControllerInstance = await this.getControllerForRemoteConnection({
-                    calledFrom: 'initializeWorkerMetadata',
+                const portControllerInstance = await this.getRemoteControllerFor({
+                    methodOptions: options.methodOptions.clone(opt => {
+                        opt.calledFrom = `${opt.calledFrom}.initializeWorkerMetadata`;
+                        return opt;
+                    }),
                 });
                 await portControllerInstance
                     .baseCLiWorkerCommand_initializeMetadata(this.serviceID, this.serviceVersion)
@@ -458,7 +629,7 @@ class BaseCliWorker {
                     startTimestamp: null,
                 });
                 index_1.Helpers.info(`[${this.serviceID}][${this.serviceVersion}] Retrying to initialize worker metadata...`);
-                await lib_1.UtilsTerminal.wait(1);
+                await lib_2.UtilsTerminal.wait(1);
             }
         }
         // process.on('SIGINT', () => {
@@ -467,51 +638,46 @@ class BaseCliWorker {
         //#endregion
     }
     //#endregion
-    //#region wait for process port saved to disk
+    //#region protected methods / wait for process port saved to disk
     async waitForProcessPortSavedToDisk(options) {
         //#region @backendFunc
         options = options || {};
-        index_1.Helpers.logInfo(`[${this.serviceID}]${options.calledFrom ? `[${options.calledFrom}]` : ''}` +
+        options.methodOptions = base_cli_worker_models_1.BaseCliMethodOptions.from(options.methodOptions);
+        index_1.Helpers.logInfo(`[${this.serviceID}][${[options.methodOptions.calledFrom]}]` +
             ` Waiting for process port saved to disk...`);
         index_1.Helpers.log(`in ${this.pathToProcessLocalInfoJson}`);
-        let portForRemote = this.processLocalInfoObj.port;
-        const MAX_TRYS = 10;
+        const MAX_TRYS = 30;
         let i = 0;
-        if (!portForRemote) {
-            while (!portForRemote) {
+        if (this.processLocalInfoPortNotInited) {
+            while (this.processLocalInfoPortNotInited) {
                 i++;
-                portForRemote = this.processLocalInfoObj.port;
-                if (portForRemote) {
-                    index_1.Helpers.taskDone(`[${this.serviceID}][${this.serviceVersion}] port assigned: ${portForRemote}`);
-                    break;
-                }
-                else {
-                    index_1.Helpers.logInfo(`[${this.serviceID}][${this.serviceVersion}] waiting/checking again for port...`);
+                if (this.processLocalInfoPortNotInited) {
+                    index_1.Helpers.logInfo(`[${this.serviceID}][${this.serviceVersion}][${options.methodOptions.calledFrom}]
+             waiting/checking again for port...`);
                     if (i > MAX_TRYS) {
-                        index_1.Helpers.throw(`Can't get port for remote connection..` +
-                            ` worker process did not start correctly`);
+                        throw `[${this.serviceID}][${this.serviceVersion}][${options.methodOptions.calledFrom}]
+              Can't get port for remote connection..
+              worker process did not start correctly`;
                     }
-                    await lib_1.UtilsTerminal.wait(1);
+                    await lib_2.UtilsTerminal.wait(1);
+                }
+                else {
+                    index_1.Helpers.taskDone(`[${this.serviceID}][${this.serviceVersion}][${options.methodOptions.calledFrom}]
+             port assigned: ${this.processLocalInfoObj.port}`);
+                    break;
                 }
             }
         }
         //#endregion
     }
     //#endregion
-    //#region get free port
+    //#region protected methods / get free port
     async getServicePort() {
         //#region @backendFunc
         index_1.Helpers.logInfo(`Getting free port for service...`);
-        const port = await lib_1.Utils.getFreePort({
+        const port = await lib_2.Utils.getFreePort({
             startFrom: START_PORT_FOR_SERVICES,
         });
-        this.saveProcessInfo({
-            port,
-            serviceID: this.serviceID,
-            pid: process.pid,
-            startTimestamp: Date.now(),
-            version: this.serviceVersion,
-        });
         index_1.Helpers.logInfo(`Done getting free port for service...`);
         return port;
         //#endregion