@josefransaenz/hypergate-core v1.0.4

Installation

npm install @josefransaenz/hypergate-core

hypergate-core

This library provides a single class called Hypergate which controls the execution of resource-specific applications (plugins) and emits events or messages about their status and data obtained.

Depending of the type of execution and the communication mode needed, a plugin can be defined inside of one of three categories:

• Routines: applications that are executed with the aim of obtaining a result (measurement or data acquisition) and may only need to receive input data at the begining of their execution and may only return output data at the end. The exchange of input and output data with this mode of plugins can be done thorugh a JSON file.
• Tasks: applications that may need to be executed independently of the parent process and may need/produce formatted input/output data to/from the standard I/O.
• Services: applications that may need to be executed all the time or for a exteded period of time and may need to periodically o episodically send or receive information. This type of plugins can provide a ZeroMQ endpoint to which the Hypergate instance can connect a ZMQ_DEALER socket for establishing a bidirectional any-time communication channel.

Example

const Hypergate = require('@josefransaenz/hypergate-core')

const hypergate = new Hypergate({
routines: {
    myRoutine: {
        command: 'myRoutine.exe',
        args: ['myArg1', 'myArg2'],
        path: '/path/to/myRoutine',
        jsonFile: 'temp.json',
        jsonFileSchema: {
            type: 'object',
            properties: { 
                foo: { type: 'string'},
                bar: { type: 'array'}
            }
        }
    }  
}
 });
 
 hypergate.once('routines/myRoutine/completed', (outputData) =>  {
 	console.log('myRoutine was completed with the following result: ' + outputData.bar);
 });
 
 hypergate.once('routines/myRoutine/error', (error) =>  {
 	console.error('Error while executing myRoutine: ' + error);
 });

 var inputData = { foo: 'val1' };

 hypergate.command('routines/myRoutine/start', inputData)
 .then(() => {
 	console.log('myRoutine is executing!');
 }); 
 .catch((error) => {
 	console.error('myRoutine could not be executed ' + error);
 }); 

API Reference

Hypergate ⇐ EventEmitter

Extends: EventEmitter
Emits: _pluginType_/_pluginName_/start, _pluginType_/_pluginName_/error, _pluginType_/_pluginName_/exit, _pluginType_/_pluginName_/stdout, _pluginType_/_pluginName_/stderr, routines/_routineName_/completed, services/_serviceName_/output

• Hypergate ⇐ EventEmitter
  • new Hypergate(plugins)
  • .getStatus() ⇒ status
  • .command(command, payload) ⇒ promise
  • .stop() ⇒ promise
  • "pluginType/pluginName/start"
  • "pluginType/pluginName/error" (error)
  • "pluginType/pluginName/exit" (exitMessage)
  • "pluginType/pluginName/stdout" (data)
  • "pluginType/pluginName/stderr" (data)
  • "routines/routineName/completed" (data)
  • "services/serviceName/output" (data)

new Hypergate(plugins)

An instance of the Hypergate class is a EventEmitters that represents a controller of a set of applications called plugins. A plugin is a script or an executable that can be spawned as a child process of the application that instaciate the Hypergate class.

hypergate.getStatus() ⇒ status

Returns the status of the hypergate instance

hypergate.command(command, payload) ⇒ promise

Execute a command for communicating or controlling a plugin or requesting the status of the hypergate instance

hypergate.stop() ⇒ promise

Stop all running plugins. Returns a promise that is full filled when all process are stopped

"pluginType/pluginName/start"

Emmitted when the process of the plugin is launched. This event do not guarantee that the plugin sucesfully started to execute.

"pluginType/pluginName/error" (error)

Emmitted when an error occurred during the execution of the plugin is launched. This event do not guarantee that the plugin sucesfully started to execute.

"pluginType/pluginName/exit" (exitMessage)

Emmitted when the process of the plugin ends.

"pluginType/pluginName/stdout" (data)

Emmitted when a chunk of data is received from the stdout of the process of the plugin.

"pluginType/pluginName/stderr" (data)

Emmitted when a chunk of data is received from the stderr of the process of the plugin.

"routines/routineName/completed" (data)

Emmitted when a plugin of type 'routines' completes its execution and its output data is successfully retrieved.

"services/serviceName/output" (data)

Emmitted when a message is received from a plugin of type 'services'.

status : object

The status of an hypergate instance.

Properties