elasticio-sailor-nodejs 2.7.1-dev3 → 2.7.1-dev5

package/lib/encryptor.js

@@ -1,114 +1,114 @@
-const crypto = require('crypto');
-const log = require('./logging.js');
-
-class Encryptor {
-    constructor(password, iv) {
-        this._cryptoPassword = password;
-        this._cryptoIV = iv;
-        if (this._cryptoPassword) {
-            this._encryptionKey = crypto
-                .createHash('sha256')
-                .update(this._cryptoPassword, 'utf-8')
-                .digest();
-            if (!this._cryptoIV) {
-                throw new Error(
-                    `missing crypt initialiazation vector,
-                    most likely ELASTICIO_MESSAGE_CRYPTO_PASSWORD env var is not set
-                    `
-                );
-            }
-        }
-        this._algorithm = 'aes-256-cbc';
-    }
-
-    createCipher() {
-        return crypto.createCipheriv(
-            this._algorithm,
-            this._encryptionKey,
-            this._cryptoIV
-        );
-    }
-
-    createDecipher() {
-        return crypto.createDecipheriv(
-            this._algorithm,
-            this._encryptionKey,
-            this._cryptoIV
-        );
-    }
-
-
-    /**
-     * Encrypt message to proper format
-     * @param {*} messagePayload anything json-stringifiable
-     * @param {'hex'|'base64'|'utf-8',undefined} outputEncoding
-     * @returns {Buffer}
-     */
-    encryptMessageContent(messagePayload, outputEncoding) {
-        const encryptedBuffer = this._encryptToBuffer(JSON.stringify(messagePayload));
-        if (outputEncoding) {
-            return Buffer.from(encryptedBuffer.toString(outputEncoding));
-        } else {
-            return encryptedBuffer;
-        }
-    }
-
-    /**
-     * Encrypt message to proper format
-     * @param {Buffer} messagePayload
-     * @param {'hex'|'base64'|'utf-8',undefined} inputEncoding
-     * @returns {*} anything, what have been encrypted
-     */
-    decryptMessageContent(messagePayload, inputEncoding) {
-        if (!messagePayload || messagePayload.length === 0) {
-            return null;
-        }
-        let encryptedBuffer;
-        if (inputEncoding) {
-            encryptedBuffer = Buffer.from(messagePayload.toString(), inputEncoding);
-        } else {
-            encryptedBuffer = messagePayload;
-        }
-        try {
-            const decryptedMessage = this._decryptFromBuffer(encryptedBuffer);
-            return JSON.parse(decryptedMessage);
-        } catch (err) {
-            log.error(err, 'Failed to decrypt message');
-            throw Error('Failed to decrypt message: ' + err.message);
-        }
-    }
-
-    /**
-     * Encrypt payload.
-     * @param {Buffer|String} message
-     * @returns {Buffer}
-     */
-    _encryptToBuffer(message) {
-        if (!this._encryptionKey) {
-            return Buffer.from(message);
-        }
-        const cipher = this.createCipher();
-        return Buffer.concat([
-            cipher.update(message),
-            cipher.final()
-        ]);
-    }
-
-    /**
-     * Decrypt payload.
-     * @param {Buffer} message
-     * @returns {String}
-     */
-    _decryptFromBuffer(message) {
-        if (!this._encryptionKey) {
-            return message.toString();
-        }
-        const decipher = this.createDecipher();
-
-        return Buffer.concat([
-            decipher.update(message),
-            decipher.final()
-        ]).toString('utf8');
-    }
-}
-module.exports = Encryptor;
+const crypto = require('crypto');
+const log = require('./logging.js');
+
+class Encryptor {
+    constructor(password, iv) {
+        this._cryptoPassword = password;
+        this._cryptoIV = iv;
+        if (this._cryptoPassword) {
+            this._encryptionKey = crypto
+                .createHash('sha256')
+                .update(this._cryptoPassword, 'utf-8')
+                .digest();
+            if (!this._cryptoIV) {
+                throw new Error(
+                    `missing crypt initialiazation vector,
+                    most likely ELASTICIO_MESSAGE_CRYPTO_PASSWORD env var is not set
+                    `
+                );
+            }
+        }
+        this._algorithm = 'aes-256-cbc';
+    }
+
+    createCipher() {
+        return crypto.createCipheriv(
+            this._algorithm,
+            this._encryptionKey,
+            this._cryptoIV
+        );
+    }
+
+    createDecipher() {
+        return crypto.createDecipheriv(
+            this._algorithm,
+            this._encryptionKey,
+            this._cryptoIV
+        );
+    }
+
+
+    /**
+     * Encrypt message to proper format
+     * @param {*} messagePayload anything json-stringifiable
+     * @param {'hex'|'base64'|'utf-8',undefined} outputEncoding
+     * @returns {Buffer}
+     */
+    encryptMessageContent(messagePayload, outputEncoding) {
+        const encryptedBuffer = this._encryptToBuffer(JSON.stringify(messagePayload));
+        if (outputEncoding) {
+            return Buffer.from(encryptedBuffer.toString(outputEncoding));
+        } else {
+            return encryptedBuffer;
+        }
+    }
+
+    /**
+     * Encrypt message to proper format
+     * @param {Buffer} messagePayload
+     * @param {'hex'|'base64'|'utf-8',undefined} inputEncoding
+     * @returns {*} anything, what have been encrypted
+     */
+    decryptMessageContent(messagePayload, inputEncoding) {
+        if (!messagePayload || messagePayload.length === 0) {
+            return null;
+        }
+        let encryptedBuffer;
+        if (inputEncoding) {
+            encryptedBuffer = Buffer.from(messagePayload.toString(), inputEncoding);
+        } else {
+            encryptedBuffer = messagePayload;
+        }
+        try {
+            const decryptedMessage = this._decryptFromBuffer(encryptedBuffer);
+            return JSON.parse(decryptedMessage);
+        } catch (err) {
+            log.error(err, 'Failed to decrypt message');
+            throw Error('Failed to decrypt message: ' + err.message);
+        }
+    }
+
+    /**
+     * Encrypt payload.
+     * @param {Buffer|String} message
+     * @returns {Buffer}
+     */
+    _encryptToBuffer(message) {
+        if (!this._encryptionKey) {
+            return Buffer.from(message);
+        }
+        const cipher = this.createCipher();
+        return Buffer.concat([
+            cipher.update(message),
+            cipher.final()
+        ]);
+    }
+
+    /**
+     * Decrypt payload.
+     * @param {Buffer} message
+     * @returns {String}
+     */
+    _decryptFromBuffer(message) {
+        if (!this._encryptionKey) {
+            return message.toString();
+        }
+        const decipher = this.createDecipher();
+
+        return Buffer.concat([
+            decipher.update(message),
+            decipher.final()
+        ]).toString('utf8');
+    }
+}
+module.exports = Encryptor;

package/lib/executor.js

@@ -1,74 +1,74 @@
-const assert = require('assert');
-const _ = require('lodash');
-const EventEmitter = require('./emitter').EventEmitter;
-
-const { ComponentLogger } = require('./logging');
-
-class TaskExec extends EventEmitter {
-    constructor({ loggerOptions, variables, services } = {}) {
-        super();
-        this.errorCount = 0;
-        this.logger = new ComponentLogger(loggerOptions);
-        // copy variables to protect from outside changes;
-        this._variables = Object.assign({}, variables || {});
-        this._services = services;
-        assert(this._services, 'TaskExec should be created with services');
-        assert(this._services.apiClient, 'TaskExec should be created with api client');
-        assert(this._services.config , 'TaskExec should be created with config');
-        assert(this._services.amqp, 'TaskExec should be created with ampq');
-    }
-
-    process(triggerOrAction, payload, cfg, snapshot) {
-        const onError = async (err) => {
-            this.logger.error('Error occurred during trigger or action processing');
-            await this.emit('error', err);
-            await this.emit('end');
-        };
-
-        if (!_.isFunction(triggerOrAction.process)) {
-            return onError(new Error('Process function is not found'));
-        }
-
-        new Promise(resolve => {
-            const result = triggerOrAction.process.bind(this)(payload, cfg, snapshot);
-            if (result) {
-                resolve(result);
-            }
-        })
-            .then(async (data) => {
-                if (data) {
-                    this.logger.debug('Process function is a Promise/generator/etc');
-                    await this.emit('data', data);
-                }
-                await this.emit('end');
-            })
-            .catch(onError);
-    }
-
-    getApiClient() {
-        return this._services.apiClient;
-    }
-
-    getConfig() {
-        return this._services.config;
-    }
-
-    /**
-     * Get amqp connection wrapper. Internal.
-     * Should be used only or really special cases
-     */
-    __getAmqp() {
-        return this._services.amqp;
-    }
-
-    /**
-     * Returns flow variables or empty object
-     * @returns {Object<String, String>}
-     */
-    getFlowVariables() {
-        return this._variables;
-    }
-}
-
-
-exports.TaskExec = TaskExec;
+const assert = require('assert');
+const _ = require('lodash');
+const EventEmitter = require('./emitter').EventEmitter;
+
+const { ComponentLogger } = require('./logging');
+
+class TaskExec extends EventEmitter {
+    constructor({ loggerOptions, variables, services } = {}) {
+        super();
+        this.errorCount = 0;
+        this.logger = new ComponentLogger(loggerOptions);
+        // copy variables to protect from outside changes;
+        this._variables = Object.assign({}, variables || {});
+        this._services = services;
+        assert(this._services, 'TaskExec should be created with services');
+        assert(this._services.apiClient, 'TaskExec should be created with api client');
+        assert(this._services.config , 'TaskExec should be created with config');
+        assert(this._services.amqp, 'TaskExec should be created with ampq');
+    }
+
+    process(triggerOrAction, payload, cfg, snapshot) {
+        const onError = async (err) => {
+            this.logger.error('Error occurred during trigger or action processing');
+            await this.emit('error', err);
+            await this.emit('end');
+        };
+
+        if (!_.isFunction(triggerOrAction.process)) {
+            return onError(new Error('Process function is not found'));
+        }
+
+        new Promise(resolve => {
+            const result = triggerOrAction.process.bind(this)(payload, cfg, snapshot);
+            if (result) {
+                resolve(result);
+            }
+        })
+            .then(async (data) => {
+                if (data) {
+                    this.logger.debug('Process function is a Promise/generator/etc');
+                    await this.emit('data', data);
+                }
+                await this.emit('end');
+            })
+            .catch(onError);
+    }
+
+    getApiClient() {
+        return this._services.apiClient;
+    }
+
+    getConfig() {
+        return this._services.config;
+    }
+
+    /**
+     * Get amqp connection wrapper. Internal.
+     * Should be used only or really special cases
+     */
+    __getAmqp() {
+        return this._services.amqp;
+    }
+
+    /**
+     * Returns flow variables or empty object
+     * @returns {Object<String, String>}
+     */
+    getFlowVariables() {
+        return this._variables;
+    }
+}
+
+
+exports.TaskExec = TaskExec;

package/lib/hooksData.js

@@ -1,68 +1,68 @@
-'use strict';
-
-const request = require('requestretry');
-
-class HooksData {
-
-    constructor({
-        FLOW_ID: taskId,
-        API_USERNAME: user,
-        API_KEY: pass,
-        API_URI: basePath,
-        API_REQUEST_RETRY_ATTEMPTS: maxAttempts,
-        API_REQUEST_RETRY_DELAY: retryDelay
-    }) {
-        this.taskId = taskId;
-        this.user = user;
-        this.pass = pass;
-        this.basePath = basePath;
-        this.maxAttempts = maxAttempts;
-        this.retryDelay = retryDelay;
-    }
-
-    async request(method, data) {
-        const options = {
-            url: `${this.basePath}/sailor-support/hooks/task/${this.taskId}/startup/data`,
-            method,
-            auth: {
-                user: this.user,
-                pass: this.pass
-            },
-            json: true,
-            forever: true,
-            headers: {
-                Connection: 'Keep-Alive'
-            },
-            maxAttempts: this.maxAttempts,
-            retryDelay: this.retryDelay,
-            retryStrategy: request.RetryStrategies.HTTPOrNetworkError
-        };
-        if (data) {
-            options.body = data;
-        }
-        const { statusCode, body } = await request(options);
-
-        if (statusCode >= 400) {
-            throw Object.assign(new Error(body.error), { statusCode });
-        }
-
-        return body;
-    }
-
-    create(data) {
-        return this.request('POST', data);
-    }
-
-    retrieve() {
-        return this.request('GET');
-    }
-
-    delete() {
-        return this.request('DELETE');
-    }
-
-}
-
-module.exports.startup = function startup(settings) {
-    return new HooksData(settings);
-};
+'use strict';
+
+const request = require('requestretry');
+
+class HooksData {
+
+    constructor({
+        FLOW_ID: taskId,
+        API_USERNAME: user,
+        API_KEY: pass,
+        API_URI: basePath,
+        API_REQUEST_RETRY_ATTEMPTS: maxAttempts,
+        API_REQUEST_RETRY_DELAY: retryDelay
+    }) {
+        this.taskId = taskId;
+        this.user = user;
+        this.pass = pass;
+        this.basePath = basePath;
+        this.maxAttempts = maxAttempts;
+        this.retryDelay = retryDelay;
+    }
+
+    async request(method, data) {
+        const options = {
+            url: `${this.basePath}/sailor-support/hooks/task/${this.taskId}/startup/data`,
+            method,
+            auth: {
+                user: this.user,
+                pass: this.pass
+            },
+            json: true,
+            forever: true,
+            headers: {
+                Connection: 'Keep-Alive'
+            },
+            maxAttempts: this.maxAttempts,
+            retryDelay: this.retryDelay,
+            retryStrategy: request.RetryStrategies.HTTPOrNetworkError
+        };
+        if (data) {
+            options.body = data;
+        }
+        const { statusCode, body } = await request(options);
+
+        if (statusCode >= 400) {
+            throw Object.assign(new Error(body.error), { statusCode });
+        }
+
+        return body;
+    }
+
+    create(data) {
+        return this.request('POST', data);
+    }
+
+    retrieve() {
+        return this.request('GET');
+    }
+
+    delete() {
+        return this.request('DELETE');
+    }
+
+}
+
+module.exports.startup = function startup(settings) {
+    return new HooksData(settings);
+};

package/lib/ipc.js

@@ -1,13 +1,13 @@
-/**
- * Used to communicate with parent processes.
- */
-class IPC {
-    send(event, data) {
-        if (!process.send) {
-            return;
-        }
-        process.send({ event, data });
-    }
-}
-
-exports.IPC = IPC;
+/**
+ * Used to communicate with parent processes.
+ */
+class IPC {
+    send(event, data) {
+        if (!process.send) {
+            return;
+        }
+        process.send({ event, data });
+    }
+}
+
+exports.IPC = IPC;