@winccoa-tools-pack/npm-winccoa-core 0.1.0-9176c0d

package/dist/esm/types/components/implementations/PmonComponent.js

@@ -0,0 +1,723 @@
+import { WinCCOAComponent } from '../WinCCOAComponent.js';
+import { ProjEnvPmonStatus } from '../../project/ProjEnvPmonStatus.js';
+import { ProjEnvManagerStartMode, ProjEnvManagerState, ProjEnvProjectState, startModeToString, } from '../../project/ProjEnv.js';
+export class PmonComponentCredential {
+    constructor(username, password) {
+        this.username = username;
+        this.password = password;
+    }
+}
+export class PmonComponent extends WinCCOAComponent {
+    constructor() {
+        //-------------------------------------------------------------------------
+        //@public members
+        //-------------------------------------------------------------------------
+        super(...arguments);
+        //-------------------------------------------------------------------------
+        //@private members
+        //-------------------------------------------------------------------------
+        this.currentCredentials = null;
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Returns the component name
+     */
+    getName() {
+        return 'WCCILpmon';
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Returns the component description
+     */
+    getDescription() {
+        return 'Process Monitor';
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Registers a sub-project using pmon's -regsubf option
+     * @param projectPath - Path to the sub-project directory
+     * @returns Promise that resolves when registration is complete
+     */
+    async registerSubProject(projectPath) {
+        const args = ['-regsubf', '-proj', projectPath, '-log', '+stderr'];
+        return this.startAndValidateOutput(args, { checkStdout: false });
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Unregisters a project using pmon's -unreg option
+     * @param projectName - Name of the project to unregister
+     * @param outputCallback - Optional callback for output logging
+     * @returns Promise that resolves when unregistration is complete
+     */
+    async unregisterProject(projectName) {
+        // Use -unreg option to unregister project
+        const args = ['-unreg', projectName, '-log', '+stderr'];
+        return this.startAndValidateOutput(args, { checkStdout: false });
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Registers a runnable project using pmon's -config -autofreg -status options
+     * @param configPath - Path to the project config file
+     * @param outputCallback - Optional callback for output logging
+     * @returns Promise that resolves when registration is complete with exit code
+     */
+    async registerProject(configPath, projectVersion) {
+        if (configPath === undefined || configPath === '') {
+            throw new Error('Config path is not set for PmonComponent');
+        }
+        // Use -config -autofreg -status options to register runnable project
+        const args = ['-config', configPath, '-log', '+stderr', '-autofreg', '-status'];
+        super.setVersion(projectVersion);
+        const code = this.startAndValidateOutput(args, { checkStdout: false });
+        // the pmon returns 3 if the project is not running after registrations
+        const state = this.pmonStateCodeToStatus(await code);
+        return state !== ProjEnvPmonStatus.Unknown ? 0 : -1;
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Get pmon status. It check if the pmon is running or not
+     */
+    async getStatus(projectName) {
+        /*
+         -status  ... returns status of pmon:
+          0=pmon is running, 3=pmon is stopped, 4=unknown
+        */
+        const args = ['-status', '-proj', projectName, '-log', '+stdout'];
+        const code = this.startAndValidateOutput(args, { checkStdout: () => { } });
+        return this.pmonStateCodeToStatus(await code);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Starts pmon only (without auto-starting managers)
+     */
+    async startPmonOnly(projectName) {
+        const args = ['-proj', projectName, '-noAutostart'];
+        return this.startAndValidateOutput(args, { detached: true, waitForLog: 'WAIT_MODE' });
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Starts a project with all managers
+     */
+    async startProject(projectName, startAll = true) {
+        let args = ['-proj', projectName];
+        if (startAll) {
+            args = args.concat(['-command', this.makeCliCredentials() + 'START_ALL:']);
+            // INFO, 9/pmon, Das Projekt wurde gestartet und läuft. Gehe in den Überwachungsmodus
+            return this.startAndValidateOutput(args, { waitForLog: '9/pmon' });
+        }
+        else {
+            // starting pmon only without extra arguments means, it will start the project too.
+            // that means the pmon process will never end (hopefully, otherwise it crashed), so we need to detach
+            return this.startAndValidateOutput(args, { detached: true, waitForLog: 'WAIT_MODE' });
+        }
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Stops all managers in a project
+     */
+    async stopProject(projectName) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'STOP_ALL:',
+            '-log',
+            '+stderr',
+        ];
+        // INFO, 13/pmon, Projekt wurde komplett gestoppt - warte auf Befehle
+        return this.startAndValidateOutput(args, { waitForLog: '13/pmon' });
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Stops all managers and exits pmon
+     */
+    async stopProjectAndPmon(projectName, timeout) {
+        const args = ['-proj', projectName, '-stopWait', '-log', '+stderr'];
+        return this.startAndValidateOutput(args, { timeout: timeout, checkStdout: false });
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Restarts all managers in a project
+     */
+    async restartProject(projectName) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'RESTART_ALL:',
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Sets pmon wait mode
+     */
+    async setWaitMode(projectName) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'WAIT_MODE:',
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Starts a specific manager by index
+     */
+    async startManager(projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:START',
+            managerIndex.toString(),
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Stops a specific manager by index
+     */
+    async stopManager(projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:STOP',
+            managerIndex.toString(),
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Kills a specific manager by index
+     */
+    async killManager(projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:KILL',
+            managerIndex.toString(),
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Removes a specific manager by index
+     */
+    async removeManager(projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:DEL',
+            managerIndex.toString(),
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Gets the list of managers in a project
+     */
+    async getManagerOptionsList(projectName) {
+        const pmonPath = this.getPath();
+        if (!pmonPath) {
+            throw new Error('WCCILpmon executable not found');
+        }
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'MGRLIST:LIST',
+            '-log',
+            '+stdout',
+        ];
+        const callPath = pmonPath ?? '';
+        const lines = await this.execAndCollectLines(callPath, args);
+        const parsed = this.parseManagerList(lines.join('\n'));
+        return parsed;
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Convenience accessor for manager option (from MGRLIST:LIST) by index.
+     * If `projectName` is provided, it will refresh the options list first.
+     * If omitted, it returns the manager from last fetched list if available.
+     *
+     * TODO use command `>WCCILpmon.exe -proj Bla -log +stderr -command SINGLE_MGR:PROP_GET 2
+once 30 3 1 -m gedi -n -num 5` to get the properties. It shall be mu more faster, then query the whole list
+     */
+    async getManagerOptionsAt(index, projectName) {
+        if (typeof index !== 'number' || index < 0)
+            return undefined;
+        if (projectName) {
+            const list = await this.getManagerOptionsList(projectName);
+            return list[index];
+        }
+        return undefined;
+    }
+    //-------------------------------------------------------------------------
+    /** Sets manager options at a specific index in project
+     *
+     * @param options
+     * @param projectName
+     * @param managerIndex
+     * @returns
+     */
+    async setManagerOptionsAt(options, projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:PROP_PUT',
+            managerIndex.toString(),
+            startModeToString(options.startMode),
+            options.secondToKill.toString(),
+            options.resetStartCounter.toString(),
+            options.resetMin.toString(),
+            options.startOptions,
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /** Inserts a manager at a specific index into project
+     * @param options Manager options
+     * @param projectName Project name
+     * @param managerIndex Index to insert at
+     */
+    async insertManagerAt(options, projectName, managerIndex) {
+        if (managerIndex === undefined) {
+            managerIndex =
+                (await this.getManagerOptionsList(projectName).then((list) => list.length)) + 1;
+        }
+        // SINGLE_MGR:INS <idx> <manager> <startmode> <seckill> <restartcount> <resetmin> <args>
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:INS',
+            managerIndex.toString(),
+            options.component,
+            startModeToString(options.startMode),
+            options.secondToKill.toString(),
+            options.resetStartCounter.toString(),
+            options.resetMin.toString(),
+            options.startOptions,
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /** Sends a debug flag to a specific manager
+     * @param flag Debug flag to send (e.g., '-dbg http', '-dbg all')
+     * @param projectName Project name
+     * @param managerIndex Manager index
+     */
+    async sendDebugFlag(flag, projectName, managerIndex) {
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'SINGLE_MGR:DEBUG',
+            managerIndex.toString(),
+            flag,
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    //-------------------------------------------------------------------------
+    /** Gets detailed project and manager status (MGRLIST:STATI) and returns typed
+     *  managers and optional project state
+     * @param projectName Project name
+     * @returns Parsed project status
+     */
+    async getProjectStatus(projectName) {
+        const pmonPath = this.getPath();
+        if (!pmonPath) {
+            const errorMsg = 'Could not locate WCCILpmon executable';
+            throw new Error(errorMsg);
+        }
+        const args = [
+            '-proj',
+            projectName,
+            '-command',
+            this.makeCliCredentials() + 'MGRLIST:STATI',
+            '-log',
+            '+stdout',
+        ];
+        const callPath = pmonPath ?? '';
+        const lines = await this.execAndCollectLines(callPath, args);
+        const raw = lines.join('\n');
+        const parsed = this.parseManagerStatus(raw);
+        return parsed;
+    }
+    //-------------------------------------------------------------------------
+    /**
+     * Convenience method to get a single manager status by index.
+     * If `projectName` is provided, it will refresh the list first.
+     * If omitted, it returns the manager from last fetched list if available.
+     */
+    async getManagerStatusAt(index, projectName) {
+        if (typeof index !== 'number' || index < 0)
+            return undefined;
+        if (projectName) {
+            const res = await this.getProjectStatus(projectName);
+            return res.managers[index];
+        }
+        // No cached data and no project specified
+        return undefined;
+    }
+    //-------------------------------------------------------------------------
+    /** Saves credentials for pmon authentication
+     *
+     * @param projectName Project name
+     * @param credentials Credentials to save
+     * @returns
+     */
+    async saveCredentials(projectName, credentials) {
+        if (!this.currentCredentials) {
+            this.currentCredentials = { username: '', password: '' };
+        }
+        this.validateCredentials(credentials);
+        const code = this._storeCredentials(projectName, this.currentCredentials, credentials);
+        if ((await code) === 0) {
+            this.currentCredentials = credentials;
+            console.log('Saved credentials for project', projectName);
+        }
+        else {
+            console.log('Failed to save credentials for project', projectName);
+        }
+        return code;
+    }
+    //-------------------------------------------------------------------------
+    /** Validates pmon credentials
+     *
+     * @param credentials
+     * throws Error if credentials are invalid
+     */
+    validateCredentials(credentials) {
+        if (!credentials.username || credentials.username.trim() === '') {
+            throw new Error('Username cannot be empty');
+        }
+        if (!credentials.password || credentials.password.trim() === '') {
+            throw new Error('Password cannot be empty');
+        }
+        if (credentials.username.indexOf('#') !== -1) {
+            throw new Error('Username cannot contains the character "#"');
+        }
+        if (credentials.password.indexOf('#') !== -1) {
+            throw new Error('Password cannot contains the character "#"');
+        }
+    }
+    //-------------------------------------------------------------------------
+    /** Gets the currently used credentials
+     *
+     * @returns
+     */
+    getCredentials() {
+        return this.currentCredentials;
+    }
+    //-------------------------------------------------------------------------
+    /** Verifies pmon credentials
+     *
+     * @param projectName Project name
+     * @param credentials Credentials to verify
+     * @returns
+     */
+    verifyCredentials(projectName, credentials) {
+        const oldCredentials = credentials;
+        // just try to store the same credentials again
+        return this._storeCredentials(projectName, oldCredentials, credentials).then((code) => code === 0);
+    }
+    makeCliCredentials() {
+        if (!this.currentCredentials) {
+            return '';
+        }
+        return `${this.currentCredentials.username}#${this.currentCredentials.password}`;
+    }
+    //-------------------------------------------------------------------------
+    _storeCredentials(projectName, oldCredentials, newCredentials) {
+        const args = [
+            '-proj',
+            projectName,
+            '-auth',
+            oldCredentials.username,
+            oldCredentials.password,
+            newCredentials.username,
+            newCredentials.password,
+            '-log',
+            '+stderr',
+        ];
+        return this.startAndValidateOutput(args);
+    }
+    startAndValidateOutput(args = [], options = {}) {
+        if (options.checkStdout === undefined) {
+            options.checkStdout = (stdout) => {
+                if (!stdout) {
+                    console.warn('WARNING: Pmon command returned empty output. Do you means stdErr: ' +
+                        this.stdErr);
+                    return;
+                }
+                stdout = stdout.trim();
+                if (stdout != 'OK') {
+                    console.error('ERROR: Pmon command failed with output:', stdout);
+                }
+                else if (stdout.startsWith('ERROR')) {
+                    throw new Error(`Pmon command failed with error: ${stdout}`);
+                }
+            };
+        }
+        return super.start(args, options);
+    }
+    //-------------------------------------------------------------------------
+    /** Converts pmon exit code to ProjEnvPmonStatus
+     *
+     * @param code
+     * @returns
+     */
+    pmonStateCodeToStatus(code) {
+        console.log('Pmon status code:', code);
+        let status = ProjEnvPmonStatus.Unknown;
+        if (code === 0)
+            status = ProjEnvPmonStatus.Running;
+        else if (code === 3)
+            status = ProjEnvPmonStatus.NotRunning;
+        else
+            status = ProjEnvPmonStatus.Unknown;
+        return status;
+    }
+    //-------------------------------------------------------------------------
+    // Private parser for manager list output
+    parseManagerList(output) {
+        const lines = output
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && l !== ';');
+        if (lines.length === 0)
+            return [];
+        if (/^LIST:\d+/i.test(lines[0]))
+            lines.shift();
+        const result = [];
+        for (const line of lines) {
+            const parts = line.split(';');
+            if (parts.length < 1)
+                continue;
+            if (parts.length < 6) {
+                throw new Error(`The line '${line}' has incorrect format`);
+            }
+            const name = parts[0];
+            const startModeNum = Number(parts[1]);
+            const seckill = Number(parts[2]);
+            const restartCount = Number(parts[3]);
+            const resetMin = Number(parts[4]);
+            const args = parts.slice(5).filter(Boolean).join(';');
+            let startModeEnum;
+            switch (startModeNum) {
+                case 0:
+                    startModeEnum = ProjEnvManagerStartMode.Manual;
+                    break;
+                case 1:
+                    startModeEnum = ProjEnvManagerStartMode.Once;
+                    break;
+                case 2:
+                    startModeEnum = ProjEnvManagerStartMode.Always;
+                    break;
+                default:
+                    throw new Error(`The line '${line}' contains invalid start mode. Expected 0,1,2 becames ${startModeNum}`);
+            }
+            result.push({
+                component: name,
+                startMode: startModeEnum,
+                secondToKill: seckill,
+                resetMin: resetMin,
+                resetStartCounter: restartCount,
+                startOptions: args,
+            });
+        }
+        return result;
+    }
+    //-------------------------------------------------------------------------
+    // Parse project state line from STATI output
+    parseProjectState(line) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 4) {
+            const statusCode = parseInt(parts[0], 10);
+            const text = parts[1];
+            const emergency = parseInt(parts[2], 10) === 1;
+            const demo = parseInt(parts[3], 10) === 1;
+            let status = ProjEnvProjectState.Unknown;
+            switch (statusCode) {
+                case -1:
+                    status = ProjEnvProjectState.Unknown;
+                    break;
+                case 0:
+                    status = ProjEnvProjectState.Down;
+                    break;
+                case 1:
+                    status = ProjEnvProjectState.Starting;
+                    break;
+                case 2:
+                    status = ProjEnvProjectState.Monitoring;
+                    break;
+                case 3:
+                    status = ProjEnvProjectState.Stopping;
+                    break;
+                case 5:
+                    status = ProjEnvProjectState.Restarting;
+                    break;
+                default:
+                    status = ProjEnvProjectState.Unknown;
+                    break;
+            }
+            return { status, statusCode, text, emergency, demo };
+        }
+        return null;
+    }
+    //-------------------------------------------------------------------------
+    // Parse STATI output into typed managers and project state
+    parseManagerStatus(output) {
+        const managers = [];
+        const lines = output.split('\n');
+        let listStarted = false;
+        let projectState = undefined;
+        let projectStateLineFound = false;
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (trimmed.startsWith('STATI:') || trimmed.startsWith('LIST:')) {
+                listStarted = true;
+                continue;
+            }
+            if (trimmed === ';') {
+                break;
+            }
+            if (!listStarted || !trimmed)
+                continue;
+            // Look ahead to detect project state line (line before ';')
+            let isProjectStateLine = false;
+            for (let j = i + 1; j < lines.length; j++) {
+                const nextTrimmed = lines[j].trim();
+                if (nextTrimmed === ';') {
+                    isProjectStateLine = true;
+                    break;
+                }
+                else if (nextTrimmed !== '')
+                    break;
+            }
+            if (isProjectStateLine && !projectStateLineFound) {
+                const parsed = this.parseProjectState(trimmed);
+                if (parsed)
+                    projectState = parsed;
+                projectStateLineFound = true;
+                continue;
+            }
+            const parts = trimmed.split(';');
+            if (parts.length >= 5) {
+                const runningStateNum = parseInt(parts[0].trim(), 10);
+                const pid = parseInt(parts[1].trim(), 10);
+                const startModeNum = parseInt(parts[2].trim(), 10);
+                const startTimeStamp = parts[3].trim();
+                const managerNumber = parseInt(parts[4].trim(), 10);
+                let runningStateEnum;
+                switch (runningStateNum) {
+                    case 0:
+                        runningStateEnum = ProjEnvManagerState.NotRunning;
+                        break;
+                    case 1:
+                        runningStateEnum = ProjEnvManagerState.Init;
+                        break;
+                    case 2:
+                        runningStateEnum = ProjEnvManagerState.Running;
+                        break;
+                    case 3:
+                        runningStateEnum = ProjEnvManagerState.Blocked;
+                        break;
+                    default:
+                        runningStateEnum = ProjEnvManagerState.NotRunning;
+                        break;
+                }
+                let startModeEnum;
+                switch (startModeNum) {
+                    case 0:
+                        startModeEnum = ProjEnvManagerStartMode.Manual;
+                        break;
+                    case 1:
+                        startModeEnum = ProjEnvManagerStartMode.Once;
+                        break;
+                    case 2:
+                        startModeEnum = ProjEnvManagerStartMode.Always;
+                        break;
+                    default:
+                        startModeEnum = ProjEnvManagerStartMode.Manual;
+                        break;
+                }
+                let parsedTimestamp;
+                if (startTimeStamp &&
+                    startTimeStamp !== '0' &&
+                    startTimeStamp !== '' &&
+                    startTimeStamp !== '-1' &&
+                    !startTimeStamp.startsWith('1970')) {
+                    try {
+                        const winccOaMatch = startTimeStamp.match(/^(\d{4})\.(\d{2})\.(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/);
+                        if (winccOaMatch) {
+                            const [, year, month, day, hours, minutes, seconds, milliseconds] = winccOaMatch;
+                            parsedTimestamp = new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hours, 10), parseInt(minutes, 10), parseInt(seconds, 10), parseInt(milliseconds, 10));
+                        }
+                    }
+                    catch {
+                        parsedTimestamp = undefined;
+                    }
+                }
+                // Build object with new typed fields and include legacy field names for compatibility
+                const managerObj = {
+                    state: runningStateEnum,
+                    pid: pid === -1 ? undefined : pid,
+                    startMode: startModeEnum,
+                    startTime: parsedTimestamp,
+                    managerNumber,
+                };
+                // Legacy compatibility fields used by older consumers/tests
+                managerObj.runningState =
+                    runningStateEnum === ProjEnvManagerState.Running
+                        ? 'running'
+                        : runningStateEnum === ProjEnvManagerState.Init
+                            ? 'init'
+                            : runningStateEnum === ProjEnvManagerState.Blocked
+                                ? 'blocked'
+                                : 'stopped';
+                managerObj.startTimeStamp = parsedTimestamp;
+                managerObj.startMode =
+                    startModeEnum === ProjEnvManagerStartMode.Always
+                        ? 'always'
+                        : startModeEnum === ProjEnvManagerStartMode.Once
+                            ? 'once'
+                            : startModeEnum === ProjEnvManagerStartMode.Manual
+                                ? 'manual'
+                                : 'unknown';
+                managers.push(managerObj);
+            }
+        }
+        const state = {
+            managers: managers,
+            project: projectState,
+        };
+        return state;
+    }
+}
+//# sourceMappingURL=PmonComponent.js.map