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

package/src/middleware.test.ts

@@ -1,148 +0,0 @@
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-
-import middleware, { MiddlewareChain } from "./middleware";
-
-describe("Middleware", () => {
-  it("middleware() is a function", () => {
-    expect(typeof middleware).to.be.equal('function');
-  });
-
-  it('returns a MiddlewareChain instance', () => {
-    const mw = middleware('testa');
-    expect(mw).to.be.instanceof(MiddlewareChain);
-    const mwc = new MiddlewareChain('testa');
-    expect(mw.name).to.be.eql(mwc.name);
-  });
-
-  it("only accepts functions", () => {
-    const mw = middleware('test');
-    // @ts-ignore
-    expect(()=>{mw.use('foobar');}).to.throw(
-      'middleware use() can only take a function as an argument');
-  });
-
-  it("only accepts functions that expect 2 or 3 params", () => {
-    const mw = middleware('test');
-    // @ts-ignore
-    expect(()=>{mw.use((one, two, three, four) => {});}).to.throw(
-      'middleware function provided with incorrect number of params: 4');
-  });
-
-  it("calls each member of call list", (done) => {
-    const callback = (data, cb) => { cb(data); };
-    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callback) ];
-    const mw = middleware('test');
-    for (let func of funcs) {
-      mw.use(func);
-    }
-    mw.done()('some data', (data) => {
-      expect(data).to.eql('some data');
-      funcs.unshift(callback);
-      for (let i = 1; i < funcs.length; i++) {
-        expect(funcs[i].calledOnce).to.be.true;
-        expect(funcs[i].calledWith('foobar', funcs[i - 1]));
-      }
-      done();
-    });
-  });
-
-  it("does not throw exception on error with no callback provided", (done) => {
-    let errorHandlerCalled = false;
-    const callbackError = (data, cb) => {
-      cb(new Error('some error')); };
-    const funcs = [ sinon.spy(callbackError) ];
-    const mw = middleware('test');
-    for (let func of funcs) {
-      const entry = mw.use(func);
-    }
-    mw.use((err, data, next) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      next(err);
-    });
-    mw.done()('foobar', () => {
-      expect(errorHandlerCalled).to.be.true;
-      done();
-    });
-  });
-
-  it("aborts call stack on error - calls error handler, and callback", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data, cb) => { cb(data); };
-    const callbackError = (data, cb) => { cb(new Error('some error')); };
-    const funcs = [ sinon.spy(callback), sinon.spy(callbackError), sinon.spy(callback) ];
-    const mw = middleware('test');
-    for (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err, data, next) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      next(err);
-    });
-    mw.done()('foobar', (data) => {
-      // FIXME -- We need to also handle socket.io callbacks!
-      expect(data instanceof Error).to.be.true;
-      expect(funcs[0].calledOnce).to.be.true;
-      expect(funcs[0].calledWith('foobar', callback));
-      expect(funcs[1].calledOnce).to.be.true;
-      expect(funcs[1].calledWith('foobar', funcs[0]));
-      expect(funcs[2].calledOnce).to.be.false;
-      expect(errorHandlerCalled).to.be.true;
-      done();
-    });
-  });
-
-  it("error handler receives error and no callback provided", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data, cb) => { cb(data); };
-    const callbackError = (data, cb) => { cb(new Error('some error')); };
-    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callbackError) ];
-    const mw = middleware('test');
-    for (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err, data, next) => {
-      expect(err instanceof Error).to.be.true;
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      expect(funcs[0].calledOnce).to.be.true;
-      expect(funcs[0].calledWith('foobar', callback));
-      expect(funcs[1].calledOnce).to.be.true;
-      expect(funcs[1].calledWith('foobar', funcs[0]));
-      expect(funcs[2].calledOnce).to.be.true;
-      expect(funcs[2].calledWith('foobar', funcs[1]));
-      expect(errorHandlerCalled).to.be.true;
-      setTimeout(done, 0);
-    });
-    mw.done()('foobar', () => {});
-  });
-
-  it("calls each member of chain (50)", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data, cb) => { cb(data); };
-    let funcs = [];
-    for (let i = 0; i <= 50; i++) {
-      funcs.push(sinon.spy(callback));
-    }
-    const mw = middleware('test');
-    for (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err, next, data) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-    });
-    mw.done()('some data', (data) => {
-      expect(data).to.equal('some data');
-      funcs.unshift(callback);
-      for (let i = 1; i < funcs.length; i++) {
-        expect(funcs[i].calledOnce).to.be.true;
-        expect(funcs[i].calledWith('foo', funcs[i - 1]));
-      }
-      expect(errorHandlerCalled).to.be.false;
-      done();
-    });
-  });
-});

package/src/middleware.ts

@@ -1,52 +0,0 @@
-import { debug } from 'debug';
-
-export default function middleware(name: string): MiddlewareChain {
-  return new MiddlewareChain(name);
-}
-
-export class MiddlewareChain {
-  public name: string;
-  private chain: Array<Function> = [];
-  private errHandler: Function = (err: Error) => { throw err; };
-  private logger: Function;
-
-  constructor(name: string) {
-    this.name = name;
-    this.logger = debug(`sockethub:middleware:${name}`);
-  }
-
-  use(func: Function): this {
-    if (typeof func !== 'function') {
-      throw new Error('middleware use() can only take a function as an argument');
-    }
-    if (func.length === 3) {
-      this.errHandler = func;
-    } else if (func.length === 2) {
-      this.chain.push(func);
-    } else {
-      throw new Error(
-        'middleware function provided with incorrect number of params: ' + func.length);
-    }
-    return this;
-  }
-
-  done() {
-    return (data: any, callback: Function) => {
-      let position = 0;
-      if (typeof callback !== 'function') {
-        callback = () => {};
-      }
-      const next = (_data: any) => {
-        if (_data instanceof Error) {
-          this.logger(_data);
-          this.errHandler(_data, data, callback);
-        } else if (typeof this.chain[position] === 'function') {
-          this.chain[position++](_data, next);
-        } else {
-          callback(_data);
-        }
-      };
-      next(data);
-    };
-  }
-}

package/src/platform-instance.test.ts

@@ -1,237 +0,0 @@
-import proxyquire from 'proxyquire';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-
-proxyquire.noPreserveCache();
-proxyquire.noCallThru();
-
-const FORK_PATH = __dirname + '/platform.js';
-
-describe("PlatformInstance", () => {
-  let pi, sandbox, forkFake, socketMock, getSocketFake, PlatformInstance, platformInstances;
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox();
-    forkFake = sandbox.fake();
-    socketMock = {
-      emit: sandbox.spy()
-    };
-    getSocketFake = sinon.fake.resolves(socketMock);
-
-    const PlatformInstanceMod = proxyquire('./platform-instance', {
-      'bull': sandbox.stub().returns({
-        on: sandbox.stub()
-      }),
-      './store': {
-        redisConfig: {
-          createClient: () => {}
-        }
-      },
-      'child_process': {
-        fork: forkFake,
-        ChildProcess: sandbox.stub()
-      },
-      './serve': {
-        'io': {
-          'in': sandbox.stub().returns({
-            fetchSockets: () => {
-              return [socketMock];
-            }
-          })
-        },
-        getSocket: getSocketFake
-      }
-    });
-    PlatformInstance = PlatformInstanceMod.default;
-    platformInstances = PlatformInstanceMod.platformInstances;
-  });
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  describe('private instance per-actor', () => {
-    it("is set as non-global when an actor is provided", () => {
-      const pi = new PlatformInstance({
-        identifier: 'id',
-        platform: 'name',
-        parentId: 'parentId',
-        actor: 'actor string'
-      });
-      expect(pi.global).to.be.equal(false);
-      sandbox.assert.calledWith(forkFake, FORK_PATH, ['parentId', 'name', 'id']);
-      pi.destroy();
-    });
-  });
-
-  describe('PlatformInstance objects', () => {
-    beforeEach(() => {
-      pi = new PlatformInstance({
-        identifier: 'platform identifier',
-        platform: 'a platform name',
-        parentId: 'the parentId'
-      });
-      platformInstances.set(pi.id, pi);
-
-      pi.process = {
-        on: sandbox.spy(),
-        removeListener: sandbox.spy(),
-        removeAllListeners: sandbox.spy(),
-        unref: sandbox.spy(),
-        kill: sandbox.spy(),
-      };
-    });
-
-    afterEach(() => {
-      pi.destroy();
-    });
-
-    it('has expected properties', () => {
-      expect(typeof PlatformInstance).to.be.equal('function');
-    });
-
-    it('should have a platformInstances Map', () => {
-      expect(platformInstances instanceof Map).to.be.equal(true);
-    });
-
-    it("has certain accessible properties", () => {
-      expect(pi.id).to.be.equal('platform identifier');
-      expect(pi.name).to.be.equal('a platform name');
-      expect(pi.parentId).to.be.equal('the parentId');
-      expect(pi.flaggedForTermination).to.be.equal(false);
-      expect(pi.global).to.be.equal(true);
-      expect(forkFake.calledWith(FORK_PATH, [
-        'the parentId', 'a platform name', 'platform identifier'
-      ])).to.be.ok;
-    });
-
-    describe('registerSession', () => {
-      beforeEach(() => {
-        pi.callbackFunction = sandbox.fake();
-      });
-
-      it('adds a close and message handler when a session is registered', () => {
-        pi.registerSession('my session id');
-        expect(pi.callbackFunction.callCount).to.equal(2);
-        sandbox.assert.calledWith(pi.callbackFunction, 'close', 'my session id');
-        sandbox.assert.calledWith(pi.callbackFunction, 'message', 'my session id');
-        expect(pi.sessions.has('my session id')).to.be.equal(true);
-      });
-
-      it('is able to generate failure reports', () => {
-        pi.registerSession('my session id');
-        expect(pi.sessions.has('my session id')).to.be.equal(true);
-        pi.reportError('my session id', 'an error message');
-        pi.sendToClient = sandbox.stub();
-        pi.destroy = sandbox.stub();
-        expect(pi.sessions.size).to.be.equal(0);
-      });
-    });
-
-    it('initializes the job queue', () => {
-      expect(pi.queue).to.be.undefined;
-      pi.initQueue('a secret');
-      expect(pi.queue).to.be.ok;
-    });
-
-    it("cleans up its references when destroyed", async () => {
-      pi.initQueue('a secret');
-      expect(pi.queue).to.be.ok;
-      expect(platformInstances.has('platform identifier')).to.be.true;
-      await pi.destroy();
-      expect(pi.queue).not.to.be.ok;
-      expect(platformInstances.has('platform identifier')).to.be.false;
-    });
-
-    it("updates its identifier when changed", () => {
-      pi.updateIdentifier('foo bar');
-      expect(pi.id).to.be.equal('foo bar');
-      expect(platformInstances.has('platform identifier')).to.be.false;
-      expect(platformInstances.has('foo bar')).to.be.true;
-    });
-
-    it('sends messages to client using socket session id', async () => {
-      await pi.sendToClient('my session id',
-        {foo: 'this is a message object', sessionSecret: 'private data'});
-      expect(getSocketFake.callCount).to.equal(1);
-      sandbox.assert.calledOnce(getSocketFake);
-      sandbox.assert.calledWith(getSocketFake, 'my session id');
-      sandbox.assert.calledOnce(socketMock.emit);
-      sandbox.assert.calledWith(
-        socketMock.emit, 'message', {foo:'this is a message object', context: 'a platform name'});
-    });
-
-    it('broadcasts to peers', async () => {
-      pi.sessions.add('other peer');
-      pi.sessions.add('another peer');
-      await pi.broadcastToSharedPeers('myself', {foo: 'bar'});
-      expect(getSocketFake.callCount).to.equal(2);
-      sandbox.assert.calledWith(getSocketFake, 'other peer');
-    });
-
-    describe('handleJobResult', () => {
-      beforeEach(() => {
-        pi.sendToClient = sandbox.fake();
-        pi.broadcastToSharedPeers = sandbox.fake();
-      });
-
-      it('broadcasts to peers when handling a completed job', async () => {
-        pi.sessions.add('other peer');
-        await pi.handleJobResult('completed', {msg: {foo: 'bar'}},
-          undefined);
-        expect(pi.sendToClient.callCount).to.equal(1);
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-      });
-
-      it('appends completed result message when present', async () => {
-        await pi.handleJobResult('completed', {sessionId: 'a session id', msg: {foo: 'bar'}},
-          'a good result message');
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
-          {foo: 'bar'});
-      });
-
-      it('appends failed result message when present', async () => {
-        await pi.handleJobResult('failed', {sessionId: 'a session id', msg: {foo: 'bar'}},
-          'a bad result message');
-        expect(pi.broadcastToSharedPeers.callCount).to.equal(1);
-        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
-          {foo: 'bar', error: 'a bad result message'});
-      });
-    });
-
-    describe('callbackFunction', () => {
-      beforeEach(() => {
-        pi.reportError = sandbox.fake();
-        pi.sendToClient = sandbox.fake();
-        pi.updateIdentifier = sandbox.fake();
-      });
-
-      it('close events from platform thread are reported', () => {
-        const close = pi.callbackFunction('close', 'my session id');
-        close('error msg');
-        sandbox.assert.calledWith(pi.reportError,
-          'my session id', 'Error: session thread closed unexpectedly: error msg');
-      });
-
-      it('message events from platform thread are route based on command: error', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['error', 'error message']);
-        sandbox.assert.calledWith(pi.reportError, 'my session id', 'error message');
-      });
-
-      it('message events from platform thread are route based on command: updateActor', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['updateActor', undefined, {foo: 'bar'}]);
-        sandbox.assert.calledWith(pi.updateIdentifier, {foo:'bar'});
-      });
-
-      it('message events from platform thread are route based on command: else', () => {
-        const message = pi.callbackFunction('message', 'my session id');
-        message(['blah', {foo: 'bar'}]);
-        sandbox.assert.calledWith(pi.sendToClient,
-          'my session id', {foo:'bar'});
-      });
-    });
-  });
-});

package/src/platform-instance.ts

@@ -1,236 +0,0 @@
-import { ChildProcess, fork } from 'child_process';
-import { join } from 'path';
-import { debug, Debugger } from 'debug';
-import Queue from 'bull';
-
-import config from "./config";
-import { ActivityStream, JobDataDecrypted, JobEncrypted } from "./sockethub";
-import { getSocket } from "./serve";
-import { decryptJobData } from "./common";
-
-// collection of platform instances, stored by `id`
-export const platformInstances = new Map<string, PlatformInstance>();
-
-export interface PlatformInstanceParams {
-  identifier: string;
-  platform: string;
-  parentId?: string;
-  actor?: string;
-}
-
-interface MessageFromPlatform extends Array<string|ActivityStream>{
-  0: string, 1: ActivityStream, 2: string}
-export interface MessageFromParent extends Array<string|any>{0: string, 1: any}
-
-interface PlatformConfig {
-  persist?: boolean;
-  requireCredentials?: Array<string>;
-}
-
-export default class PlatformInstance {
-  flaggedForTermination: boolean = false;
-  id: string;
-  queue: Queue;
-  completedJobHandlers: Map<string, Function> = new Map();
-  config: PlatformConfig = {};
-  readonly name: string;
-  readonly process: ChildProcess;
-  readonly debug: Debugger;
-  readonly parentId: string;
-  readonly sessions: Set<string> = new Set();
-  readonly sessionCallbacks: object = {
-    'close': (() => new Map())(),
-    'message': (() => new Map())()
-  };
-  public readonly global?: boolean = false;
-  private readonly actor?: string;
-
-  constructor(params: PlatformInstanceParams) {
-    this.id = params.identifier;
-    this.name = params.platform;
-    this.parentId = params.parentId;
-    if (params.actor) {
-      this.actor = params.actor;
-    } else {
-      this.global = true;
-    }
-
-    this.debug = debug(`sockethub:platform-instance:${this.id}`);
-    // spin off a process
-    this.process = fork(join(__dirname, 'platform.js'), [this.parentId, this.name, this.id]);
-  }
-
-  /**
-   * Destroys all references to this platform instance, internal listeners and controlled processes
-   */
-  public async destroy() {
-    this.debug(`cleaning up`);
-    this.flaggedForTermination = true;
-    try {
-      await this.queue.removeAllListeners();
-    } catch (e) { }
-    try {
-      await this.queue.obliterate({ force: true });
-    } catch (e) { }
-    try {
-      delete this.queue;
-      await this.process.removeAllListeners('close');
-      await this.process.unref();
-      await this.process.kill();
-    } catch (e) { }
-    platformInstances.delete(this.id);
-  }
-
-  /**
-   * When jobs are completed or failed, we prepare the results and send them to the client socket
-   */
-  public initQueue(secret: string) {
-    this.queue = new Queue(this.parentId + this.id, { redis: config.get('redis') });
-
-    this.queue.on('global:completed', (jobId, resultString) => {
-      const result = resultString ? JSON.parse(resultString) : "";
-      this.queue.getJob(jobId).then(async (job: JobEncrypted) => {
-        await this.handleJobResult('completed', decryptJobData(job, secret), result);
-        await job.remove();
-      });
-    });
-
-    this.queue.on('global:error', (jobId, result) => {
-      this.debug("unknown queue error", jobId, result);
-    });
-
-    this.queue.on('global:failed', (jobId, result) => {
-      this.queue.getJob(jobId).then(async (job: JobEncrypted) => {
-        await this.handleJobResult('failed', decryptJobData(job, secret), result);
-        await job.remove();
-      });
-    });
-  }
-
-  /**
-   * Register listener to be called when the process emits a message.
-   * @param sessionId ID of socket connection that will receive messages from platform emits
-   */
-  public registerSession(sessionId: string) {
-    if (! this.sessions.has(sessionId)) {
-      this.sessions.add(sessionId);
-      for (let type of Object.keys(this.sessionCallbacks)) {
-        const cb = this.callbackFunction(type, sessionId);
-        this.process.on(type, cb);
-        this.sessionCallbacks[type].set(sessionId, cb);
-      }
-    }
-  }
-
-  /**
-   * Sends a message to client (user), can be registered with an event emitted from the platform
-   * process.
-   * @param sessionId ID of the socket connection to send the message to
-   * @param msg ActivityStream object to send to client
-   */
-  public sendToClient(sessionId: string, msg: ActivityStream) {
-    getSocket(sessionId).then((socket) => {
-      try {
-        // this property should never be exposed externally
-        delete msg.sessionSecret;
-      } catch (e) {}
-      msg.context = this.name;
-      if ((msg.type === 'error') && (typeof msg.actor === 'undefined') && (this.actor)) {
-        // ensure an actor is present if not otherwise defined
-        msg.actor = { id: this.actor };
-      }
-      socket.emit('message', msg);
-    }, (err) => this.debug(`sendToClient ${err}`));
-  }
-
-  // send message to every connected socket associated with this platform instance.
-  private async broadcastToSharedPeers(sessionId: string, msg: ActivityStream) {
-    for (let sid of this.sessions.values()) {
-      if (sid !== sessionId) {
-        this.debug(`broadcasting message to ${sid}`);
-        await this.sendToClient(sid, msg);
-      }
-    }
-  }
-
-  // handle job results coming in on the queue from platform instances
-  private async handleJobResult(type: string, jobData: JobDataDecrypted, result) {
-    this.debug(`${type} job ${jobData.title}`);
-    delete jobData.msg.sessionSecret;
-    let msg = jobData.msg;
-    if (type === 'failed') {
-      msg.error = result ? result : "job failed for unknown reason";
-      if ((this.config.persist) && (this.config.requireCredentials.includes(jobData.msg.type))) {
-        this.debug(`critical job type ${jobData.msg.type} failed, terminating platform instance`);
-        await this.destroy();
-      }
-    }
-
-    // send result to client
-    const callback = this.completedJobHandlers.get(jobData.title);
-    if (callback) {
-      callback(msg);
-      this.completedJobHandlers.delete(jobData.title);
-    } else {
-      await this.sendToClient(jobData.sessionId, msg);
-    }
-
-    // let all related peers know of result as an independent message
-    // (not as part of a job completion, or failure)
-    await this.broadcastToSharedPeers(jobData.sessionId, msg);
-  }
-
-  /**
-   * Sends error message to client and clears all references to this class.
-   * @param sessionId
-   * @param errorMessage
-   */
-  private async reportError(sessionId: string, errorMessage: any) {
-    const errorObject: ActivityStream = {
-      context: this.name,
-      type: 'error',
-      actor: { id: this.actor },
-      error: errorMessage
-    };
-    this.sendToClient(sessionId, errorObject);
-    this.sessions.clear();
-    await this.destroy();
-  }
-
-  /**
-   * Updates the instance with a new identifier, updating the platformInstances mapping as well.
-   * @param identifier
-   */
-  private updateIdentifier(identifier: string) {
-    platformInstances.delete(this.id);
-    this.id = identifier;
-    platformInstances.set(this.id, this);
-  }
-
-  /**
-   * Generates a function tied to a given client session (socket connection), the generated
-   * function will be called for each session ID registered, for every platform emit.
-   * @param listener
-   * @param sessionId
-   */
-  private callbackFunction(listener: string, sessionId: string) {
-    const funcs = {
-      'close': (e: object) => {
-        this.debug(`close even triggered ${this.id}: ${e}`);
-        this.reportError(sessionId, `Error: session thread closed unexpectedly: ${e}`);
-      },
-      'message': (data: MessageFromPlatform) => {
-        if (data[0] === 'updateActor') {
-          // We need to update the key to the store in order to find it in the future.
-          this.updateIdentifier(data[2]);
-        } else if (data[0] === 'error') {
-          this.reportError(sessionId, data[1]);
-        } else {
-          // treat like a message to clients
-          this.sendToClient(sessionId, data[1]);
-        }
-      }
-    };
-    return funcs[listener];
-  }
-}