@koeroesi86/node-lambda-invoke 1.0.21-d1fa702 → 26.10.36900076505-master

package/classes/FileStorage.js

@@ -1,114 +0,0 @@
-const { resolve } = require('path');
-const {
-  unlink,
-  readFile,
-  writeFile,
-  existsSync,
-  mkdirSync,
-} = require('fs');
-const rimraf = require('rimraf');
-
-const serializer = {
-  serialize: data => JSON.stringify(data),
-  deserialize: data => JSON.parse(data),
-};
-
-/**
- * @type {{restore: (function(*=): Promise), save: (function(*=, *=): Promise), destroy: (function(*=): Promise)}}
- */
-const Driver = {
-  save: (path, data) => new Promise((res, rej) =>
-    writeFile(path, data, 'utf8', err => err ? rej(err) : res())
-  ),
-  restore: path => new Promise((res, rej) =>
-    readFile(path, 'utf8', (err, data) => err ? rej(err) : res(data))
-  ),
-  destroy: path => new Promise((res, rej) =>
-    existsSync(path) ? unlink(path, err => err ? rej(err) : res()) : setTimeout(res, 0)
-  ),
-};
-
-
-class FileStorage {
-  /**
-   * @param {string} id
-   */
-  constructor(id)  {
-    this.id = id;
-
-    this.setResponse = this.setResponse.bind(this);
-    this.getResponse = this.getResponse.bind(this);
-    this.setRequest = this.setRequest.bind(this);
-    this.getRequest = this.getRequest.bind(this);
-    this.destroy = this.destroy.bind(this);
-  }
-
-  /**
-   * @returns {string}
-   */
-  get requestPath() {
-    return resolve(FileStorage.requestBase, `./${this.id}`);
-  }
-
-  /**
-   * @returns {string}
-   */
-  get responsePath() {
-    return resolve(FileStorage.responseBase, `./${this.id}`);
-  }
-
-  /**
-   * @param {ResponseEvent} response
-   * @returns {Promise}
-   */
-  setResponse(response) {
-    return Driver.save(this.responsePath, serializer.serialize(response));
-  }
-
-  /**
-   * @returns {Promise<ResponseEvent>}
-   */
-  getResponse() {
-    return Driver.restore(this.responsePath)
-      .then(data => Promise.resolve(serializer.deserialize(data)));
-  }
-
-  /**
-   * @param {RequestEvent} request
-   * @returns {Promise}
-   */
-  setRequest(request) {
-    return Driver.save(this.requestPath, serializer.serialize(request));
-  }
-
-  /**
-   * @returns {Promise<RequestEvent>}
-   */
-  getRequest() {
-    return Driver.restore(this.requestPath)
-      .then(data => Promise.resolve(serializer.deserialize(data)));
-  }
-
-  /**
-   * @returns {Promise}
-   */
-  destroy() {
-    return Promise.all([
-      Driver.destroy(this.responsePath),
-      Driver.destroy(this.requestPath)
-    ]);
-  }
-}
-
-FileStorage.requestBase = resolve(__dirname, `../requests/`);
-FileStorage.responseBase = resolve(__dirname, `../responses/`);
-
-FileStorage.start = () => {
-  rimraf.sync(resolve(FileStorage.requestBase, './*'));
-  rimraf.sync(resolve(FileStorage.responseBase, './*'));
-
-  if (!existsSync(FileStorage.requestBase)) mkdirSync(FileStorage.requestBase, { recursive: true });
-  if (!existsSync(FileStorage.responseBase)) mkdirSync(FileStorage.responseBase, { recursive: true });
-};
-
-module.exports = FileStorage;

package/classes/IPCStorage.js

@@ -1,216 +0,0 @@
-const Lambda = require('./Lambda');
-
-let storage = {};
-
-const MESSAGES = {
-  GET_RESONSE: 'GW_GET_RESONSE',
-  SET_RESONSE: 'GW_SET_RESONSE',
-  SET_RESONSE_FINISHED: 'GW_SET_RESONSE_FINISHED',
-  GET_REQUEST: 'GW_GET_REQUEST',
-  SET_REQUEST: 'GW_SET_REQUEST',
-  SET_REQUEST_FINISHED: 'GW_SET_REQUEST_FINISHED',
-  DESTROY: 'GW_DESTROY',
-};
-
-const getRequestKey = id => `request-${id}`;
-const getResponseKey = id => `response-${id}`;
-
-process.on('message', message => {
-  if (message.type === MESSAGES.SET_REQUEST) {
-    const id = getRequestKey(message.id);
-    storage[id] = message.payload;
-    process.send({ type: MESSAGES.SET_REQUEST_FINISHED, id: message.id });
-  }
-
-  if (message.type === MESSAGES.SET_RESONSE) {
-    const id = getResponseKey(message.id);
-    storage[id] = message.payload;
-    process.send({ type: MESSAGES.SET_RESONSE_FINISHED, id: message.id });
-  }
-
-  // if (message.type === MESSAGES.DESTROY) {
-  //   const requestId = getResponseKey(message.id);
-  //   delete storage[requestId];
-  //   const responseId = getResponseKey(message.id);
-  //   delete storage[responseId];
-  // }
-});
-
-class IPCStorage {
-  /**
-   * @param {string} id
-   * @param {Process|Lambda} [instance]
-   */
-  constructor(id, instance)  {
-    this.id = id;
-    /** @type {Process|Lambda} */
-    this.instance = instance;
-
-    this.setResponse = this.setResponse.bind(this);
-    this.getResponse = this.getResponse.bind(this);
-    this.setRequest = this.setRequest.bind(this);
-    this.getRequest = this.getRequest.bind(this);
-    this.destroy = this.destroy.bind(this);
-    this.invoker = this.invoker.bind(this);
-    this.executor = this.executor.bind(this);
-    this.invokerMessageListener = this.invokerMessageListener.bind(this);
-    this.executorMessageListener = this.executorMessageListener.bind(this);
-
-    if (this.instance instanceof Lambda) {
-      this.invoker();
-    } else {
-      this.executor();
-    }
-  }
-
-  invoker() {
-    this.instance.addEventListener('message', this.invokerMessageListener);
-  }
-
-  invokerMessageListener(message) {
-    if (message && message.type === MESSAGES.GET_REQUEST) {
-      const id = getRequestKey(message.id);
-      const item = storage[id];
-      if (item) {
-        this.instance.postMessage({ type: MESSAGES.SET_REQUEST, id: message.id, payload: item });
-      }
-    }
-
-    if (message && message.type === MESSAGES.SET_RESONSE) {
-      const id = getResponseKey(message.id);
-      storage[id] = message.payload;
-      this.instance.postMessage({ type: MESSAGES.SET_RESONSE_FINISHED, id: message.id });
-    }
-  }
-
-  executor() {
-    this.instance.on('message', this.executorMessageListener);
-  }
-
-  executorMessageListener(message) {
-    if (message && message.type === MESSAGES.SET_REQUEST) {
-      const id = getRequestKey(message.id);
-      storage[id] = message.payload;
-      process.send({ type: MESSAGES.SET_REQUEST_FINISHED, id: message.id });
-    }
-
-    if (message && message.type === MESSAGES.GET_RESONSE) {
-      const id = getResponseKey(message.id);
-      const item = storage[id];
-      if (item) {
-        process.send({ type: MESSAGES.SET_RESONSE, id: message.id, payload: item });
-      }
-    }
-  }
-
-  /**
-   * @returns {string}
-   */
-  get requestKey() {
-    return getRequestKey(this.id);
-  }
-
-  /**
-   * @returns {string}
-   */
-  get responseKey() {
-    return getResponseKey(this.id);
-  }
-
-  /**
-   * @param {ResponseEvent} response
-   * @returns {Promise}
-   */
-  setResponse(response) {
-    storage[this.responseKey] = response;
-    return new Promise(resolve => {
-      const finishListener = message => {
-        if (message && message.type === MESSAGES.SET_RESONSE_FINISHED && message.id === this.id) {
-          resolve();
-          this.instance.off('message', finishListener);
-        }
-      };
-      this.instance.on('message', finishListener);
-      this.instance.send({ type: MESSAGES.SET_RESONSE, id: this.id, payload: response });
-    });
-  }
-
-  /**
-   * @returns {Promise<ResponseEvent>}
-   */
-  getResponse() {
-    return new Promise(resolve => {
-      if (storage[this.responseKey]) return resolve(storage[this.responseKey]);
-      const finishListener = message => {
-        if (message && message.type === MESSAGES.SET_RESONSE && message.id === this.id) {
-          storage[this.responseKey] = message.payload;
-          resolve(message.payload);
-          this.instance.off('message', finishListener);
-        }
-      };
-      this.instance.on('message', finishListener);
-      this.instance.send({ type: MESSAGES.GET_RESONSE, id: this.id });
-    });
-  }
-
-  /**
-   * @param {RequestEvent} request
-   * @returns {Promise}
-   */
-  setRequest(request) {
-    storage[this.requestKey] = request;
-    return new Promise(resolve => {
-      const finishListener = message => {
-        if (message && message.type === MESSAGES.SET_REQUEST_FINISHED && message.id === this.id) {
-          resolve();
-          this.instance.off('message', finishListener);
-        }
-      };
-      this.instance.on('message', finishListener);
-      this.instance.send({ type: MESSAGES.SET_REQUEST, id: this.id, payload: request });
-    });
-  }
-
-  /**
-   * @returns {Promise<RequestEvent>}
-   */
-  getRequest() {
-    return new Promise(resolve => {
-      if (storage[this.requestKey]) return resolve(storage[this.requestKey]);
-      const finishListener = message => {
-        if (message && message.type === MESSAGES.SET_REQUEST && message.id === this.id) {
-          storage[this.requestKey] = message.payload;
-          resolve(message.payload);
-          this.instance.off('message', finishListener);
-          // this.instance.send({ type: MESSAGES.SET_REQUEST_FINISHED, id: message.id })
-        }
-      };
-      this.instance.on('message', finishListener);
-      this.instance.send({ type: MESSAGES.GET_REQUEST, id: this.id });
-    });
-  }
-
-  /**
-   * @returns {Promise}
-   */
-  destroy() {
-    storage[this.requestKey] = null;
-    delete storage[this.requestKey];
-    storage[this.responseKey] = null;
-    delete storage[this.responseKey];
-
-    if (this.instance instanceof Lambda) {
-      this.instance.removeEventListener('message', this.invokerMessageListener);
-    } else {
-      this.instance.off('message', this.executorMessageListener);
-    }
-
-    return Promise.resolve();
-  }
-}
-
-IPCStorage.start = () => {
-  storage = {};
-};
-
-module.exports = IPCStorage;

package/classes/Lambda.js

@@ -1,124 +0,0 @@
-const { resolve } = require('path');
-const Worker = require('./Worker');
-const {
-  EVENT_REQUEST,
-  EVENT_RESPONSE,
-} = require('../constants');
-const CommunicationRegistry = require('../registry/communication');
-
-class Lambda {
-  /**
-   * @param {string} path
-   * @param {string} handler
-   * @param {function} [logger]
-   * @param {Object} communication
-   */
-  constructor(path, handler, logger = () => {}, communication) {
-    this._path = path;
-    this._handler = handler;
-    this._logger = logger;
-    this._storagePath = CommunicationRegistry[communication.type].js.path;
-    this._communication = communication;
-    this.StorageDriver = require(this._storagePath);
-    this.createInstance();
-    this.busy = false;
-
-    const killTimer = setTimeout(() => {
-      this._logger('Shutting down lambda.');
-        if (this.instance) {
-          this.instance.terminate();
-          this.instance = null;
-        }
-    }, 15 * 60 * 1000);
-
-    this.instance.addEventListenerOnce('close', code => {
-      this.instance = null;
-      clearTimeout(killTimer);
-    });
-
-    this._onFinished = this._onFinished.bind(this);
-  }
-
-  get stdout() {
-    return this.instance.stdout;
-  }
-
-  get stderr() {
-    return this.instance.stderr;
-  }
-
-  createInstance() {
-    this.instance = new Worker(
-      resolve(__dirname, '../middlewares/invoke.js'),
-      {
-        stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-        env: {
-          LAMBDA: this._path,
-          HANDLER: this._handler,
-          COMMUNICATION: JSON.stringify(this._communication),
-        }
-      }
-    );
-  }
-
-  /**
-   * @param {string} requestId
-   * @param {RequestEvent} requestEvent
-   * @param {function} callback
-   */
-  invoke(requestId, requestEvent, callback = () => {}) {
-    if (!this.instance) this.createInstance();
-    this._storage = new this.StorageDriver(requestId, this.instance);
-    Promise.resolve()
-      .then(() => this._storage.setRequest(requestEvent))
-      .then(() => {
-        this.busy = true;
-        this._requestId = requestId;
-        this._callback = callback;
-        this.instance.addEventListener('message', this._onFinished);
-        this.instance.postMessage({ type: EVENT_REQUEST, id: requestId });
-      });
-  }
-
-  /**
-   * @param event
-   * @private
-   */
-  _onFinished(event) {
-    if (event.type === EVENT_RESPONSE && event.id === this._requestId) {
-      this.busy = false;
-      this.instance.removeEventListener('message', this._onFinished);
-      this._storage.getResponse().then(responseEvent => this._callback(responseEvent));
-    }
-  }
-
-  /**
-   * @param {string} event
-   * @param {function} listener
-   */
-  addEventListener(event, listener) {
-    this.instance.addEventListener(event, listener);
-  }
-
-  /**
-   * @param {string} event
-   * @param {function} listener
-   */
-  addEventListenerOnce(event, listener) {
-    this.instance.addEventListenerOnce(event, listener);
-  }
-
-  /**
-   * @param {string} event
-   * @param {function} listener
-   */
-  removeEventListener(event, listener) {
-    this.instance.removeEventListener(event, listener);
-  }
-
-  postMessage(message, cb = () => {}) {
-    this.instance.postMessage(message, cb);
-  }
-}
-
-module.exports = Lambda;

package/classes/LambdaPool.js

@@ -1,78 +0,0 @@
-const uuid = require('uuid');
-const Lambda = require('../classes/Lambda');
-const stdoutListener = require('../middlewares/stdoutListener');
-const { EVENT_STARTED } = require('../constants');
-
-const lambdaInstances = {};
-
-function getOverallCount() {
-  return Object.keys(lambdaInstances).reduce((result, current) => Object.keys(lambdaInstances[current]).length + result, 0);
-}
-
-function getNonBusyId(lambdaToInvoke) {
-  const timeLimit = Date.now() - 15 * 60 * 1000 + 5000; // lifespan of lambda, to give enough time to respond before killed
-  return Object.keys(lambdaInstances[lambdaToInvoke] || {}).find(id => {
-    const instance = lambdaInstances[lambdaToInvoke][id];
-    return !instance.busy && instance.createdAt >= timeLimit;
-  });
-}
-
-class LambdaPool {
-  constructor({ overallLimit, logger = () => {}, communication }) {
-    this.communication = communication;
-    this.overallLimit = overallLimit;
-    this.logger = logger;
-
-    this.getLambda = this.getLambda.bind(this);
-    this.createLambda = this.createLambda.bind(this);
-  }
-
-  createLambda(lambdaToInvoke, handlerKey) {
-    return new Promise(resolve => {
-      const currentId = uuid.v4();
-      const currentLambdaInstance = new Lambda(lambdaToInvoke, handlerKey, this.logger, this.communication);
-
-      const lambdaStartListener = message => {
-        if (message.type === EVENT_STARTED) {
-          this.logger(`[${currentId}] started`);
-          currentLambdaInstance.removeEventListener('message', lambdaStartListener);
-          resolve({ id: currentId, instance: currentLambdaInstance });
-        }
-      };
-      currentLambdaInstance.addEventListener('message', lambdaStartListener);
-
-      currentLambdaInstance.addEventListenerOnce('close', code => {
-        if (code) this.logger(`[${currentId}] Lambda exited with code ${code}`);
-      });
-
-      stdoutListener(currentLambdaInstance, this.logger);
-    });
-  }
-
-  getLambda(lambdaToInvoke, handlerKey) {
-      const nonBusyId = getNonBusyId(lambdaToInvoke);
-      if (getOverallCount() >= this.overallLimit) {
-        return Promise.resolve()
-          .then(() => new Promise(r => setTimeout(r, 100)))
-          .then(() => this.getLambda(lambdaToInvoke, handlerKey));
-      } else if (!lambdaInstances[lambdaToInvoke] || !nonBusyId) {
-        return Promise.resolve()
-          .then(() => this.createLambda(lambdaToInvoke, handlerKey))
-          .then(({ id, instance }) => {
-            instance.createdAt = Date.now();
-            lambdaInstances[lambdaToInvoke] = {
-              ...(lambdaInstances[lambdaToInvoke] && lambdaInstances[lambdaToInvoke]),
-              [id]: instance,
-            };
-
-            return Promise.resolve(instance);
-          });
-      } else if(nonBusyId) {
-        return Promise.resolve(lambdaInstances[lambdaToInvoke][nonBusyId]);
-      }
-
-      return Promise.reject();
-  }
-}
-
-module.exports = LambdaPool;

package/classes/RequestEvent.js

@@ -1,15 +0,0 @@
-/**
- * @class RequestEvent
- * @property {String} path
- * @property {Object.<String, String>} headers
- * @property {Object.<String, String>} pathParameters
- * @property {Object} requestContext
- * @property {String} resource
- * @property {String} httpMethod
- * @property {Object.<String, String>} queryStringParameters
- * @property {Object.<String, String>} stageVariables
- */
-class RequestEvent {
-}
-
-module.exports = RequestEvent;

package/classes/ResponseEvent.js

@@ -1,12 +0,0 @@
-/**
- * @class ResponseEvent
- * @property {Number} statusCode
- * @property {Object.<String, String>} headers
- * @property {String} body
- * @property {boolean} [isBase64Encoded]
- */
-class ResponseEvent {
-
-}
-
-module.exports = ResponseEvent;

package/classes/Worker.js

@@ -1,93 +0,0 @@
-const { spawn } = require('child_process');
-
-// TODO: move this to separate package
-class Worker {
-  /**
-   * @param {string} workerPath
-   * @param {Object} options
-   */
-  constructor(workerPath, options = {}) {
-    this.workerPath = workerPath;
-    this.instance = spawn(
-      'node',
-      [
-        ...this.workerPath.split(' ')
-      ],
-      {
-        stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-        ...options,
-      }
-    );
-    if (this.instance.stdout) {
-      const messageListener = data => {
-        console.info(data.toString().trim());
-      };
-      this.instance.stdout.on('data', messageListener);
-    }
-    this.instance.once('close', () => {
-      this.instance = null;
-      delete this.instance;
-    });
-
-    this.addEventListener = this.addEventListener.bind(this);
-    this.removeEventListener = this.removeEventListener.bind(this);
-    this.terminate = this.terminate.bind(this);
-    this.postMessage = this.postMessage.bind(this);
-    this.send = this.send.bind(this);
-  }
-
-  set onmessage(onmessage) {
-    this.addEventListener('message', onmessage);
-  }
-
-  set onerror(onerror) {
-    this.addEventListener('error', onerror);
-  }
-
-  get stdout() {
-    return this.instance.stdout;
-  }
-
-  get stderr() {
-    return this.instance.stderr;
-  }
-
-  addEventListener(event, listener) {
-    if (this.instance) this.instance.on(event, listener);
-  }
-
-  addEventListenerOnce(event, listener) {
-    if (this.instance) this.instance.once(event, listener);
-  }
-
-  on(event, listener) {
-    this.addEventListener(event, listener);
-  }
-
-  off(event, listener) {
-    this.removeEventListener(event, listener);
-  }
-
-  send(message, cb = () => {}) {
-    this.postMessage(message, cb);
-  }
-
-  removeEventListener(event, listener) {
-    if (this.instance && this.instance.off) this.instance.off(event, listener);
-  }
-
-  // from EventTarget prototype, if needed
-  // dispatchEvent() {
-  //
-  // }
-
-  terminate() {
-    if (this.instance) this.instance.kill('SIGINT');
-  }
-
-  postMessage(message, cb = () => {}) {
-    if (this.instance) this.instance.send(message, cb);
-  }
-}
-
-module.exports = Worker;

package/constants/index.js

@@ -1,8 +0,0 @@
-const EVENT_STARTED = 'LAMBDA_EVENT_STARTED';
-module.exports.EVENT_STARTED = EVENT_STARTED;
-
-const EVENT_REQUEST = 'LAMBDA_EVENT_REQUEST';
-module.exports.EVENT_REQUEST = EVENT_REQUEST;
-
-const EVENT_RESPONSE = 'LAMBDA_EVENT_RESPONSE';
-module.exports.EVENT_RESPONSE = EVENT_RESPONSE;

package/index.js

@@ -1,9 +0,0 @@
-module.exports.httpMiddleware = require('./middlewares/http');
-
-module.exports.Lambda = require('./classes/Lambda');
-
-module.exports.FileStorage = require('./classes/FileStorage');
-
-module.exports.IPCStorage = require('./classes/IPCStorage');
-
-module.exports.Worker = require('./classes/Worker');