sockethub 4.1.0 → 5.0.0-alpha.0

package/src/process-manager.ts

@@ -1,7 +1,7 @@
 import init from './bootstrap/init';
-import PlatformInstance, { platformInstances, PlatformInstanceParams } from "./platform-instance";
+import PlatformInstance, {
+  platformInstances, PlatformInstanceParams, MessageFromParent } from "./platform-instance";
 import { getPlatformId } from "./common";
-import { MessageFromParent } from "./platform-instance";
 
 class ProcessManager {
   private readonly parentId: string;
@@ -16,14 +16,17 @@ class ProcessManager {
 
   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
-      return this.ensureProcess(platform, sessionId, actorId);
+      pi = this.ensureProcess(platform, sessionId, actorId);
     } else {
       // ensure process is started - one for all jobs
-      return this.ensureProcess(platform);
+      pi = this.ensureProcess(platform);
     }
+    pi.config = platformDetails.config;
+    return pi;
   }
 
   private createPlatformInstance(identifier: string, platform: string,

package/src/routes.ts

@@ -10,15 +10,12 @@ const debug_scope = process.env.DEBUG || '',
                     config.get('public:path');
 
 export const basePaths = {
-  '/sockethub-client.js': path.resolve(`${__dirname}/../dist/client/sockethub-client.js`),
-  '/sockethub-client.js.map': path.resolve(`${__dirname}/../dist/client/sockethub-client.js.map`),
+  '/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`),
-  // '/activity-streams.js':
-  // path.resolve(`${__dirname}/../node_modules/activity-streams/browser/activity-streams.js`),
-  '/activity-streams.min.js':
-    path.resolve(`${__dirname}/../node_modules/activity-streams/browser/activity-streams.min.js`),
 };
 
 export const examplePaths = {

package/src/serve.ts

@@ -59,7 +59,7 @@ class Serve {
 
 const serve = new Serve();
 
-interface SocketInstance {
+export interface SocketInstance {
   id: string;
   emit: Function;
 }

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

@@ -3,14 +3,15 @@ import { Socket } from "socket.io";
 
 import crypto from './crypto';
 import init from './bootstrap/init';
-import createMiddleware 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 ProcessManager from "./process-manager";
-import { platformInstances } from "./platform-instance";
+import PlatformInstance, { platformInstances } from "./platform-instance";
 import { getSessionStore } from "./store";
 
 const log = debug('sockethub:core');
@@ -18,7 +19,7 @@ const log = debug('sockethub:core');
 
 export interface JobDataDecrypted {
   title?: string;
-  msg: ActivityObject;
+  msg: ActivityStream;
   sessionId: string;
 }
 
@@ -38,34 +39,34 @@ export interface JobEncrypted {
   remove?: Function;
 }
 
-export interface ActivityObject {
-  '@type'?: string;
-  actor?: string | {
-    '@type': string;
-    '@id'?: string;
+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 errorHandler(type, socket, log) {
-  return function reportError(err, msg) {
-    log('failure handling ' + type + '. ' + err);
-    if (typeof msg !== 'object') {
-      msg = { context: 'error' };
-    }
-    msg.error = err;
-    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 {
@@ -104,31 +105,26 @@ 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, done: Function) => {
-      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: JobDataEncrypted = {
-        title: title,
-        sessionId: socket.id,
-        msg: crypto.encrypt(msg, this.parentSecret1 + this.parentSecret2)
-      };
-      platformInstance.queue.add(job);
-      done(job);
+  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
@@ -137,40 +133,51 @@ class Sockethub {
     sessionLog(`socket.io connection`);
 
     socket.on('disconnect', () => {
-      sessionLog('disconnect received from client.');
+      sessionLog('disconnect received from client');
     });
 
     socket.on('credentials',
-      createMiddleware(errorHandler('credentials', socket, sessionLog))(
-        validate('credentials', socket.id),
-        storeCredentials(store, sessionLog)
-      )
-    );
-
-    socket.on(
-      'message',
-      createMiddleware(errorHandler('message', socket, sessionLog))(
-        validate('message', socket.id),
-        (msg, done) => {
-          // 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;
-          done(msg);
-        },
-        this.handleIncomingMessage(socket, sessionLog)
-      )
-    );
+      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',
-      createMiddleware(errorHandler('message', socket, sessionLog))(
-        validate('activity-object', socket.id),
-        createActivityObject
-      )
-    );
+    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());
   }
 }