sockethub 5.0.0-alpha.2 → 5.0.0-alpha.4

package/src/platform.ts

@@ -1,189 +0,0 @@
-import debug from 'debug';
-import hash from "object-hash";
-import config from './config';
-import Queue from 'bull';
-import { getPlatformId, decryptJobData } from "./common";
-import { ActivityStream, JobDataDecrypted, JobEncrypted } from "./sockethub";
-import { MessageFromParent } from './platform-instance';
-import { getSessionStore } from "./store";
-
-// command-line params
-const parentId = process.argv[2];
-const platformName = process.argv[3];
-let identifier = process.argv[4];
-const loggerPrefix = `sockethub:platform:${platformName}:${identifier}`;
-let logger = debug(loggerPrefix);
-
-const PlatformModule = require(`sockethub-platform-${platformName}`);
-
-let queueStarted = false;
-let parentSecret1: string, parentSecret2: string;
-
-logger(`platform handler initialized for ${platformName} ${identifier}`);
-
-export interface PlatformSession {
-  debug(msg: string): void;
-  sendToClient(msg: ActivityStream, special?: string): void;
-  updateActor(credentials: object): void;
-}
-
-/**
- * Handle any uncaught errors from the platform by alerting the worker and shutting down.
- */
-process.on('uncaughtException', (err) => {
-  console.log('EXCEPTION IN PLATFORM');
-  // eslint-disable-next-line security-node/detect-crlf
-  console.log(err.stack);
-  process.send(['error', err.toString()]);
-  process.exit(1);
-});
-
-/**
- * Incoming messages from the worker to this platform. Data is an array, the first property is the
- * method to call, the rest are params.
- */
-process.on('message', (data: MessageFromParent) => {
-  if (data[0] === 'secrets') {
-    parentSecret1 = data[1].parentSecret1;
-    parentSecret2 = data[1].parentSecret2;
-    startQueueListener();
-  }
-});
-
-
-/**
- * Initialize platform module
- */
-const platformSession: PlatformSession = {
-  debug: debug(`sockethub:platform:${platformName}:${identifier}`),
-  sendToClient: getSendFunction('message'),
-  updateActor: updateActor
-};
-const platform = new PlatformModule(platformSession);
-
-/**
- * Get the credentials stored for this user in this sessions store, if given the correct
- * sessionSecret.
- * @param actorId
- * @param sessionId
- * @param sessionSecret
- * @param cb
- */
-function getCredentials(actorId: string, sessionId: string, sessionSecret: string, cb: Function) {
-  if (platform.config.noCredentials) { return cb(); }
-  const store = getSessionStore(parentId, parentSecret1, sessionId, sessionSecret);
-  store.get(actorId, (err, credentials) => {
-    if (platform.config.persist) {
-      // don't continue if we don't get credentials
-      if (err) { return cb(err); }
-    } else if (! credentials) {
-      // also skip if this is a non-persist platform with no credentials
-      return cb();
-    }
-
-    if (platform.credentialsHash) {
-      if (platform.credentialsHash !== hash(credentials.object)) {
-        return cb('provided credentials do not match existing platform instance for actor '
-            + platform.actor.id);
-      }
-    } else {
-      platform.credentialsHash = hash(credentials.object);
-    }
-    cb(undefined, credentials);
-  });
-}
-
-/**
- * Returns a function used to handle completed jobs from the platform code (the `done` callback).
- * @param secret the secret used to decrypt credentials
- */
-function getJobHandler(secret: string) {
-  return (job: JobEncrypted, done: Function) => {
-    const jobData: JobDataDecrypted = decryptJobData(job, secret);
-    const jobLog = debug(`${loggerPrefix}:${jobData.sessionId}`);
-    jobLog(`received ${jobData.title} ${jobData.msg.type}`);
-    const sessionSecret = jobData.msg.sessionSecret;
-    delete jobData.msg.sessionSecret;
-
-    return getCredentials(jobData.msg.actor.id, jobData.sessionId, sessionSecret,
-      (err, credentials) => {
-        if (err) { return done(new Error(err)); }
-        let jobCallbackCalled = false;
-        const doneCallback = (err, result) => {
-          if (jobCallbackCalled) { return; }
-          jobCallbackCalled = true;
-          if (err) {
-            jobLog(`errored ${jobData.title} ${jobData.msg.type}`);
-            let errMsg;
-            // some error objects (eg. TimeoutError) don't interoplate correctly to human-readable
-            // so we have to do this little dance
-            try {
-              errMsg = err.toString();
-            } catch (e) {
-              errMsg = err;
-            }
-            done(new Error(errMsg));
-          } else {
-            jobLog(`completed ${jobData.title} ${jobData.msg.type}`);
-            done(null, result);
-          }
-        };
-        if ((Array.isArray(platform.config.requireCredentials)) &&
-          (platform.config.requireCredentials.includes(jobData.msg.type))) {
-          // add the credentials object if this method requires it
-          platform[jobData.msg.type](jobData.msg, credentials, doneCallback);
-        } else if (platform.config.persist) {
-          if (platform.initialized) {
-            platform[jobData.msg.type](jobData.msg, doneCallback);
-          } else {
-            done(new Error(`${jobData.msg.type} called on uninitialized platform`));
-          }
-        } else {
-          platform[jobData.msg.type](jobData.msg, doneCallback);
-        }
-      });
-  };
-}
-
-/**
- * Get an function which sends a message to the parent thread (PlatformInstance). The platform
- * can call that function to send messages back to the client.
- * @param command string containing the type of command to be sent. 'message' or 'close'
- */
-function getSendFunction(command: string) {
-  return function (msg: ActivityStream, special?: string) {
-    process.send([command, msg, special]);
-  };
-}
-
-/**
- * When a user changes it's actor name, the channel identifier changes, we need to ensure that
- * both the queue thread (listening on the channel for jobs) and the logging object are updated.
- * @param credentials
- */
-function updateActor(credentials) {
-  identifier = getPlatformId(platformName, credentials.actor.id);
-  logger(`platform actor updated to ${credentials.actor.id} identifier ${identifier}`);
-  logger = debug(`sockethub:platform:${identifier}`);
-  platform.credentialsHash = hash(credentials.object);
-  platform.debug = debug(`sockethub:platform:${platformName}:${identifier}`);
-  process.send(['updateActor', undefined, identifier]);
-  startQueueListener(true);
-}
-
-/**
- * starts listening on the queue for incoming jobs
- * @param refresh boolean if the param is true, we re-init the queue.process
- * (used when identifier changes)
- */
-function startQueueListener(refresh: boolean = false) {
-  const secret = parentSecret1 + parentSecret2;
-  if ((queueStarted) && (!refresh)) {
-    logger('start queue called multiple times, skipping');
-    return;
-  }
-  const queue = new Queue(parentId + identifier, { redis: config.get('redis') });
-  queueStarted = true;
-  logger('listening on the queue for incoming jobs');
-  queue.process(getJobHandler(secret));
-}

package/src/process-manager.ts

@@ -1,64 +0,0 @@
-import init from './bootstrap/init';
-import PlatformInstance, {
-  platformInstances, PlatformInstanceParams, MessageFromParent } from "./platform-instance";
-import { getPlatformId } from "./common";
-
-class ProcessManager {
-  private readonly parentId: string;
-  private readonly parentSecret1: string;
-  private readonly parentSecret2: string;
-
-  constructor(parentId: string, parentSecret1: string, parentSecret2: string) {
-    this.parentId = parentId;
-    this.parentSecret1 = parentSecret1;
-    this.parentSecret2 = parentSecret2;
-  }
-
-  get(platform: string, actorId: string, sessionId?: string): PlatformInstance {
-    const platformDetails = init.platforms.get(platform);
-    let pi;
-
-    if (platformDetails.config.persist) {
-      // ensure process is started - one for each actor
-      pi = this.ensureProcess(platform, sessionId, actorId);
-    } else {
-      // ensure process is started - one for all jobs
-      pi = this.ensureProcess(platform);
-    }
-    pi.config = platformDetails.config;
-    return pi;
-  }
-
-  private createPlatformInstance(identifier: string, platform: string,
-                                 actor?: string): PlatformInstance {
-    const secrets: MessageFromParent = [
-      'secrets', {
-        parentSecret1: this.parentSecret1,
-        parentSecret2: this.parentSecret2
-      }
-    ];
-    const platformInstanceConfig: PlatformInstanceParams = {
-      identifier: identifier,
-      platform: platform,
-      parentId: this.parentId,
-      actor: actor
-    };
-    const platformInstance = new PlatformInstance(platformInstanceConfig);
-    platformInstance.initQueue(this.parentSecret1 + this.parentSecret2);
-    platformInstance.process.send(secrets);
-    return platformInstance;
-  }
-
-  private ensureProcess(platform: string, sessionId?: string, actor?: string): PlatformInstance {
-    const identifier = getPlatformId(platform, actor);
-    const platformInstance = platformInstances.get(identifier) ||
-              this.createPlatformInstance(identifier, platform, actor);
-    if (sessionId) {
-      platformInstance.registerSession(sessionId);
-    }
-    platformInstances.set(identifier, platformInstance);
-    return platformInstance;
-  }
-}
-
-export default ProcessManager;

package/src/routes.test.ts

@@ -1,100 +0,0 @@
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-import { existsSync } from "fs";
-
-import routes, { basePaths, examplePaths, examplePages } from "./routes";
-
-describe('routes/base', () => {
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  it('can find each of the base files it serves', () => {
-    Object.values(basePaths).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
-    });
-  });
-
-  it('can find each of the example files it serves', () => {
-    Object.values(examplePaths).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
-    });
-  });
-
-  it('can find each of the example page files it serves', () => {
-    Object.values(examplePages).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
-    });
-  });
-
-  it('adds base routes', () => {
-    const app = {
-      get: sinon.spy()
-    };
-    routes.setup(app, false);
-    sinon.assert.callCount(
-      app.get,
-      Object.keys(basePaths).length
-    );
-  });
-
-  it('adds base and example routes', () => {
-    const app = {
-      get: sinon.spy()
-    };
-    routes.setup(app, true);
-    sinon.assert.callCount(
-      app.get,
-      Object.keys(basePaths).length
-      + Object.keys(examplePaths).length
-      + Object.keys(examplePages).length
-    );
-  });
-
-  it('handles calls to base routes as expected', () => {
-    let routeHandlers = {};
-    let app = {
-      get: (path, route) => {
-        routeHandlers[path] = route;
-      }
-    };
-    routes.setup(app, true);
-
-    function verifyPathRoutes(pathMap) {
-      Object.keys(pathMap).forEach((path) => {
-        const res = {
-          setHeader: sinon.spy(),
-          sendFile: sinon.spy()
-        };
-        expect(pathMap[path].endsWith('.ejs')).to.be.false;
-        routeHandlers[path]({url: path}, res);
-        sinon.assert.called(res.setHeader);
-        sinon.assert.calledWith(res.sendFile, pathMap[path]);
-      });
-    }
-    verifyPathRoutes(basePaths);
-    verifyPathRoutes(examplePaths);
-
-    Object.keys(examplePages).forEach((path) => {
-      const res = {
-        render: sinon.spy()
-      };
-      expect(examplePages[path].endsWith('.ejs')).to.be.true;
-      routeHandlers[path]({url: path}, res);
-      sinon.assert.called(res.render);
-    });
-  });
-});

package/src/routes.ts

@@ -1,93 +0,0 @@
-import path from 'path';
-import config from "./config";
-import debug from 'debug';
-
-const debug_scope = process.env.DEBUG || '',
-      logger      = debug('sockethub:routes'),
-      address     = config.get('public:protocol') + '://' +
-                    config.get('public:host') + ':' +
-                    config.get('public:port') +
-                    config.get('public:path');
-
-export const basePaths = {
-  '/sockethub-client.js': path.resolve(`${__dirname}/../dist/sockethub-client.js`),
-  '/sockethub-client.min.js': path.resolve(`${__dirname}/../dist/sockethub-client.min.js`),
-  '/sockethub-client.js.map': path.resolve(`${__dirname}/../dist/sockethub-client.js.map`),
-  '/socket.io.js': path.resolve(`${__dirname}/../node_modules/socket.io/client-dist/socket.io.js`),
-  '/socket.io.js.map': path.resolve(
-    `${__dirname}/../node_modules/socket.io/client-dist/socket.io.js.map`),
-};
-
-export const examplePaths = {
-  '/jquery.js': path.resolve(`${__dirname}/../node_modules/jquery/dist/jquery.min.js`),
-  '/jquery.min.map': path.resolve(`${__dirname}/../node_modules/jquery/dist/jquery.min.map`),
-  '/examples/shared.js': path.resolve(`${__dirname}/../views/examples/shared.js`)
-};
-
-export const examplePages = {
-  '/': path.resolve(`${__dirname}/../views/index.ejs`),
-  '/examples/dummy': path.resolve(`${__dirname}/../views/examples/dummy.ejs`),
-  '/examples/feeds': path.resolve(`${__dirname}/../views/examples/feeds.ejs`),
-  '/examples/irc': path.resolve(`${__dirname}/../views/examples/irc.ejs`),
-  '/examples/xmpp': path.resolve(`${__dirname}/../views/examples/xmpp.ejs`)
-};
-
-
-function prepFileRoutes(pathMap) {
-  let _routes = [];
-  Object.keys(pathMap).forEach((key) => {
-    _routes.push({
-      meta: {
-        method: 'GET',
-        path: key
-      },
-      route: (req, res) => {
-        logger(`serving resource ${req.url}`);
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.sendFile(pathMap[req.url]);
-      }
-    });
-  });
-  return _routes;
-}
-const baseRoutes = prepFileRoutes(basePaths);
-const exampleRoutes = prepFileRoutes(examplePaths);
-
-
-Object.keys(examplePages).forEach((key) => {
-  exampleRoutes.push({
-    meta: {
-      method: 'GET',
-      path: key
-    },
-    route: (req, res) => {
-      logger(`serving page ${req.url}`);
-      res.render(examplePages[req.url], {
-        debug_scope: debug_scope,
-        address: address,
-      });
-    }
-  });
-});
-
-function addRoute(app) {
-  return (route) => {
-    app[route.meta.method.toLowerCase()](
-      route.meta.path,
-      route.route
-    );
-  };
-}
-
-/**
- * Setup
- */
-const routes = {
-  setup: function (app: any, examplesEnabled: boolean = config.get('examples:enabled')) {
-    baseRoutes.forEach(addRoute(app));
-    if (examplesEnabled) {
-      exampleRoutes.forEach(addRoute(app));
-    }
-  }
-};
-export default routes;

package/src/serve.ts

@@ -1,79 +0,0 @@
-import debug from 'debug';
-import bodyParser from 'body-parser';
-import express from 'express';
-import * as HTTP from 'http';
-import { Server } from 'socket.io';
-
-import config from './config';
-import routes from './routes';
-
-const log = debug('sockethub:services:http');
-
-/**
- * Handles the initialization and access of service objects.
- *
- *  - HTTP Server
- *  - Express (service resources and example routes)
- *  - Socket.io (bidirectional websocket communication)
- */
-class Serve {
-  io: Server;
-  http: HTTP.Server;
-
-  /**
-   * Starts the services needed for sockethub to operate. After this command completes,
-   * the `http` and `io` class properties will be set.
-   */
-  start() {
-    // initialize express and socket.io objects
-    const app = Serve.initExpress();
-    this.http = new HTTP.Server(app);
-    this.io = new Server(this.http, {
-      path: config.get('service:path'),
-      cors: {
-        origin: "*",
-        methods: [ "GET", "POST" ]
-      }
-    });
-    routes.setup(app);
-    this.startListener();
-  }
-
-  private startListener() {
-    this.http.listen(config.get('service:port'), config.get('service:host'), () => {
-      log(`sockethub listening on ` +
-        `http://${config.get('service:host')}:${config.get('service:port')}`);
-    });
-  };
-
-  private static initExpress() {
-    let app = express();
-    // templating engines
-    app.set('view engine', 'ejs');
-    // use bodyParser
-    app.use(bodyParser.urlencoded({extended: true}));
-    app.use(bodyParser.json());
-    return app;
-  }
-}
-
-const serve = new Serve();
-
-export interface SocketInstance {
-  id: string;
-  emit: Function;
-}
-
-export async function getSocket(sessionId: string): Promise<SocketInstance> {
-  const sockets: Array<SocketInstance> = await serve.io.fetchSockets();
-  return new Promise((resolve, reject) => {
-    for (let socket of sockets) {
-      if (sessionId === socket.id) {
-        return resolve(socket);
-      }
-    }
-    return reject(`unable to find socket for sessionId ${sessionId}`);
-  });
-}
-
-export default serve;