Basic version extracted from exoframe-server

Author: yamalight

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -0,0 +1,17 @@
+# Exoframe-FaaS
+
+> Simple function deployments for Exoframe
+
+[![Build Status](https://travis-ci.org/exoframejs/exoframe-server.svg?branch=master)](https://travis-ci.org/exoframejs/exoframe-server)
+[![Coverage Status](https://coveralls.io/repos/github/exoframejs/exoframe-server/badge.svg?branch=master)](https://coveralls.io/github/exoframejs/exoframe-server?branch=master)
+[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://opensource.org/licenses/MIT)
+
+Exoframe is a self-hosted tool that allows simple one-command deployments using Docker.
+
+## Installation, usage and docs
+
+For more details on how to get it up and running please follow the following link [how to setup exoframe-server](https://github.com/exoframejs/exoframe/tree/master/docs).
+
+## License
+
+Licensed under MIT.

index.js

@@ -0,0 +1,17 @@
+// export faas methods
+const {getLogsForFunction, listFunctions, registerFunction, removeFunction, setup} = require('./src/index');
+const template = require('./src/template');
+
+module.exports = {
+  // logs
+  getLogsForFunction,
+  // listing
+  listFunctions,
+  // function registration and removal
+  registerFunction,
+  removeFunction,
+  // init & middleware setup
+  setup,
+  // exoframe template
+  template,
+};

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "exoframe-faas",
+  "version": "0.1.0",
+  "description": "Simple function deployments for Exoframe",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Tim Ermilov <[email protected]> (http://codezen.net)",
+  "license": "MIT",
+  "dependencies": {
+    "fs-extra": "^8.0.1",
+    "rimraf": "^2.6.3"
+  },
+  "devDependencies": {
+    "fastify": "^2.4.1",
+    "jest": "^24.8.0"
+  }
+}

src/index.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+const rimraf = require('rimraf');
+
+const runInWorker = require('./worker');
+
+// loaded functions storage
+const functions = {};
+
+// remove function
+const rmDir = path => new Promise(resolve => rimraf(path, resolve));
+
+// basic logging function generator
+const loggerForRoute = route => msg => functions[route].log.push(`${new Date().toISOString()} ${msg}\n`);
+
+exports.listFunctions = ({functionToContainerFormat}) =>
+  Object.keys(functions).map(route =>
+    functionToContainerFormat({config: functions[route].config, route, type: functions[route].type})
+  );
+
+exports.getLogsForFunction = id => {
+  const route = Object.keys(functions).find(route => functions[route].config.name === id);
+  const fn = functions[route];
+  if (!fn) {
+    return;
+  }
+  return fn.log;
+};
+
+exports.removeFunction = async ({id, username}) => {
+  const route = Object.keys(functions).find(route => functions[route].config.name === id);
+  const fn = functions[route];
+  if (!fn) {
+    return false;
+  }
+
+  // if running in worker - trigger cleanup
+  if (fn.type === 'worker') {
+    fn.worker.terminate();
+  }
+
+  // remove from cache
+  delete functions[route];
+  // remove files
+  await rmDir(fn.folder);
+
+  return true;
+};
+
+exports.registerFunction = async ({faasFolder, folder}) => {
+  // ignore empty current folder reference
+  if (!folder || !folder.trim().length) {
+    return;
+  }
+  // construct paths
+  const funPath = path.join(faasFolder, folder);
+  const funConfigPath = path.join(funPath, 'exoframe.json');
+  // load code and config
+  const fun = require(funPath);
+  const funConfig = require(funConfigPath);
+  // expand config into default values
+  const config = {route: `/${funConfig.name}`, type: 'http', ...funConfig.function};
+
+  // if function already exists - remove old version
+  if (functions[config.route]) {
+    await exports.removeFunction({id: funConfig.name});
+  }
+
+  // store function in memory
+  functions[config.route] = {
+    type: config.type,
+    route: config.route,
+    handler: fun,
+    config: funConfig,
+    folder: funPath,
+    log: [],
+  };
+
+  // we're done if it's http function
+  if (config.type === 'http') {
+    return;
+  }
+
+  // otherwise - execute work based on function
+  if (config.type === 'worker') {
+    const worker = runInWorker({meta: functions[config.route], log: loggerForRoute(config.route)});
+    functions[config.route].worker = worker;
+    return;
+  }
+
+  throw new Error(`Unknown function type! Couldn't register ${functions[config.route]}!`);
+};
+
+const loadFunctions = faasFolder => {
+  const folders = fs.readdirSync(faasFolder);
+  for (const folder of folders) {
+    exports.registerFunction(folder);
+  }
+};
+
+exports.setup = config => {
+  // load current functions
+  loadFunctions(config.faasFolder);
+  // return new fastify middleware
+  return (fastify, opts, next) => {
+    // http handler
+    fastify.route({
+      method: 'GET',
+      path: '*',
+      async handler(request, reply) {
+        const route = request.params['*'];
+        if (functions[route] && functions[route].type === 'http') {
+          const event = request;
+          const context = {reply, log: loggerForRoute(route)};
+          const res = await functions[route].handler(event, context);
+          if (res) {
+            reply.send(res);
+          }
+          return;
+        }
+
+        reply.code(404).send(`Error! Function not found!`);
+      },
+    });
+
+    next();
+  };
+};

src/runner.js

@@ -0,0 +1,17 @@
+const {parentPort, workerData} = require('worker_threads');
+
+const {file} = workerData;
+
+const execute = require(file);
+
+const log = msg => {
+  parentPort.postMessage(msg);
+};
+
+const main = async () => {
+  parentPort.postMessage('Worker starting with:', file);
+  const cleanup = await execute(null, {log});
+  parentPort.postMessage('Worker started, cleanup:', cleanup);
+};
+
+main();

src/template.js

@@ -0,0 +1,54 @@
+// npm packages
+const fs = require('fs');
+const fse = require('fs-extra');
+const path = require('path');
+
+// template name
+exports.name = 'faas';
+
+// function to check if the template fits this recipe
+exports.checkTemplate = async ({config}) => {
+  // if project has function field defined in config
+  try {
+    return config.function;
+  } catch (e) {
+    return false;
+  }
+};
+
+// function to execute current template
+exports.executeTemplate = async ({config, serverConfig, username, tempDockerDir, folder, resultStream, util, faas}) => {
+  try {
+    // generate dockerfile
+    const faasFolder = path.join(tempDockerDir, folder);
+    util.writeStatus(resultStream, {message: 'Deploying function project..', level: 'info'});
+
+    // execute yarn to install deps
+    const hasPackageJson = fs.existsSync(path.join(faasFolder, 'package.json'));
+    util.logger.debug('Function has package.json:', hasPackageJson);
+    if (hasPackageJson) {
+      const log = await util.runYarn({args: ['install'], cwd: faasFolder});
+      util.logger.debug('Installed function deps:', log);
+    }
+
+    // copy folder to current folder for functions
+    const destFolder = path.join(serverConfig.faasFolder, folder);
+    util.logger.debug('Copying function from-to:', {faasFolder, destFolder});
+    await fse.move(faasFolder, destFolder);
+    util.logger.debug('Copied function to server..');
+
+    // register new function
+    await faas.registerFunction({faasFolder: serverConfig.faasFolder, folder});
+    util.logger.debug('Registered function on server..');
+
+    // return new deployment
+    const {route, type} = {route: `/${config.name}`, type: 'http', ...config.function};
+    const deployment = util.functionToContainerFormat({config, route, type});
+    util.writeStatus(resultStream, {message: 'Deployment success!', deployments: [deployment], level: 'info'});
+    resultStream.end('');
+  } catch (e) {
+    util.logger.debug('Function deployment failed!', e);
+    util.writeStatus(resultStream, {message: e.error, error: e.error, log: e.log, level: 'error'});
+    resultStream.end('');
+  }
+};

src/worker.js

@@ -0,0 +1,20 @@
+const path = require('path');
+const {Worker} = require('worker_threads');
+
+module.exports = ({meta, log}) => {
+  const file = path.join(meta.folder, 'index.js');
+  const runner = path.join(__dirname, 'runner.js');
+  const worker = new Worker(runner, {
+    workerData: {file},
+  });
+  worker.on('message', msg => {
+    log(msg);
+  });
+  worker.on('error', err => {
+    log(err);
+  });
+  worker.on('exit', code => {
+    log(`Worker stopped with exit code ${code}`);
+  });
+  return worker;
+};