@nsshunt/stsappframework 3.1.211 → 3.1.213

package/src/commonTypes.ts

@@ -10,6 +10,8 @@ import { Consumer, KafkaMessage } from 'kafkajs'
 //@@import { RedisMessageHandler } from '@nsshunt/stsmessaging'
 import { TinyEmitter } from "tiny-emitter";
 
+import { Worker, Address } from 'node:cluster'
+
 export interface IServiceProcessContext extends IContextBase {
 	serviceId?: string // Service name and the service version
 
@@ -80,6 +82,26 @@ export type IPCMessages = Record<string, IPCMessage>
 
 //------------------------------------
 
+export interface IProcessBaseEvents {
+    'processSigint': []
+    'processSigterm': []
+    'processExit': [ workerid: number ]
+
+    'ProcessTerminate': []
+
+    'clusterListening': [ worker: Worker, address: Address ];
+    'clusterOnline': [ worker: Worker ]
+    'clusterExit': [ worker: Worker, code: number, signal: string ]
+    'allListening': []
+
+    'workerMessage': [ id: number, payload: any ]
+    'workerError': [ error: Error ]
+    'workerAdded': [ id: number ]
+    'workerExit': [ code: number, signal: string ]
+
+    'prometheusScrapesListening': [ url: string, endpoint: string, prometheusClusterPort: string ]
+}
+
 export interface IProcessBase extends TinyEmitter {
     SetupInstrumentation(): void
     GetAdditionalInstruments(): InstrumentDefinitions
@@ -102,10 +124,13 @@ export interface IProcessBase extends TinyEmitter {
     get accessLayer(): IDBAccessLayer | null
     get shuttingDown(): boolean
     //@@get redisMessageHandler(): RedisMessageHandler
+
+    emit<K extends keyof IProcessBaseEvents>(event: K, ...arg: IProcessBaseEvents[K]): this
+    on<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this
+    off<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this
 }
 
 export interface IMasterProcessBase extends IProcessBase {
-     
     WorkerMessageEvent(messageId: number, msg: any): any
     SetupServer: () => Promise<void>
     SetupServerEx: () => Promise<void>
@@ -122,32 +147,27 @@ export interface IMasterProcessBase extends IProcessBase {
     ProcessIPCCommand(iPCMessagePayload: IPCMessagePayload): Promise<IPCMessagePayload>
 }
 
-export interface ISingleProcessBase extends IProcessBase {
-     
+export interface IServerProcessBase extends IProcessBase {
     get httpServer(): any
-    CollectAdditionalTelemetry(): void
-    ProcessStarted(): void
     get io(): any
-    get expressServer(): any // STSExpressServer - need to put interface in common types - circular reference
+    get expressServer(): STSExpressServer | null
+    set expressServer(server: STSExpressServer | null)
+    Terminate: (clusterPerformExit: boolean, signal?: any) => Promise<void>
+    SetupSTSServer: () => Promise<void>
+    CollectAdditionalTelemetry(): void
     SetupServer(): Promise<boolean>
-    SetupServerEx: () => Promise<void>
+    SetupServerEx: () => Promise<boolean>
+    ProcessStarted(): void
+}
+
+export interface ISingleProcessBase extends IServerProcessBase {
     TerminateApplication(): Promise<void>
 }
 
-export interface IWorkerProcessBase extends IProcessBase {
-    get httpServer(): any
-    WorkerStarted(): void
-     
+export interface IWorkerProcessBase extends IServerProcessBase {
     ReceivedMessageFromMaster(msg: any): void
-    CollectAdditionalTelemetry(): void
-    get io(): any
-     
     AddWorker: (options: any) => Promise<string>
-     
     DeleteWorker: (workerId: string, options: any) => Promise<JSONObject>
-    get expressServer(): any
-    SetupServer: () => Promise<void>
-    SetupServerEx: () => Promise<void>
     GetMasterProcessOptions: () => Promise<JSONObject>
 }
 

package/src/masterprocessbase.ts

@@ -5,7 +5,7 @@ import https from 'https'
 
 import axios from 'axios';
 
-import cluster, { Worker } from 'node:cluster'
+import cluster, { Worker, Address } from 'node:cluster'
 
 import chalk from 'chalk';
 
@@ -27,9 +27,8 @@ import { InstrumentDefinitions } from '@nsshunt/stsobservability'
 import { IPCMessagePayload, IPCMessageCommand } from './commonTypes'
 
 import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
-import { JSONObject } from "@nsshunt/stsutils";
 
-import { GetFirstNetworkInterface } from './network';
+//import { GetFirstNetworkInterface } from './network';
 
 export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 {
@@ -101,7 +100,8 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
     }
 
     #InitCluster = () => {
-        cluster.on('listening', () => {
+        cluster.on('listening', (worker: Worker, address: Address) => {
+            this.emit('clusterListening', worker, address);
             let allListening = true;
             for (const worker of Object.values(cluster.workers as NodeJS.Dict<Worker>)) {
                 if (worker?.isConnected) {
@@ -109,9 +109,9 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                     break;
                 }
             }
-
             if (allListening) {
                 this.LogInfoMessage(`Service instance started.`);
+                this.emit('allListening');
             }
         });
     };
@@ -158,6 +158,9 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                 //@@chmodSync(this.options.port, 511);
             }).on('listening', () =>
             {
+                this.emit('prometheusScrapesListening', `${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`,
+                    this.options.endpoint,
+                    this.options.prometheusClusterPort);
                 this.LogInfoMessage(`Prometheus scrapes ready and live on ${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`);
             });
         } catch (error)
@@ -407,6 +410,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         this.IncWorkers();
 
         worker.on('exit', (code, signal) => {
+            this.emit('workerExit', code, signal);
             if (signal) {
                 this.LogInfoMessage(`Worker: ${worker.process.pid} was killed by signal: ${signal}`);
             } else if (code !== 0) {
@@ -417,6 +421,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         });
 
         worker.on('message', async (payload) => {
+            this.emit('workerMessage', worker.id, payload);
             // Only handle request/response message types here ...
             if (payload.requestResponse) {
                 const iPCMessagePayload: IPCMessagePayload = payload as IPCMessagePayload;
@@ -430,6 +435,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         });
 
         worker.on('error', (error) => {
+            this.emit('workerError', error);
             const message = chalk.red(`#SpawnWorker():worker.on('error'): Error: [${error}]`);
             this.LogErrorMessage(message);
         });
@@ -482,18 +488,19 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
         this.#InitCluster();
 
-        cluster.on('listening', (worker, address) =>
-        {
+        cluster.on('listening', (worker, address) => {
+            this.emit('clusterListening', worker, address);
             this.LogInfoMessage(`Worker process ${worker.process.pid} is listening at address: ${JSON.stringify(address)}`);
         });
 
         //Setting up lifecycle event listeners for worker processes
-        cluster.on('online', worker => 
-        {
+        cluster.on('online', worker => {
+            this.emit('clusterOnline', worker);
             this.LogInfoMessage(`Worker process ${worker.process.pid} is online`);
         });
 
         cluster.on('exit', (worker, code, signal) => {
+            this.emit('clusterExit', worker, code, signal);
             if ((code !== null && code === 0) || (signal === 'SIGINT')) {
                 this.LogInfoMessage(chalk.green(`Process ${worker.process.pid} terminated gracefully with code: ${code}, signal: ${signal}`));
                 this.DecWorkers();
@@ -590,20 +597,19 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
             }
         }
 
-        process.on('SIGINT', async () =>
-        {
+        process.on('SIGINT', async () => {
+            this.emit('processSigint');
             await Terminate('SIGINT');
         });
 
-        process.on('SIGTERM', async () =>
-        {
+        process.on('SIGTERM', async () => {
+            this.emit('processSigterm');
             await Terminate('SIGTERM');
         });
 
-        process.on('exit', (code) =>
-        {
-            if (code === 0)
-            {
+        process.on('exit', (code) => {
+            this.emit('processExit', code);
+            if (code === 0) {
                 this.LogInfoMessage(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
             } else {
                 this.LogInfoMessage(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
@@ -616,15 +622,6 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
             }, 1000).unref();
         }
 
-        /*
-        this.redisMessageHandler.AddGroup('primary');
-
-        this.redisMessageHandler.on('GetSystemInformation', async (args: JSONObject, callback: any) => {
-            const retVal = await this.#GetSystemInformation();
-            callback(retVal);
-        });
-        */
-
         this.MasterStarted();
 
         this.LogInfoMessage(chalk.green(`Master process:${process.pid} started`));

package/src/processbase.ts

@@ -22,7 +22,7 @@ import { PublishInstrumentController, IPublishInstrumentControllerOptions, Instr
 
 import os from 'os';
 
-import { IProcessBase, ISocketIoServerHelper, CreateServiceProcessContext, ProcessOptions, STSServerType } from './commonTypes'
+import { IProcessBase, ISocketIoServerHelper, CreateServiceProcessContext, ProcessOptions, STSServerType, IProcessBaseEvents } from './commonTypes'
 
 //@@import { RedisMessageHandler } from '@nsshunt/stsmessaging'
 import { TinyEmitter } from 'tiny-emitter';
@@ -428,6 +428,21 @@ export abstract class ProcessBase extends TinyEmitter implements IProcessBase
         return msgcolor;
     };
 
+    emit<K extends keyof IProcessBaseEvents>(event: K, ...arg: IProcessBaseEvents[K]): this {
+        super.emit(event, arg);
+        return this;
+    }
+
+    on<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this {
+        super.on(event, callback);
+        return this;
+    }
+
+    off<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this {
+        super.off(event, callback);
+        return this;
+    }
+
     /*@@
     get redisMessageHandler(): RedisMessageHandler {
         return this.#redisMessageHandler as RedisMessageHandler;

package/src/serverprocessbase.ts

@@ -10,7 +10,7 @@ import { createAdapter } from "@socket.io/redis-streams-adapter";
 
 import { JSONObject, Sleep } from '@nsshunt/stsutils'
 
-import { ProcessOptions, STSServerType } from './commonTypes'
+import { ProcessOptions, STSServerType, IServerProcessBase } from './commonTypes'
 import { ProcessBase } from './processbase';
 
 import { register, Counter, collectDefaultMetrics, AggregatorRegistry } from 'prom-client'
@@ -28,12 +28,14 @@ import { createClient, RedisClientType } from 'redis';
 
 import jayson from 'jayson'
 
+import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
+
 /**
  * todo
  * @typedef {Object} options - todo
  * @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
  */
-export class ServerProcessBase extends ProcessBase
+export abstract class ServerProcessBase extends ProcessBase implements IServerProcessBase
 {
     #masterProcessExitTime = goptions.masterProcessExitTime;
     #io: Server | null = null;
@@ -363,6 +365,73 @@ export class ServerProcessBase extends ProcessBase
         }
     }
 
+    async SetupServer(): Promise<boolean> {
+        return new Promise((resolve, reject) => {
+            try {
+                this.SetupInstrumentation();
+                setTimeout(async () => {
+                    try {
+                        await this.SetupServerEx();
+                        resolve(true);
+                    } catch (error) {
+                        reject(error);
+                    }
+                }, 100);
+            } catch (error) {
+                reject(error);
+            }
+        })
+    }
+
+    ProcessStarted() {
+        const transport = new STSTransportLoggerWinston({
+            stsApp: this
+        });
+        setTimeout(() => {
+            (this.options.logger as any).add(transport);
+        }, 0);
+    }
+
+    async SetupServerEx(): Promise<boolean> {
+        this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Main Process:${process.pid} Starting ...`));
+
+        this.ProcessStartup();
+
+        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
+            this.expressServer = new STSExpressServer(this.options, this);
+        }
+
+        this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
+
+        // Signal Codes
+        // https://en.wikipedia.org/wiki/Signal_(IPC)
+        process.on('SIGTERM', async () => {
+            this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): SIGTERM signal received for worker: ${process.pid}`);
+            await this.Terminate(true, true);
+        });
+
+        process.on('SIGINT', async () => {
+            this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): SIGINT signal received for worker: ${process.pid}`);
+            await this.Terminate(true, true);
+        });
+
+        process.on('exit', (code) => {
+            if (code === 0) {
+                this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Process: ${process.pid} terminated gracefully with code: ${code}`));
+            } else {
+                this.LogInfoMessage(chalk.red(`ServerProcessBase:SetupServerEx(): Process: ${process.pid} terminated with code: ${code}`));
+            }
+        });
+
+        await this.SetupSTSServer();
+        
+        this.ProcessStarted();
+
+        this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Main Process:${process.pid} Started`));
+
+        return true;
+    };
+
     SetupSTSServer = async(): Promise<void> => {
         switch (this.options.serverType) {
         case STSServerType.EXPRESS :

package/src/singleprocessbase.ts

@@ -1,19 +1,14 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
 import { goptions } from '@nsshunt/stsconfig'
 
-import chalk from 'chalk';
-
 import { Gauge, GaugeTypes, InstrumentGaugeOptions, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
 
 import { ISingleProcessBase, ProcessOptions } from './commonTypes';
 import { InstrumentDefinitions } from '@nsshunt/stsobservability'
-import { STSExpressServer } from './server'
 import { ServerProcessBase } from './serverprocessbase'
 
 import si from 'systeminformation' // https://systeminformation.io/
 
-import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
-
 export type EventCb = (socket: any, data: any) => void
 
 export class SingleProcessBase extends ServerProcessBase implements ISingleProcessBase
@@ -54,67 +49,12 @@ export class SingleProcessBase extends ServerProcessBase implements ISingleProce
         return null;
     }
 
-    ProcessStarted() {
-        const transport = new STSTransportLoggerWinston({
-            stsApp: this
-        });
-        setTimeout(() => {
-            (this.options.logger as any).add(transport);
-        }, 0);
-    }
-
-    SetupServer(): Promise<boolean>
-    {
-        return new Promise((resolve, reject) => {
-            try {
-                this.SetupInstrumentation();
-                setTimeout(async () => {
-                    try {
-                        await this.SetupServerEx();
-                        resolve(true);
-                    } catch (error) {
-                        reject(error);
-                    }
-                }, 100);
-            } catch (error) {
-                reject(error);
-            }
-        })
-    }
-
-    SetupServerEx = async () => {
-        this.ProcessStartup();
-
-        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
-            this.expressServer = new STSExpressServer(this.options, this);
-        }
-
-        this.LogInfoMessage(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
-        this.LogInfoMessage(`Master process:${process.pid} started`);
+    override SetupServerEx = async (): Promise<boolean> => {
+        await super.SetupServerEx();
 
         this.LogSystemTelemetry();
 
-        process.on('SIGINT', async () => {
-            await this.Terminate(false, 'SIGINT');
-        });
-
-        process.on('SIGTERM', async () => {
-            await this.Terminate(false, 'SIGTERM');
-        });
-
-        process.on('exit', (code) => {
-            if (code === 0) {
-                this.LogInfoMessage(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
-            } else {
-                this.LogInfoMessage(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
-            }
-        });
-
-        await this.SetupSTSServer();
-
-        this.ProcessStarted();
-
-        this.LogInfoMessage(chalk.green(`Main process:${process.pid} started`));
+        return true;
     }
 
     async TerminateApplication()

package/src/workerprocessbase.ts

@@ -4,13 +4,10 @@ import chalk from 'chalk';
 import { Gauge, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
 import { JSONObject } from '@nsshunt/stsutils'
 import { IPCMessage, IPCMessages, IPCMessagePayload, IPCMessageCommand, IWorkerProcessBase, ProcessOptions } from './commonTypes'
-import { STSExpressServer } from './server';
 import { ServerProcessBase } from './serverprocessbase'
 
 import { v4 as uuidv4 } from 'uuid';
 
-import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
-
 import { goptions } from '@nsshunt/stsconfig'
 
 import si from 'systeminformation' // https://systeminformation.io/
@@ -31,15 +28,6 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         super(options);
     }
 
-    WorkerStarted() {
-        const transport = new STSTransportLoggerWinston({
-            stsApp: this
-        });
-        setTimeout(() => {
-            (this.options.logger as any).add(transport);
-        }, 0);
-    }
-
     // eslint-disable-next-line  @typescript-eslint/no-unused-vars
     ReceivedMessageFromMaster(msg: any) {
         // Override in subclass if required
@@ -96,7 +84,6 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         });
         return workerResponse.workerId;
     }
-
      
     DeleteWorker = async (workerId: string, options: any): Promise<JSONObject> => {
         const workerResponse: JSONObject = await this.#SendMessageToParentProcess({
@@ -121,13 +108,6 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         return parentResponse;
     }
 
-    SetupServer = async () => {
-        this.SetupInstrumentation();
-        setTimeout(() => {
-            this.SetupServerEx();
-        }, 100);
-    }
-
     GetNumCPUs = async (): Promise<number> => {
         // https://systeminformation.io/
         const valueObject = {
@@ -191,16 +171,9 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         return sysInfo;
     }
 
-    SetupServerEx = async () => {
-        this.ProcessStartup();
-		
-        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
-            this.expressServer = new STSExpressServer(this.options, this);
-        }
-
-        this.LogInfoMessage(`Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
+    override SetupServerEx = async (): Promise<boolean> => {
+        await super.SetupServerEx();
 
-         
         process.on('message', async (msg: any) => {
             if (msg.requestResponse) {
                 const iPCMessagePayload: IPCMessagePayload = msg as IPCMessagePayload;
@@ -239,27 +212,7 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
             }
         });
 
-        // Signal Codes
-        // https://en.wikipedia.org/wiki/Signal_(IPC)
-        process.on('SIGTERM', async () =>
-        {
-            this.LogInfoMessage(`SIGTERM signal received for worker: ${process.pid}`);
-            await this.Terminate(true, true);
-        });
-
-        process.on('SIGINT', async () =>
-        {
-            this.LogInfoMessage(`SIGINT signal received for worker: ${process.pid}`);
-            await this.Terminate(true, true);
-        });
-
-        await this.SetupSTSServer();
-
-        //@@this.redisMessageHandler.AddGroup('worker');
-
-        this.WorkerStarted();
-
-        this.LogInfoMessage(chalk.green(`Worker process:${process.pid} started`));
+        return true;
     };
 
     override ProcessTerminate(): Promise<void> {

package/types/commonTypes.d.ts

@@ -5,6 +5,7 @@ import { PublishInstrumentController, InstrumentDefinitions, IContextBase, Instr
 import { IDBAccessLayer } from '@nsshunt/stsdatamanagement';
 import { Consumer, KafkaMessage } from 'kafkajs';
 import { TinyEmitter } from "tiny-emitter";
+import { Worker, Address } from 'node:cluster';
 export interface IServiceProcessContext extends IContextBase {
     serviceId?: string;
     serviceInstanceId?: string;
@@ -37,6 +38,21 @@ export interface IPCMessage {
     timeout: NodeJS.Timeout;
 }
 export type IPCMessages = Record<string, IPCMessage>;
+export interface IProcessBaseEvents {
+    'processSigint': [];
+    'processSigterm': [];
+    'processExit': [workerid: number];
+    'ProcessTerminate': [];
+    'clusterListening': [worker: Worker, address: Address];
+    'clusterOnline': [worker: Worker];
+    'clusterExit': [worker: Worker, code: number, signal: string];
+    'allListening': [];
+    'workerMessage': [id: number, payload: any];
+    'workerError': [error: Error];
+    'workerAdded': [id: number];
+    'workerExit': [code: number, signal: string];
+    'prometheusScrapesListening': [url: string, endpoint: string, prometheusClusterPort: string];
+}
 export interface IProcessBase extends TinyEmitter {
     SetupInstrumentation(): void;
     GetAdditionalInstruments(): InstrumentDefinitions;
@@ -56,6 +72,9 @@ export interface IProcessBase extends TinyEmitter {
     TerminateDatabase(): Promise<void>;
     get accessLayer(): IDBAccessLayer | null;
     get shuttingDown(): boolean;
+    emit<K extends keyof IProcessBaseEvents>(event: K, ...arg: IProcessBaseEvents[K]): this;
+    on<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this;
+    off<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this;
 }
 export interface IMasterProcessBase extends IProcessBase {
     WorkerMessageEvent(messageId: number, msg: any): any;
@@ -70,27 +89,25 @@ export interface IMasterProcessBase extends IProcessBase {
     BroadcastDataToWorkers: (command: any, data: any) => void;
     ProcessIPCCommand(iPCMessagePayload: IPCMessagePayload): Promise<IPCMessagePayload>;
 }
-export interface ISingleProcessBase extends IProcessBase {
+export interface IServerProcessBase extends IProcessBase {
     get httpServer(): any;
-    CollectAdditionalTelemetry(): void;
-    ProcessStarted(): void;
     get io(): any;
-    get expressServer(): any;
+    get expressServer(): STSExpressServer | null;
+    set expressServer(server: STSExpressServer | null);
+    Terminate: (clusterPerformExit: boolean, signal?: any) => Promise<void>;
+    SetupSTSServer: () => Promise<void>;
+    CollectAdditionalTelemetry(): void;
     SetupServer(): Promise<boolean>;
-    SetupServerEx: () => Promise<void>;
+    SetupServerEx: () => Promise<boolean>;
+    ProcessStarted(): void;
+}
+export interface ISingleProcessBase extends IServerProcessBase {
     TerminateApplication(): Promise<void>;
 }
-export interface IWorkerProcessBase extends IProcessBase {
-    get httpServer(): any;
-    WorkerStarted(): void;
+export interface IWorkerProcessBase extends IServerProcessBase {
     ReceivedMessageFromMaster(msg: any): void;
-    CollectAdditionalTelemetry(): void;
-    get io(): any;
     AddWorker: (options: any) => Promise<string>;
     DeleteWorker: (workerId: string, options: any) => Promise<JSONObject>;
-    get expressServer(): any;
-    SetupServer: () => Promise<void>;
-    SetupServerEx: () => Promise<void>;
     GetMasterProcessOptions: () => Promise<JSONObject>;
 }
 export type ServerEventCb = (socket: any, data: any) => void;