sockethub 4.0.0 → 5.0.0-alpha.0

package/src/common.test.ts

@@ -1,43 +1,54 @@
-import { getPlatformId, getSessionStore } from './common';
+import proxyquire from 'proxyquire';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { decryptJobData, getPlatformId } from './common';
 import crypto from './crypto';
-import Store from 'secure-store-redis';
-
-jest.mock('./config');
-jest.mock('secure-store-redis');
-jest.mock('./crypto', () => ({
-  __esModule: true,
-  default: {
-    encrypt: jest.fn().mockImplementation(() => {
-      console.log("encrypt called");
-    }),
-    decrypt: jest.fn().mockImplementation(() => {
-      console.log("decrypt called");
-    }),
-    hash: jest.fn().mockImplementation((string) => {
-      return string;
-    }),
-  }
-}));
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
 
 describe("getPlatformId", () => {
+  let cryptoHashStub;
+
+  beforeEach(() => {
+    cryptoHashStub = sinon.stub(crypto, 'hash');
+    cryptoHashStub.returnsArg(0);
+    proxyquire('./common', { crypto: { hash: cryptoHashStub }});
+  });
+
+  afterEach(() => {
+    cryptoHashStub.restore();
+  });
+
   it('generates platform hash', () => {
-    expect(getPlatformId('foo')).toBe('foo');
-    expect(crypto.hash).toBeCalledWith('foo');
+    expect(getPlatformId('foo')).to.be.equal('foo');
+    sinon.assert.calledOnce(cryptoHashStub);
+    sinon.assert.calledWith(cryptoHashStub, 'foo');
   });
   it('generates platform + actor hash', () => {
-    expect(getPlatformId('foo', 'bar')).toBe('foobar');
-    expect(crypto.hash).toBeCalledWith('foobar');
+    expect(getPlatformId('foo', 'bar')).to.be.equal('foobar');
+    sinon.assert.calledOnce(cryptoHashStub);
+    sinon.assert.calledWith(cryptoHashStub, 'foobar');
   });
 });
 
-describe('getSessionStore', () => {
-  it('returns a valid Store object', () => {
-    getSessionStore('a parent id', 'a parent secret',
-      'a session id', 'a session secret');
-    expect(Store).toBeCalledWith({
-      namespace: 'sockethub:a parent id:session:a session id:store',
-      secret: 'a parent secreta session secret',
-      redis: undefined
-    });
+describe("decryptJobData", () => {
+  let cryptoDecryptStub;
+
+  beforeEach(() => {
+    cryptoDecryptStub = sinon.stub(crypto, 'decrypt');
+    cryptoDecryptStub.returnsArg(0);
+    proxyquire('./common', { crypto: { hash: cryptoDecryptStub }});
+  });
+
+  afterEach(() => {
+    cryptoDecryptStub.restore();
   });
-});
+
+  it("decrypts and returns expected object", () => {
+    const jobData = {data:{title:"foo", msg:'encryptedjobdata', sessionId:'foobar'}};
+    const secret = 'secretstring';
+    expect(decryptJobData(jobData, secret)).to.be.eql(jobData.data);
+  });
+});

package/src/common.ts

@@ -1,22 +1,14 @@
-import Store from 'secure-store-redis';
-
-import config from "./config";
 import crypto from "./crypto";
-
-export interface Store {
-  save(id: string, obj: any, cb: Function);
-  get(id: string, cb: Function);
-}
-
-export function getSessionStore(parentId: string, parentSecret: string,
-                                sessionId: string, sessionSecret: string): Store {
-  return new Store({
-    namespace: 'sockethub:' + parentId + ':session:' + sessionId + ':store',
-    secret: parentSecret + sessionSecret,
-    redis: config.get('redis')
-  });
-}
+import { JobDataDecrypted, JobEncrypted } from "./sockethub";
 
 export function getPlatformId(platform: string, actor?: string): string {
   return actor ? crypto.hash(platform + actor) : crypto.hash(platform);
+}
+
+export function decryptJobData(job: JobEncrypted, secret: string): JobDataDecrypted {
+  return {
+    title: job.data.title,
+    msg: crypto.decrypt(job.data.msg, secret),
+    sessionId: job.data.sessionId
+  };
 }

package/src/config.test.ts

@@ -1,50 +1,28 @@
-import { redisConfig } from "./config";
-
-import Redis from 'ioredis';
-
-jest.mock('ioredis');
+import { expect } from 'chai';
 
+import { Config } from './config';
 
 describe('config', () => {
-  beforeEach(() => {
-    jest.resetModules();
+
+  it('loads default values', () => {
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('service:host')).to.eql('localhost');
   });
 
-  it('prioritizes redis url', () => {
-    process.env = { REDIS_URL: 'a redis url' };
-    const nconf = require('nconf');
-    const config = require('./config');
-    expect(config.default).toHaveProperty('get');
-    expect(config.default.get('redis')).toStrictEqual(
-      {"host": "127.0.0.1", "port": 6379, "url": "a redis url"});
+  it('overrides from env', () => {
+    const hostname = 'a host string';
+    process.env = { HOST: hostname };
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('service:host')).to.eql(hostname);
   });
 
   it('defaults to redis config', () => {
     process.env = { REDIS_URL: '' };
-    const nconf = require('nconf');
-    const config = require('./config');
-    expect(config.default).toHaveProperty('get');
-    expect(config.default.get('redis')).toStrictEqual(
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('redis')).to.eql(
       {"host": "127.0.0.1", "port": 6379});
   });
-
-  it('has a redisConfig object', () => {
-    expect(redisConfig).toHaveProperty('createClient');
-    expect(Redis).toHaveBeenCalledTimes(2);
-  })
-
-  it('returns existing client', () => {
-    const client1 = redisConfig.createClient('client');
-    expect(Redis).toHaveBeenCalledTimes(2);
-  });
-
-  it('returns existing subscriber', () => {
-    const client1 = redisConfig.createClient('subscriber');
-    expect(Redis).toHaveBeenCalledTimes(2);
-  });
-
-  it('returns new client otherwise', () => {
-    const client1 = redisConfig.createClient('foo');
-    expect(Redis).toHaveBeenCalledTimes(3);
-  });
 });

package/src/config.ts

@@ -1,10 +1,9 @@
 import nconf from 'nconf';
 import { debug } from 'debug';
-import Redis from 'ioredis';
 
 const log = debug('sockethub:bootstrap:config');
 
-class Config {
+export class Config {
   constructor() {
     log('initializing config');
     // assign config loading priorities (command-line, environment, cfg, defaults)
@@ -70,25 +69,4 @@ class Config {
 }
 
 const config = new Config();
-
-/**
- * config object that can be passed in to ioredis to make use of existing connections
- * https://github.com/OptimalBits/bull/blob/master/PATTERNS.md#reusing-redis-connections
- */
-const client = new Redis(config.get('redis'));
-const subscriber = new Redis(config.get('redis'));
-
-export const redisConfig = {
-  createClient: function (type) {
-    switch (type) {
-      case 'client':
-        return client;
-      case 'subscriber':
-        return subscriber;
-      default:
-        return new Redis(config.get('redis'));
-    }
-  }
-};
-
 export default config;

package/src/crypto.test.ts

@@ -1,43 +1,41 @@
-import crypto from './crypto';
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+
+const crypto = proxyquire('./crypto', {
+  'crypto': {
+    randomBytes: () => Buffer.alloc(16)
+  }
+}).default;
 
 const secret = 'a test secret.. that is 16 x 2..';
 const data = {'foo': 'bar'};
 const encryptedData = "00000000000000000000000000000000:0543ec94d863fbf4b7a19b48e69d9317";
 
-jest.mock('crypto', () => {
-  const originalModule = jest.requireActual('crypto');
-  return {
-    __esModule: true,
-    ...originalModule,
-    randomBytes: jest.fn(() => Buffer.alloc(16)),
-  };
-});
-
 describe('crypto', () => {
   it('encrypts', () => {
-    expect(crypto.encrypt(data, secret)).toBe(encryptedData);
+    expect(crypto.encrypt(data, secret)).to.be.equal(encryptedData);
   });
   it('decrypts', () => {
-    expect(crypto.decrypt(encryptedData, secret)).toStrictEqual(data);
+    expect(crypto.decrypt(encryptedData, secret)).to.eql(data);
   });
   it('hashes', () => {
-    expect(crypto.hash('foobar')).toBe('8843d7f');
+    expect(crypto.hash('foobar')).to.be.equal('8843d7f');
   });
   it('randTokens 8', () => {
     const token = crypto.randToken(8);
-    expect(token.length).toBe(8);
+    expect(token.length).to.be.equal(8);
   });
   it('randTokens 16', () => {
     const token = crypto.randToken(16);
-    expect(token.length).toBe(16);
+    expect(token.length).to.be.equal(16);
   });
   it('randTokens 32', () => {
     const token = crypto.randToken(32);
-    expect(token.length).toBe(32);
+    expect(token.length).to.be.equal(32);
   });
   it('randTokens 33+ will fail', () => {
     expect(() => {
       crypto.randToken(33);
-    }).toThrowError();
+    }).to.throw();
   });
 });

package/src/crypto.ts

@@ -1,13 +1,12 @@
 import { randomBytes, createCipheriv, createDecipheriv, createHash } from 'crypto';
+import { ActivityStream } from "./sockethub";
 
 const ALGORITHM = 'aes-256-cbc',
       IV_LENGTH = 16; // For AES, this is always 16
 
-let crypto;
-
 class Crypto {
   constructor() {}
-  encrypt(json: object, secret: string): string {
+  encrypt(json: ActivityStream, secret: string): string {
     const iv = randomBytes(IV_LENGTH);
     const cipher = createCipheriv(ALGORITHM, Buffer.from(secret), iv);
     let encrypted = cipher.update(JSON.stringify(json));
@@ -15,7 +14,7 @@ class Crypto {
     encrypted = Buffer.concat([encrypted, cipher.final()]);
     return iv.toString('hex') + ':' + encrypted.toString('hex');
   }
-  decrypt(text: string, secret: string): object {
+  decrypt(text: string, secret: string): ActivityStream {
     let parts = text.split(':');
     const iv = Buffer.from(parts.shift(), 'hex');
     const encryptedText = Buffer.from(parts.join(':'), 'hex');
@@ -38,5 +37,5 @@ class Crypto {
   }
 }
 
-crypto = new Crypto();
+const crypto = new Crypto();
 export default crypto;

package/src/janitor.ts

@@ -1,7 +1,7 @@
 import debug from 'debug';
 
-import { platformInstances } from './platform-instance';
-import serve from "./serve";
+import PlatformInstance, { platformInstances } from './platform-instance';
+import serve, { SocketInstance } from "./serve";
 
 const rmLog = debug('sockethub:janitor');
 
@@ -23,15 +23,15 @@ function janitorCycle() {
   rmLog('initializing resource manager');
   setInterval(async () => {
     cycleCount++;
-    const sockets = await serve.io.fetchSockets();
+    const sockets: Array<SocketInstance> = await serve.io.fetchSockets();
 
     if (! (cycleCount % 4)) {
       reportCount++;
-      rmLog(`sessions: ${sockets.length} instances: ${platformInstances.size}`);
+      rmLog(`socket sessions: ${sockets.length} platform instances: ${platformInstances.size}`);
     }
 
     for (let platformInstance of platformInstances.values()) {
-      removeStaleSessions(platformInstance, sockets);
+      removeStaleSocketSessions(platformInstance, sockets);
       // Static platforms are for global use, not tied to a unique to session / eg. credentials)
       if ((! platformInstance.global) && (platformInstance.sessions.size === 0)) {
         removeStalePlatformInstance(platformInstance);
@@ -42,7 +42,7 @@ function janitorCycle() {
   }, TICK);
 }
 
-function socketExists(sessionId, sockets) {
+function socketExists(sessionId: string, sockets: Array<SocketInstance>) {
   for (let socket of sockets) {
     if (socket.id === sessionId) {
       return true;
@@ -51,20 +51,27 @@ function socketExists(sessionId, sockets) {
   return false;
 }
 
-function removeStaleSessions(platformInstance, sockets) {
-  for (let sessionId of platformInstance.sessions.values()) {
+function removeSessionCallbacks(platformInstance: PlatformInstance, sessionId: string) {
+  for (const key in platformInstance.sessionCallbacks) {
+    platformInstance.sessionCallbacks[key].delete(sessionId);
+  }
+}
+
+function removeStaleSocketSessions(platformInstance: PlatformInstance,
+                                   sockets: Array<SocketInstance>) {
+  for (const sessionId of platformInstance.sessions.values()) {
     if (! socketExists(sessionId, sockets)) {
-      rmLog('removing stale session reference ' + sessionId + ' in platform instance '
+      rmLog('removing stale socket session reference ' + sessionId + ' in platform instance '
         + platformInstance.id);
       platformInstance.sessions.delete(sessionId);
+      removeSessionCallbacks(platformInstance, sessionId);
     }
   }
 }
 
-function removeStalePlatformInstance(platformInstance) {
+function removeStalePlatformInstance(platformInstance: PlatformInstance) {
   if (platformInstance.flaggedForTermination) {
-    rmLog(`terminating platform instance ${platformInstance.id} ` +
-      `(flagged for termination: no registered sessions found)`);
+    rmLog(`terminating platform instance ${platformInstance.id}`);
     platformInstance.destroy(); // terminate
   } else {
     rmLog(`flagging for termination platform instance ${platformInstance.id} ` +

package/src/middleware/create-activity-object.test.ts

@@ -0,0 +1,10 @@
+import createActivityObject from "./create-activity-object";
+
+describe('Middleware: createActivityObject', () => {
+  it('Calls activity.Object.create with incoming data', (done) => {
+    // @ts-ignore
+    createActivityObject({foo: 'bar'}, (msg) => {
+      done();
+    });
+  });
+});

package/src/middleware/create-activity-object.ts

@@ -0,0 +1,13 @@
+import ActivityStreams from 'activity-streams';
+import config from "../config";
+const activity = ActivityStreams(config.get('activity-streams:opts'));
+
+/**
+ * A simple middleware wrapper for the activity-streams Object.create method.
+ * @param obj
+ * @param done
+ */
+export default function createActivityObject(obj: any, done: Function) {
+  activity.Object.create(obj);
+  done(obj);
+}