sockethub 4.0.0 → 5.0.0-alpha.0

package/src/sockethub-client.test.ts

@@ -0,0 +1,235 @@
+import proxyquire from 'proxyquire';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { EventEmitter2 } from 'eventemitter2';
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+describe("SockethubClient bad initialization", () => {
+  it("no socket.io instance", () => {
+    const SockethubClient = proxyquire('./sockethub-client', {
+      'activity-streams': (config: any) => {}
+    });
+    expect(() => {
+      const junk = new SockethubClient();
+    }).to.throw("SockethubClient requires a socket.io instance");
+  });
+});
+
+describe("SockethubClient", () => {
+  let ASManager, socket, sc, sandbox;
+
+  beforeEach(() => {
+    sandbox = sandbox = sinon.createSandbox();
+    socket = new EventEmitter2();
+    // @ts-ignore
+    socket.__instance = 'socketio'; // used to uniquely identify the object we're passing in
+    sandbox.spy(socket, 'on');
+    sandbox.spy(socket, 'emit');
+    ASManager = new EventEmitter2();
+    sandbox.spy(ASManager, 'on');
+    sandbox.spy(ASManager, 'emit');
+    ASManager.Stream = sandbox.stub();
+    ASManager.Object = {
+      create: sandbox.stub()
+    };
+    const SockethubClient = proxyquire('./sockethub-client', {
+      'activity-streams': (config: any) => {
+        return ASManager;
+      }
+    });
+    sc = new SockethubClient(socket);
+    sandbox.spy(sc.socket, 'on');
+    sandbox.spy(sc.socket, '_on');
+    sandbox.spy(sc.socket, 'emit');
+    sandbox.spy(sc.socket, '_emit');
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it("contains the ActivityStreams property", () => {
+    expect(sc.ActivityStreams).to.be.eql(ASManager);
+  });
+
+  it("contains the socket property", () => {
+    expect(sc.socket instanceof EventEmitter2).to.be.true;
+    // the object we passed in should not be the publically available one
+    expect(sc.socket.__instance).to.not.equal('socketio');
+    expect(sc.debug).to.be.true;
+    expect(sc.online).to.be.false;
+  });
+
+  it("registers listeners for ActivityStream events", () => {
+    expect(ASManager.on.callCount).to.equal(1);
+    expect(ASManager.on.calledWithMatch('activity-object-create')).to.be.true;
+  });
+
+  it("registers a listeners for socket events", () => {
+    expect(socket.on.callCount).to.equal(5);
+    expect(socket.on.calledWithMatch('activity-object')).to.be.true;
+    expect(socket.on.calledWithMatch('connect')).to.be.true;
+    expect(socket.on.calledWithMatch('connect_error')).to.be.true;
+    expect(socket.on.calledWithMatch('disconnect')).to.be.true;
+    expect(socket.on.calledWithMatch('message')).to.be.true;
+  });
+
+  describe("event handling", () => {
+    it("activity-object", (done) => {
+      socket.emit('activity-object', {foo:"bar"});
+      setTimeout(() => {
+        sandbox.assert.calledWith(ASManager.Object.create, {foo:"bar"});
+        done();
+      }, 0);
+    });
+
+    it("activity-object-create", (done) => {
+      ASManager.emit('activity-object-create', {foo:"bar"});
+      setTimeout(() => {
+        expect(socket.emit.callCount).to.equal(1);
+        expect(socket.emit.calledWithMatch('activity-object', {foo:"bar"})).to.be.true;
+        done();
+      }, 0);
+    });
+
+    it("connect", (done) => {
+      expect(sc.online).to.be.false;
+      sc.socket.on("connect", () => {
+        expect(sc.online).to.be.true;
+        expect(sc.socket._emit.callCount).to.equal(1);
+        expect(sc.socket._emit.calledWithMatch('connect'));
+        done();
+      });
+      socket.emit("connect");
+    });
+
+    it("disconnect", (done) => {
+      sc.online = true;
+      sc.socket.on("disconnect", () => {
+        expect(sc.online).to.be.false;
+        expect(sc.socket._emit.callCount).to.equal(1);
+        expect(sc.socket._emit.calledWithMatch('disconnect'));
+        done();
+      });
+      socket.emit("disconnect");
+    });
+
+    it("connect_error", (done) => {
+      sc.socket.on("connect_error", () => {
+        expect(sc.socket._emit.callCount).to.equal(1);
+        expect(sc.socket._emit.calledWithMatch('connect_error'));
+        done();
+      });
+      socket.emit("connect_error");
+    });
+
+    it("message", (done) => {
+      sc.socket.on("message", () => {
+        expect(sc.socket._emit.callCount).to.equal(1);
+        expect(sc.socket._emit.calledWithMatch('message'));
+        done();
+      });
+      socket.emit("message");
+    });
+  });
+
+  describe("event emitting", () => {
+    it("message (no actor)", () => {
+      sc.online = true;
+      const callback = (res) => {};
+      expect(() => {
+        sc.socket.emit("message", {foo:"bar"}, callback);
+      }).to.throw("actor property not present");
+    });
+
+    it("message", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar", type: "bar"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar", type: "bar"}, callback);
+    });
+
+    it("message (join)", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar", type: "join"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar", type: "join"}, callback);
+    });
+
+    it("message (leave)", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar", type: "leave"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar", type: "leave"}, callback);
+    });
+
+    it("message (connect)", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar", type: "connect"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar", type: "connect"}, callback);
+    });
+
+    it("message (disconnect)", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar", type: "disconnect"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar", type: "disconnect"}, callback);
+    });
+
+    it("message (offline)", (done) => {
+      sc.online = false;
+      const callback = (res) => {};
+      socket.once("message", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("message", {actor:"bar"}, callback);
+    });
+
+    it("activity-object", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("activity-object", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("activity-object", {actor:"bar"}, callback);
+    });
+
+    it("credentials", (done) => {
+      sc.online = true;
+      const callback = (res) => {};
+      socket.once("credentials", (data, cb) => {
+        expect(data).to.be.eql({actor: "bar"});
+        expect(cb).to.be.eql(callback);
+        done();
+      });
+      sc.socket.emit("credentials", {actor:"bar"}, callback);
+    });
+  });
+});

package/src/sockethub-client.ts

@@ -0,0 +1,164 @@
+import { EventEmitter2 } from 'eventemitter2';
+import ASFactory from 'activity-streams';
+
+export interface ActivityObjectManager {
+  create(obj: any): any;
+  delete(id: string): boolean;
+  list(): Array<string>,
+  get(id: string, expand: boolean): any;
+}
+
+export interface ASManager {
+  Stream(meta: any): any,
+  Object: ActivityObjectManager,
+  on(event, func): void;
+  once(event, func): void;
+  off(event, funcName): void;
+}
+
+class SockethubClient {
+  private _socket;
+  private events = {
+    'credentials': new Map(),
+    'activity-object': new Map(),
+    'connect': new Map(),
+    'join': new Map()
+  };
+  public socket;
+  public ActivityStreams: ASManager;
+  public online = false;
+  public debug = true;
+
+  constructor(socket) {
+    if (! socket) { throw new Error('SockethubClient requires a socket.io instance'); }
+    this._socket = socket;
+    // @ts-ignore
+    this.ActivityStreams = ASFactory({specialObjs: ['credentials']});
+
+    this.socket = this.createPublicEmitter();
+    this.registerSocketIOHandlers();
+
+    this.ActivityStreams.on('activity-object-create', (obj) => {
+      socket.emit('activity-object', obj, (err) => {
+        if (err) { console.error('failed to create activity-object ', err); }
+        else { this.eventActivityObject(obj); }
+      });
+    });
+
+    socket.on('activity-object', (obj) => {
+      this.ActivityStreams.Object.create(obj);
+    });
+  }
+
+  private createPublicEmitter(): EventEmitter2 {
+    let socket = new EventEmitter2({
+      wildcard: true,
+      verboseMemoryLeak: false
+    });
+    // @ts-ignore
+    socket._emit = socket.emit;
+    socket.emit = (event, content, callback): any => {
+      if (event === 'credentials') {
+        this.eventCredentials(content);
+      } else if (event === 'activity-object') {
+        this.eventActivityObject(content);
+      } else if (event === 'message') {
+        this.eventMessage(content);
+      }
+      this._socket.emit(event, content, callback);
+    };
+    return socket;
+  }
+
+  private eventActivityObject(content: any) {
+    if (content.id) {
+      this.events['activity-object'].set(content.id, content);
+    }
+  }
+
+  private eventCredentials(content: any) {
+    if ((content.object) && (content.object.type === 'credentials')) {
+      this.events['credentials'].set(content.actor.id || content.actor, content);
+    }
+  }
+
+  private eventMessage(content: any) {
+    if (! this.online) { return; }
+    // either store or delete the specified content onto the storedJoins map,
+    // for reply once we're back online.
+    const key = SockethubClient.getKey(content);
+    if (content.type === 'join' || content.type === 'connect') {
+      this.events[content.type].set(key, content);
+    } else if (content.type === 'leave') {
+      this.events['join'].delete(key);
+    } else if (content.type === 'disconnect') {
+      this.events['connect'].delete(key);
+    }
+  }
+
+  private static getKey(content: any) {
+    let actor = content.actor?.id || content.actor;
+    if (! actor) {
+      throw new Error("actor property not present for message type: " + content?.type);
+    }
+    let target = content.target ? content.target.id || content.target : '';
+    return actor + '-' + target;
+  }
+
+  private log(msg: string, obj?: any) {
+    if (this.debug) {
+      // eslint-disable-next-line security-node/detect-crlf
+      console.log(msg, obj);
+    }
+  }
+
+  private registerSocketIOHandlers() {
+    // middleware for events which don't deal in AS objects
+    const callHandler = (event: string) => {
+      return (obj, cb) => {
+        if (event === 'connect') {
+          this.online = true;
+          this.replay('activity-object', this.events['activity-object']);
+          this.replay('credentials', this.events['credentials']);
+          this.replay('message', this.events['connect']);
+          this.replay('message', this.events['join']);
+        } else if (event === 'disconnect') {
+          this.online = false;
+        }
+        this.socket._emit(event, obj, cb);
+      };
+    };
+
+    // register for events that give us information on connection status
+    this._socket.on('connect', callHandler('connect'));
+    this._socket.on('connect_error', callHandler('connect_error'));
+    this._socket.on('disconnect', callHandler('disconnect'));
+
+    // use as a middleware to receive incoming Sockethub messages and unpack them
+    // using the ActivityStreams library before passing them along to the app.
+    this._socket.on('message', (obj, cb) => {
+      this.socket._emit('message', this.ActivityStreams.Stream(obj), cb);
+    });
+  }
+
+  private replay(name: string, asMap: any) {
+    asMap.forEach((obj) => {
+      this.log(`replaying ${name}`, obj);
+      this._socket.emit(name, obj);
+    });
+  };
+}
+
+if (typeof module === 'object' && module.exports) {
+  module.exports = SockethubClient;
+}
+
+if (typeof exports === 'object') {
+  exports = SockethubClient;  // lgtm [js/useless-assignment-to-local]
+}
+
+// @ts-ignore
+if (typeof window === 'object') {
+  // @ts-ignore
+  window.SockethubClient = SockethubClient;
+}

package/src/sockethub.ts

@@ -1,64 +1,72 @@
 import debug from 'debug';
-import ActivityStreams from 'activity-streams';
 import { Socket } from "socket.io";
 
-import config from './config';
 import crypto from './crypto';
 import init from './bootstrap/init';
-import Middleware from './middleware';
+import middleware from './middleware';
+import createActivityObject from "./middleware/create-activity-object";
+import expandActivityStream from "./middleware/expand-activity-stream";
+import storeCredentials from "./middleware/store-credentials";
+import validate from "./middleware/validate";
 import janitor from './janitor';
 import serve from './serve';
-import validate from './validate';
 import ProcessManager from "./process-manager";
-import { getSessionStore, Store } from "./common";
-import { platformInstances } from "./platform-instance";
+import PlatformInstance, { platformInstances } from "./platform-instance";
+import { getSessionStore } from "./store";
 
-const log = debug('sockethub:core'),
-      activity = ActivityStreams(config.get('activity-streams:opts'));
+const log = debug('sockethub:core');
 
 
-export interface JobData {
+export interface JobDataDecrypted {
   title?: string;
-  msg: ActivityObject;
+  msg: ActivityStream;
   sessionId: string;
 }
 
-export interface Job {
-  data: JobData,
+export interface JobDataEncrypted {
+  title?: string;
+  msg: string;
+  sessionId: string;
+}
+
+export interface JobDecrypted {
+  data: JobDataDecrypted,
   remove?: Function;
 }
 
-export interface ActivityObject {
-  '@type'?: string;
-  actor?: string | {
-    '@type': string;
-    '@id'?: string;
+export interface JobEncrypted {
+  data: JobDataEncrypted,
+  remove?: Function;
+}
+
+export interface ActivityStream {
+  type: string;
+  context: string;
+  actor: {
+    id: string;
+    type?: string;
+    name?: string;
   },
   object?: {
-    '@type': string;
+    type: string;
     content?: any;
   },
-  target?: string | {
-    '@type': string;
-    '@id'?: string;
+  target?: {
+    type: string;
+    id: string;
+    name?: string;
   },
-  context: string;
-  error?: any;
+  error?: string;
   sessionSecret?: string;
 }
 
-
-function getMiddleware(socket: Socket, sessionLog: Function) {
-  return new Middleware((err, type: string, msg: ActivityObject) => {
-    sessionLog('validation failed for ' + type + '. ' + err, msg);
-    // called with validation fails
-    if (typeof msg !== 'object') {
-      msg = { context: 'error' };
-    }
-    msg.error = err;
-    // send failure
-    socket.emit('failure', msg);
-  });
+function attachError(err, msg) {
+  if (typeof msg !== 'object') {
+    msg = { context: 'error' };
+  }
+  msg.error = err.toString();
+  delete msg.sessionSecret;
+  return msg;
 }
 
 class Sockethub {
@@ -97,84 +105,79 @@ class Sockethub {
     janitor.clean(); // start cleanup cycle
     serve.start();   // start external services
     log('registering handlers');
-    serve.io.on('connection', this.incomingConnection.bind(this));
+    serve.io.on('connection', this.handleIncomingConnection.bind(this));
   }
 
-  removeAllPlatformInstances() {
-    for (let platform of platformInstances.values()) {
-      platform.destroy();
+  async removeAllPlatformInstances() {
+    for (let platform of platformInstances) {
+      await platform[1].destroy();
     }
   }
 
-  private handleIncomingMessage(socket: Socket, sessionLog: Function) {
-    return (msg) => {
-      const platformInstance = this.processManager.get(msg.context, msg.actor['@id'], socket.id);
-      const title = `${msg.context}-${(msg['@id']) ? msg['@id'] : this.counter++}`;
-      sessionLog(`queued to channel ${platformInstance.id}`);
-      const job: JobData = {
-        title: title,
-        sessionId: socket.id,
-        msg: crypto.encrypt(msg, this.parentSecret1 + this.parentSecret2)
-      };
-      platformInstance.queue.add(job);
-    };
-  };
-
-  private handleStoreCredentials(store: Store, sessionLog: Function) {
-    return (creds: ActivityObject) => {
-      store.save(creds.actor['@id'], creds, (err) => {
-        if (err) {
-          sessionLog('error saving credentials to store ' + err);
-        } else {
-          sessionLog('credentials encrypted and saved');
-        }
-      });
+  private createJob(socketId: string, platformInstance: PlatformInstance, msg): JobDataEncrypted {
+    const title = `${msg.context}-${(msg.id) ? msg.id : this.counter++}`;
+    const job: JobDataEncrypted = {
+      title: title,
+      sessionId: socketId,
+      msg: crypto.encrypt(msg, this.parentSecret1 + this.parentSecret2)
     };
+    return job;
   };
 
-  private incomingConnection(socket: Socket) {
+  private handleIncomingConnection(socket: Socket) {
     const sessionLog = debug('sockethub:core:' + socket.id), // session-specific debug messages
           sessionSecret = crypto.randToken(16),
           // store instance is session-specific
-          store = getSessionStore(this.parentId, this.parentSecret1, socket.id, sessionSecret),
-          middleware = getMiddleware(socket, sessionLog);
+          store = getSessionStore(this.parentId, this.parentSecret1, socket.id, sessionSecret);
 
     sessionLog(`socket.io connection`);
 
     socket.on('disconnect', () => {
-      sessionLog('disconnect received from client.');
+      sessionLog('disconnect received from client');
     });
 
-    socket.on(
-      'credentials',
-      middleware.chain(
-        validate('credentials', socket.id), this.handleStoreCredentials(store, sessionLog))
-    );
-
-    socket.on(
-      'message',
-      middleware.chain(
-        validate('message', socket.id),
-        (next, msg) => {
-          // middleware which attaches the sessionSecret to the message. The platform thread
-          // must find the credentials on their own using the given sessionSecret, which indicates
-          // that this specific session (socket connection) has provided credentials.
-          msg.sessionSecret = sessionSecret;
-          next(true, msg);
-        },
-        this.handleIncomingMessage(socket, sessionLog)
-      )
-    );
+    socket.on('credentials',
+      middleware('credentials')
+        .use(expandActivityStream)
+        .use(validate('credentials', socket.id))
+        .use(storeCredentials(store, sessionLog))
+        .use((err, data, next) => {
+          // error handler
+          next(attachError(err, data));
+        }).use((data, next) => { next(); })
+        .done());
 
     // when new activity objects are created on the client side, an event is
     // fired and we receive a copy on the server side.
-    socket.on(
-      'activity-object',
-      middleware.chain(
-        validate('activity-object', socket.id),
-        activity.Object.create
-      )
-    );
+    socket.on('activity-object',
+      middleware('activity-object')
+        .use(validate('activity-object', socket.id))
+        .use(createActivityObject)
+        .use((err, data, next) => {
+          next(attachError(err, data));
+        }).use((data, next) => { next(); })
+        .done());
+
+    socket.on('message',
+      middleware('message')
+        .use(expandActivityStream)
+        .use(validate('message', socket.id))
+        .use((msg, next) => {
+          // The platform thread must find the credentials on their own using the given
+          // sessionSecret, which indicates that this specific session (socket
+          // connection) has provided credentials.
+          msg.sessionSecret = sessionSecret;
+          next(msg);
+        }).use((err, data, next) => {
+          next(attachError(err, data));
+        }).use((msg, next) => {
+          const platformInstance = this.processManager.get(msg.context, msg.actor.id, socket.id);
+          sessionLog(`queued to channel ${platformInstance.id}`);
+          const job = this.createJob(socket.id, platformInstance, msg);
+          // job validated and queued, store socket.io callback for when job is completed
+          platformInstance.completedJobHandlers.set(job.title, next);
+          platformInstance.queue.add(job);
+        }).done());
   }
 }
 

package/src/store.test.ts

@@ -0,0 +1,26 @@
+import proxyquire from 'proxyquire';
+import * as sinon from 'sinon';
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+const MockSecureStore = sinon.fake();
+
+const StoreMod = proxyquire('./store', {
+  'secure-store-redis': MockSecureStore
+});
+
+const getSessionStore = StoreMod.getSessionStore;
+
+describe('getSessionStore', () => {
+  it('returns a valid Store object', () => {
+    const store = getSessionStore('a parent id', 'a parent secret',
+      'a session id', 'a session secret');
+    sinon.assert.calledOnce(MockSecureStore);
+    sinon.assert.calledWith(MockSecureStore, {
+      namespace: 'sockethub:a parent id:session:a session id:store',
+      secret: 'a parent secreta session secret',
+      redis: { host: '127.0.0.1', port: 6379 }
+    });
+  });
+});

package/src/store.ts

@@ -0,0 +1,17 @@
+import SecureStore from 'secure-store-redis';
+
+import config from "./config";
+
+export interface ISecureStoreInstance {
+  save(id: string, obj: any, cb: Function);
+  get(id: string, cb: Function);
+}
+
+export function getSessionStore(parentId: string, parentSecret: string,
+                                sessionId: string, sessionSecret: string): ISecureStoreInstance {
+  return new SecureStore({
+    namespace: 'sockethub:' + parentId + ':session:' + sessionId + ':store',
+    secret: parentSecret + sessionSecret,
+    redis: config.get('redis')
+  });
+}