systemlynx 1.1.0

package/systemlynx/LoadBalancer/tests/LoadBalancer.test.js

@@ -0,0 +1,142 @@
+const { expect } = require("chai");
+const LoadBalancer = require("../LoadBalancer")();
+const ServiceFactory = require("../../Service/Service");
+const HttpClient = require("../../HttpClient/HttpClient")();
+const lbPort = 5030;
+const route = "loadbalancer";
+
+describe("LoadBalancerFactory", () => {
+  it("should return a SystemLynx LoadBalancer", () => {
+    expect(LoadBalancer)
+      .to.be.an("object")
+      .that.has.all.keys(
+        "startService",
+        "Server",
+        "WebSocket",
+        "defaultModule",
+        "ServerModule",
+        "clones"
+      )
+      .that.respondsTo("startService")
+      .that.respondsTo("Server")
+      .that.respondsTo("WebSocket")
+      .that.respondsTo("ServerModule");
+    expect(LoadBalancer.clones)
+      .to.be.an("object")
+      .that.has.all.keys("on", "emit", "clones", "register", "dispatch", "assignDispatch")
+      .that.respondsTo("emit")
+      .that.respondsTo("on")
+      .that.respondsTo("register")
+      .that.respondsTo("dispatch")
+      .that.respondsTo("assignDispatch")
+      .that.has.property("clones")
+      .that.is.an("array");
+  });
+});
+describe("LoadBalancer", () => {
+  it("should return an object with properties: startService (fn), clones (Service)", () => {
+    expect(LoadBalancer).to.be.an("object");
+    expect(typeof LoadBalancer.startService).to.equal("function");
+  });
+
+  it("should be able to start the LoadBalancer Service using the LoadBalancer.startService method", async () => {
+    await LoadBalancer.startService({ port: lbPort, route });
+    const url = `http://localhost:${lbPort}/${route}`;
+    const connData = await HttpClient.request({ url });
+
+    expect(connData)
+      .to.be.an("Object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "host",
+        "port",
+        "modules",
+        "route",
+        "namespace",
+        "serviceUrl"
+      )
+      .that.has.property("modules")
+      .that.is.an("array")
+      .to.has.a.lengthOf(1);
+  });
+});
+describe("LoadBalancer.clones (ServerModule)", () => {
+  const test_service1 = {
+    route: "test-service1",
+    port: 5393,
+    host: "localhost",
+  };
+
+  const test_service2 = {
+    route: "test-service2",
+    port1: 5391,
+    port2: 5392,
+    host: "localhost",
+  };
+  it("should be a Service object with additional methods for LoadBalancing", () => {
+    expect(LoadBalancer.clones)
+      .to.be.an("Object")
+      .that.has.all.keys("on", "emit", "register", "dispatch", "assignDispatch", "clones")
+      .that.respondsTo("on")
+      .that.respondsTo("emit")
+      .that.respondsTo("register")
+      .that.respondsTo("dispatch")
+      .that.respondsTo("assignDispatch")
+      .that.has.property("clones")
+      .that.is.an("array");
+  });
+
+  it("should be able to use clones.register(connData, callback) method to host connection", async () => {
+    const Service = ServiceFactory();
+    const { route, port, host } = test_service1;
+    await Service.startService({ route, port, host });
+    LoadBalancer.clones.register({ route, port, host }, () => {});
+    const url = `http://localhost:${lbPort}/${route}`;
+    const connData = await HttpClient.request({ url });
+
+    expect(connData)
+      .to.be.an("Object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "host",
+        "port",
+        "modules",
+        "route",
+        "namespace",
+        "serviceUrl"
+      )
+      .that.has.property("modules")
+      .that.is.an("array")
+      .to.has.a.lengthOf(0);
+    expect(connData.serviceUrl).to.equal(`http://localhost:${port}/${route}`);
+  });
+
+  it("should be able to manager the routing to multiple clones of the same Service", async () => {
+    const { route, port1, port2, host } = test_service2;
+    const Clone1 = ServiceFactory();
+    const Clone2 = ServiceFactory();
+    await Clone1.startService({ route, port: port1, host });
+    await Clone2.startService({ route, port: port2, host });
+    LoadBalancer.clones.register({ route, port: port1, host }, () => {});
+    LoadBalancer.clones.register({ route, port: port2, host }, () => {});
+
+    const url = `http://localhost:${lbPort}/${route}`;
+
+    const connData1 = await HttpClient.request({ url });
+    expect(connData1.serviceUrl).to.equal(`http://localhost:${port1}/${route}`);
+    const connData2 = await HttpClient.request({ url });
+    expect(connData2.serviceUrl).to.equal(`http://localhost:${port2}/${route}`);
+  });
+
+  it("should be able to manage the route of multiple clones of multiple Services. aka Service Discovery", async () => {
+    const route1 = test_service1.route;
+    const route2 = test_service2.route;
+    const url1 = `http://localhost:${lbPort}/${route1}`;
+    const url2 = `http://localhost:${lbPort}/${route2}`;
+
+    const connData1 = await HttpClient.request({ url: url1 });
+    expect(connData1.route).to.equal(`/${route1}`);
+    const connData2 = await HttpClient.request({ url: url2 });
+    expect(connData2.route).to.equal(`/${route2}`);
+  });
+});

package/systemlynx/ServerManager/ServerManager.js

@@ -0,0 +1,113 @@
+"use strict";
+const SystemLynxServer = require("./components/Server");
+const SystemLynxRouter = require("./components/Router");
+const SocketEmitter = require("./components/SocketEmitter");
+const SystemLynxWebSocket = require("./components/WebSocketServer");
+const parseMethods = require("./components/parseMethods");
+const shortId = require("shortid");
+
+module.exports = function SystemLynxServerManager() {
+  let serverConfigurations = {
+    route: null,
+    port: null,
+    host: "localhost",
+    serviceUrl: null,
+    socketPort: null,
+    useREST: false,
+    useService: true,
+    staticRouting: false,
+    validateArgs: true,
+    middleware: [],
+    useCallbacks: true,
+    useReturnValues: false,
+  };
+  const server = SystemLynxServer();
+  const router = SystemLynxRouter(server, () => serverConfigurations);
+  const { SocketServer, WebSocket } = SystemLynxWebSocket();
+  const moduleQueue = [];
+  const modules = [];
+
+  const ServerManager = { Server: () => server, WebSocket: () => WebSocket };
+
+  ServerManager.startService = (options) => {
+    let { route, host = "localhost", port, socketPort, staticRouting } = options;
+
+    socketPort =
+      socketPort || parseInt(Math.random() * parseInt(Math.random() * 10000)) + 1023;
+    const namespace = staticRouting ? route : shortId();
+    SocketServer.listen(socketPort);
+    SocketEmitter.apply(ServerManager, [namespace, WebSocket]);
+
+    route = route.charAt(0) === "/" ? route.substr(1) : route;
+    route =
+      route.charAt(route.length - 1) === "/" ? route.substr(route.length - 1) : route;
+    const serviceUrl = `http://${host}:${port}/${route}`;
+    serverConfigurations = {
+      ...serverConfigurations,
+      ...options,
+      serviceUrl,
+      route,
+      socketPort,
+    };
+
+    server.get(`/${route}`, (req, res) => {
+      //The route will return connection data for the service including an array of
+      //modules (objects) which contain instructions on how to make request to each object
+      res.json({
+        modules,
+        port,
+        host,
+        route: `/${route}`,
+        serviceUrl,
+        namespace: `http://${host}:${socketPort}/${namespace}`,
+        SystemLynxService: true,
+      });
+    });
+
+    return new Promise((resolve) =>
+      server.listen(port, () => {
+        console.log(`(SystemLynxService): ${route} --> Listening on ${host}:${port}`);
+        moduleQueue.forEach(({ name, object, reserved_methods }) =>
+          ServerManager.addModule(name, object, reserved_methods)
+        );
+        moduleQueue.length = 0;
+        resolve(ServerManager);
+      })
+    );
+  };
+
+  ServerManager.addModule = (name, object, reserved_methods = []) => {
+    const { host, route, serviceUrl, staticRouting, useService, useREST, socketPort } =
+      serverConfigurations;
+
+    if (!serviceUrl) return moduleQueue.push({ name, object, reserved_methods });
+    const methods = parseMethods(object, ["on", "emit", ...reserved_methods], useREST);
+    const namespace = staticRouting ? name : shortId();
+
+    SocketEmitter.apply(object, [namespace, WebSocket]);
+
+    if (useService) {
+      const path = staticRouting ? `${route}/${name}` : `${shortId()}/${shortId()}`;
+
+      modules.push({
+        namespace: `http://${host}:${socketPort}/${namespace}`,
+        route: `/${path}`,
+        name,
+        methods,
+      });
+      methods.forEach((method) => router.addService(object, path, method, name));
+    }
+    if (useREST)
+      methods.forEach((method) => {
+        switch (method.fn) {
+          case "get":
+          case "put":
+          case "post":
+          case "delete":
+            router.addREST(object, `${route}/${name}`, method, name);
+        }
+      });
+  };
+
+  return ServerManager;
+};

package/systemlynx/ServerManager/components/Router.js

@@ -0,0 +1,89 @@
+const isObject = (value) =>
+  typeof value === "object" ? (!value ? false : !Array.isArray(value)) : false;
+const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
+const isPromise = (p) => typeof p === "object" && typeof p.then === "function";
+
+module.exports = function SystemLynxRouter(server, config) {
+  const addService = (ServerModule, route, { fn, method }, module_name) => {
+    server[method](
+      [`/${route}/${fn}`, `/sf/${route}/${fn}`, `/mf/${route}/${fn}`],
+      (req, res, next) => {
+        req.module_name = module_name;
+        req.fn = fn;
+        req.ServerModule = ServerModule;
+        next();
+      },
+      routeHandler
+    );
+  };
+
+  const addREST = (ServerModule, route, { method }, module_name) => {
+    server[method](
+      [`/${route}`],
+      (req, res, next) => {
+        req.module_name = module_name;
+        req.fn = method;
+        req.ServerModule = ServerModule;
+        next();
+      },
+      routeHandler
+    );
+  };
+
+  const routeHandler = (req, res) => {
+    const { query, file, files, body, fn, ServerModule, module_name, method } = req;
+    const { serviceUrl } = config();
+    const presets = { serviceUrl, module_name, fn };
+
+    const sendError = (error) => {
+      const status = error.status || 500;
+      const message = error.message || "Unexpected error";
+      const unhandledMessage = status === 500 ? "Unhandled error" : "Error";
+      res.status(status).json({
+        ...presets,
+        error,
+        status,
+        message: `[SystemLynx][error]: ${unhandledMessage} While calling ${module_name}.${fn}(...): ${message}`,
+        SystemLynxServiceError: true,
+      });
+    };
+
+    const sendResponse = (returnValue) => {
+      const status = returnValue.status || 200;
+      if (status < 400) {
+        res.status(status).json({
+          ...presets,
+          status,
+          message:
+            returnValue.message ||
+            `[SystemLynx][response]: ${module_name}.${fn}(...) returned successfully`,
+          returnValue,
+        });
+      } else sendError(returnValue);
+    };
+
+    if (typeof ServerModule[fn] !== "function")
+      return sendResponse({
+        message: `[SystemLynx][error]:${module_name}.${fn} method not found`,
+        status: 404,
+      });
+
+    try {
+      const args = body.__arguments || [];
+      if (!isEmpty(query) && !args.length) args.push(query);
+      if (isObject(args[0]) && method === "PUT") args[0] = { ...args[0], file, files };
+
+      const results = ServerModule[fn].apply(ServerModule, args);
+
+      if (isPromise(results)) {
+        results.then(sendResponse).catch(sendError);
+      } else {
+        sendResponse(results);
+      }
+    } catch (error) {
+      sendError(error);
+    }
+  };
+
+  return { addService, addREST };
+};

package/systemlynx/ServerManager/components/Server.js

@@ -0,0 +1,52 @@
+//express server, socket.io server and middleware needed for SystemLynx basic functionality
+
+module.exports = function SystemLynxServer() {
+  const cwd = process.cwd();
+  //express server
+  const express = require("express");
+  const server = express();
+  //express middleware
+  const bodyParser = require("body-parser");
+  const multer = require("multer");
+  //express file upload middleware setup
+  const TEMP_LOCATION = "./temp";
+  const mime = require("mime");
+  const shortId = require("shortid");
+  const storage = multer.diskStorage({
+    destination: (req, file, cb) => cb(null, TEMP_LOCATION),
+    filename: (req, file, cb) =>
+      cb(null, `${shortId()}.${mime.getExtension(file.mimetype)}`),
+  });
+  //multi-file and single-file upload middleware functions
+  const sf = multer({ storage: storage }).single("file");
+  const mf = multer({ storage: storage }).array("files");
+  //the sf and mf functions are used to a extract file from the req during a file upload
+  //a property named file and files will be added to the req object respectively
+  const singleFileUpload = (req, res, next) =>
+    sf(req, res, (err) => {
+      if (err) res.json(errorResponseBuilder(err));
+      else next();
+    });
+  const multiFileUpload = (req, res, next) =>
+    mf(req, res, (err) => {
+      if (err) res.json(errorResponseBuilder(err));
+      else next();
+    });
+
+  server.use("/sf", singleFileUpload);
+  server.use("/mf", multiFileUpload);
+  server.use(express.static(cwd + "/public"));
+  server.use(bodyParser.json({ limit: "5mb" }));
+
+  server.use((req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT ,DELETE");
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      "X-Requested-With,content-type, Authorization"
+    );
+    next();
+  });
+
+  return server;
+};

package/systemlynx/ServerManager/components/SocketEmitter.js

@@ -0,0 +1,19 @@
+"use strict";
+const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
+const shortid = require("shortid");
+module.exports = function SocketEmitter(namespace, WebSocket) {
+  const Emitter =
+    (this || {}).on && (this || {}).emit ? this : SystemLynxDispatcher.apply(this);
+
+  const socket = WebSocket.of(`/${namespace}`);
+  const emit = Emitter.emit;
+
+  Emitter.emit = (name, data) => {
+    const id = shortid();
+    const type = "WebSocket";
+    socket.emit("dispatch", { id, name, data, type });
+    //emit the same event locally
+    emit(name, data);
+  };
+  return Emitter;
+};

package/systemlynx/ServerManager/components/WebSocketServer.js

@@ -0,0 +1,7 @@
+module.exports = function SystemLynxWebWebSocket() {
+  const express = require("express");
+  const SocketServer = require("http").Server(express());
+  const WebSocket = require("socket.io")(SocketServer);
+
+  return { WebSocket, SocketServer };
+};

package/systemlynx/ServerManager/components/parseMethods.js

@@ -0,0 +1,19 @@
+const parseMethods = (obj, reserved_methods = [], useREST) => {
+  const methods = [];
+  const REST_methods = ["get", "put", "post", "delete"];
+  const props = Object.getOwnPropertyNames(obj);
+
+  props.forEach((fn) => {
+    if (typeof obj[fn] === "function" && reserved_methods.indexOf(fn) === -1) {
+      const method =
+        useREST && REST_methods.indexOf(fn.toLocaleLowerCase()) > -1
+          ? fn.toLocaleLowerCase()
+          : "put";
+      methods.push({ method, fn });
+    }
+  });
+
+  return methods;
+};
+
+module.exports = parseMethods;

package/systemlynx/ServerManager/tests/ServerManager.test.js

@@ -0,0 +1,197 @@
+const { expect } = require("chai");
+const SystemLynxServerManager = require("../ServerManager");
+const request = require("request");
+
+describe("SystemLynxServerManager function", () => {
+  it("should return an ServerManager instance", () => {
+    const ServerManager = SystemLynxServerManager();
+
+    expect(ServerManager)
+      .to.be.an("Object")
+      .that.has.all.keys(["startService", "addModule", "Server", "WebSocket"])
+      .that.respondsTo("startService")
+      .that.respondsTo("addModule")
+      .that.respondsTo("Server")
+      .that.respondsTo("WebSocket");
+  });
+});
+describe("ServerManager", () => {
+  it("should be able use ServerManager.startService to start a server that will accept requests for ServerModule Connection Data on the given route", async () => {
+    const ServerManager = SystemLynxServerManager();
+    const route = "/testService";
+    const port = 4400;
+    const url = `http://localhost:${port}${route}`;
+
+    await ServerManager.startService({ route, port });
+    const results = await new Promise((resolve) => {
+      request({ url, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results)
+      .to.be.an("Object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "serviceUrl",
+        "route",
+        "host",
+        "port",
+        "modules",
+        "namespace"
+      )
+      .that.has.property("modules")
+      .that.is.an("array").that.is.empty;
+  });
+
+  it("should be able to use the ServerManager.addModule method to add data to the ServerManager instance that can be accessed via a GET request", async () => {
+    const ServerManager = SystemLynxServerManager();
+    const route = "/testService";
+    const port = 4634;
+    const url = `http://localhost:${port}${route}`;
+    const name = "TestModule";
+    await ServerManager.startService({ route, port });
+
+    ServerManager.addModule(name, {});
+    ServerManager.addModule(name + 1, {});
+    const results = await new Promise((resolve) => {
+      request({ url, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results)
+      .to.be.an("object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "serviceUrl",
+        "route",
+        "host",
+        "port",
+        "modules",
+        "namespace"
+      )
+      .that.has.property("modules")
+      .that.is.an("array")
+      .that.has.a.lengthOf(2);
+    expect(results.modules[0])
+      .to.be.an("object")
+      .that.has.all.keys("name", "methods", "route", "namespace");
+  });
+
+  it("should be able call ServerManager.addModule method before or after calling ServerManager.startService", async () => {
+    const ServerManager = SystemLynxServerManager();
+    const route = "/testService";
+    const port = 4500;
+    const url = `http://localhost:${port}${route}`;
+    const name = "TestModule";
+
+    ServerManager.addModule(name, {});
+    ServerManager.addModule(name + 1, {});
+
+    await ServerManager.startService({ route, port });
+
+    const results = await new Promise((resolve) => {
+      request({ url, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results)
+      .to.be.an("object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "serviceUrl",
+        "route",
+        "host",
+        "port",
+        "modules",
+        "namespace"
+      )
+      .that.has.property("modules")
+      .that.is.an("array")
+      .that.has.a.lengthOf(2);
+    expect(results.modules[0])
+      .to.be.an("object")
+      .that.has.all.keys("name", "methods", "route", "namespace");
+  });
+});
+
+describe("ServerManager.startService(ServerConfiguration)", () => {
+  it("should be able to use the useREST=true property to create a REST API route for any method with the name 'get', 'put', 'post' or 'delete'", async () => {
+    const ServerManager = SystemLynxServerManager();
+    const route = "/testAPI";
+    const port = 8372;
+    const url = `http://localhost:${port}${route}`;
+    const name = "testObject";
+    const object = {
+      get: () => (null, { REST_TEST_PASSED: true }),
+      put: () => {},
+      post: () => {},
+      delete: () => {},
+    };
+
+    ServerManager.addModule(name, object);
+
+    await ServerManager.startService({
+      route,
+      port,
+      useREST: true,
+    });
+
+    const results = await new Promise((resolve) => {
+      request({ url: `${url}/${name}`, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results).to.deep.equal({
+      fn: "get",
+      message: "[SystemLynx][response]: testObject.get(...) returned successfully",
+      module_name: "testObject",
+      returnValue: {
+        REST_TEST_PASSED: true,
+      },
+      serviceUrl: "http://localhost:8372/testAPI",
+      status: 200,
+    });
+  });
+
+  it("should be able to use the staticRouting=true property to create static routes to the ServerModules", async () => {
+    const ServerManager = SystemLynxServerManager();
+    const route = "/testAPI";
+    const port = 2233;
+    const url = `http://localhost:${port}${route}`;
+    const name = "testObject";
+    const object = {
+      get: () => (null, { SERVICE_TEST_PASSED: true }),
+      put: () => (null, { SERVICE_TEST_PASSED: true }),
+      post: () => {},
+      delete: () => {},
+    };
+
+    ServerManager.addModule(name, object);
+
+    await ServerManager.startService({
+      route,
+      port,
+      staticRouting: true,
+      useREST: true,
+    });
+
+    const results = await new Promise((resolve) => {
+      request({ url: `${url}/${name}/get`, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results).to.deep.equal({
+      returnValue: { SERVICE_TEST_PASSED: true },
+      fn: "get",
+      message: "[SystemLynx][response]: testObject.get(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:2233/testAPI",
+      status: 200,
+    });
+  });
+});

package/systemlynx/ServerManager/tests/SocketEmitter.test.js

@@ -0,0 +1,29 @@
+const { expect } = require("chai");
+const SocketEmiiter = require("../components/SocketEmitter");
+const { WebSocket, SocketServer } = require("../components/WebSocketServer")();
+const io = require("socket.io-client");
+
+describe("SocketEmiiter", () => {
+  it("should be able to use emmiter.emit(name, data) to dispatch events to a websockt client", done => {
+    const namespace = "test-namespace";
+    const port = 5556;
+    const eventName = "test-event";
+    SocketServer.listen(port);
+    const emmiter = SocketEmiiter(namespace, WebSocket);
+
+    setTimeout(() => {
+      emmiter.emit(eventName, { testPassed: true });
+    }, 500);
+    const socket = io.connect(`http://localhost:${port}/${namespace}`);
+    socket.on("dispatch", dispatch => {
+      expect(dispatch)
+        .to.be.an("object")
+        .that.has.all.keys("id", "name", "data", "type");
+      expect(dispatch.name).to.equal(eventName);
+      expect(dispatch.data).to.deep.equal({ testPassed: true });
+      done();
+    });
+    socket.on("disconnect", () => console.log("---------> disconnect"));
+    socket.on("connect", () => console.log(`socket connected to namespace: ${namespace}`));
+  });
+});