sockethub 4.1.0 → 5.0.0-alpha.0

package/src/middleware.test.ts

@@ -1,27 +1,43 @@
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 
-import createMiddleware from "./middleware";
+import middleware, { MiddlewareChain } from "./middleware";
 
 describe("Middleware", () => {
-  it("createMiddleware() is a function", () => {
-    expect(typeof createMiddleware).to.be.equal('function');
+  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 = createMiddleware(()=>{});
+    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(()=>{}, 'foobar');}).to.throw(
-      'middleware chain can only take other functions as arguments.');
+    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 = createMiddleware(()=>{});
-    const entry = mw(...funcs);
-    entry('foobar', (err) => {
-      expect(err).to.be.null;
+    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;
@@ -33,16 +49,22 @@ describe("Middleware", () => {
 
   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 callbackError = (data, cb) => {
+      cb(new Error('some error')); };
     const funcs = [ sinon.spy(callbackError) ];
-    const mw = createMiddleware((err)=>{
+    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();
     });
-    const entry = mw(...funcs);
-    entry('foobar');
-    expect(errorHandlerCalled).to.be.true;
-    done();
   });
 
   it("aborts call stack on error - calls error handler, and callback", (done) => {
@@ -50,14 +72,18 @@ describe("Middleware", () => {
     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 = createMiddleware((err, msg) => {
+    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);
     });
-    const entry = mw(...funcs);
-    entry('foobar', (err) => {
+    mw.done()('foobar', (data) => {
       // FIXME -- We need to also handle socket.io callbacks!
-      expect(err instanceof Error).to.be.true;
+      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;
@@ -73,7 +99,11 @@ describe("Middleware", () => {
     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 = createMiddleware((err, msg) => {
+    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;
@@ -86,8 +116,7 @@ describe("Middleware", () => {
       expect(errorHandlerCalled).to.be.true;
       setTimeout(done, 0);
     });
-    const entry = mw(...funcs);
-    entry('foobar');
+    mw.done()('foobar', () => {});
   });
 
   it("calls each member of chain (50)", (done) => {
@@ -97,12 +126,16 @@ describe("Middleware", () => {
     for (let i = 0; i <= 50; i++) {
       funcs.push(sinon.spy(callback));
     }
-    const mw = createMiddleware((err, msg) => {
+    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(...funcs)('foo', (err) => {
-      expect(err).to.be.null;
+    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;

package/src/middleware.ts

@@ -1,84 +1,52 @@
-/**
- * Returns a function which accepts a list of middleware functions to call, in order.
- * The errorHandler will be called whenever an error occurs.
- * @param {function} errorHandler
- * @return {function} chains a series of functions to be called in sequence
- */
-export default function createMiddleware(errorHandler: Function) {
-  return function chain(...chain: Array<Function>) {
-    for (let func of chain) {
-      if (typeof func !== 'function') {
-        throw new Error('middleware chain can only take other functions as arguments.');
-      }
-    }
-    return getMiddlewareInstance(chain, errorHandler);
-  };
+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;
 
-function getMiddlewareInstance(chain: Array<Function>, errorHandler: Function) {
-  return (...initialParams) => {
-    // placeholder callback in case one is not provided
-    let callback = (err: Error|null) => { if (err) {} };
-    let position = 0;
+  constructor(name: string) {
+    this.name = name;
+    this.logger = debug(`sockethub:middleware:${name}`);
+  }
 
-    if (typeof initialParams[initialParams.length - 1] === 'function') {
-      // callback has been provided
-      callback = initialParams.pop();
+  use(func: Function): this {
+    if (typeof func !== 'function') {
+      throw new Error('middleware use() can only take a function as an argument');
     }
-
-    function callFunc(...params) {
-      if (params[0] instanceof Error) {
-        errorHandler(...params);
-        callback(params[0]);
-      } else if (typeof chain[position] === 'function') {
-        params.push(callFunc);
-        chain[position++](...params);
-      } else {
-        callback(null);
-      }
+    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;
+  }
 
-    callFunc(...initialParams);
-  };
+  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);
+    };
+  }
 }
-
-/**
- * When calling the middleware instance function, pass in a list of functions to call in order.
- * Each function can expect any number of params, but the final param should expect a callback.
- *
- * After all functions are completed, it will call the callback function. If any middleware calls
- * the callback with the first parameter an instance of Error, then the call stack will be aborted,
- * and the final callback (callback of first input) will be called with the Error as the first i
- * parameter.
- * Additionally, if provided during the `createMiddleware` call, the errorHandler will be called,
- * with the error object as the first parameter along with the remaining parameters.
- *
- * @param {function} middleware Any number of functions, each expecting a callback as the final
- * parameter.
- * @return {function} entry The entry function, which will start calling functions defined in the
- * chain.
- *
- * @example
- *
- *  const entry = middleware.chain(
- *    (data, cb) => {
- *      //... do something with data
- *      cb(data);
- *    },
- *    (data, cb) => {
- *      //... do more with data
- *      cb(data);
- *    },
- *    (data, cb) => {
- *      //... do last stuff with data
- *      cb();
- *    }
- *  );
- *
- *  entry(initialData, (err) => {
- *    // this function is called when complete or an error occurs anywhere on the chain
- *    // in which case execution is aborted.
- *  });
- *
- */

package/src/platform-instance.test.ts

@@ -126,10 +126,8 @@ describe("PlatformInstance", () => {
         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');
@@ -153,7 +151,7 @@ describe("PlatformInstance", () => {
     });
 
     it('sends messages to client using socket session id', async () => {
-      await pi.sendToClient('my session id', 'message',
+      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);
@@ -186,19 +184,19 @@ describe("PlatformInstance", () => {
       });
 
       it('appends completed result message when present', async () => {
-        await pi.handleJobResult('completed', {msg: {foo: 'bar'}},
+        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, undefined, 'completed',
-          {foo: 'bar', object: {'@type': 'result', content: 'a good result message'}});
+        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
+          {foo: 'bar'});
       });
 
       it('appends failed result message when present', async () => {
-        await pi.handleJobResult('failed', {msg: {foo: 'bar'}},
+        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, undefined, 'failed',
-          {foo: 'bar', object: {'@type': 'error', content: 'a bad result message'}});
+        sandbox.assert.calledWith(pi.sendToClient, 'a session id',
+          {foo: 'bar', error: 'a bad result message'});
       });
     });
 
@@ -232,7 +230,7 @@ describe("PlatformInstance", () => {
         const message = pi.callbackFunction('message', 'my session id');
         message(['blah', {foo: 'bar'}]);
         sandbox.assert.calledWith(pi.sendToClient,
-          'my session id', 'message', {foo:'bar'});
+          'my session id', {foo:'bar'});
       });
     });
   });

package/src/platform-instance.ts

@@ -4,12 +4,12 @@ import { debug, Debugger } from 'debug';
 import Queue from 'bull';
 
 import config from "./config";
-import { ActivityObject, JobDataDecrypted, JobEncrypted } from "./sockethub";
+import { ActivityStream, JobDataDecrypted, JobEncrypted } from "./sockethub";
 import { getSocket } from "./serve";
-import {decryptJobData} from "./common";
+import { decryptJobData } from "./common";
 
 // collection of platform instances, stored by `id`
-export const platformInstances = new Map();
+export const platformInstances = new Map<string, PlatformInstance>();
 
 export interface PlatformInstanceParams {
   identifier: string;
@@ -18,26 +18,32 @@ export interface PlatformInstanceParams {
   actor?: string;
 }
 
-interface MessageFromPlatform extends Array<string|ActivityObject>{
-  0: string, 1: ActivityObject, 2: 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();
-  public readonly global?: boolean = false;
-  private readonly actor?: string;
-  private readonly sessionCallbacks: object = {
+  readonly sessionCallbacks: object = {
     'close': (() => new Map())(),
-    'message': (() => new Map())(),
+    'message': (() => new Map())()
   };
+  public readonly global?: boolean = false;
+  private readonly actor?: string;
 
   constructor(params: PlatformInstanceParams) {
     this.id = params.identifier;
@@ -58,29 +64,21 @@ export default class PlatformInstance {
    * Destroys all references to this platform instance, internal listeners and controlled processes
    */
   public async destroy() {
+    this.debug(`cleaning up`);
     this.flaggedForTermination = true;
-    platformInstances.delete(this.id);
-    try {
-      await this.queue.empty();
-    } catch (e) { }
-    try {
-      await this.queue.clean(0);
-    } catch (e) { }
     try {
-      await this.queue.close();
-    } catch (e) { }
-    try {
-      this.queue.removeAllListeners();
+      await this.queue.removeAllListeners();
     } catch (e) { }
     try {
       await this.queue.obliterate({ force: true });
     } catch (e) { }
     try {
       delete this.queue;
-      this.process.removeAllListeners('close');
-      this.process.unref();
-      this.process.kill();
+      await this.process.removeAllListeners('close');
+      await this.process.unref();
+      await this.process.kill();
     } catch (e) { }
+    platformInstances.delete(this.id);
   }
 
   /**
@@ -88,20 +86,23 @@ export default class PlatformInstance {
    */
   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);
-        job.remove();
+        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);
-        job.remove();
+        await job.remove();
       });
     });
   }
@@ -125,55 +126,58 @@ export default class PlatformInstance {
    * 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 type type of message to emit. 'message', 'completed', 'failed'
    * @param msg ActivityStream object to send to client
    */
-  public sendToClient(sessionId: string, type: string, msg: ActivityObject) {
+  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)) {
+      if ((msg.type === 'error') && (typeof msg.actor === 'undefined') && (this.actor)) {
         // ensure an actor is present if not otherwise defined
-        msg.actor = this.actor;
+        msg.actor = { id: this.actor };
       }
-      socket.emit(type, msg);
+      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: ActivityObject) {
+  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, 'message', msg);
+        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(`job ${jobData.title}: ${type}`);
-    if ((type === 'completed') && (result)) {
-      jobData.msg.object = {
-        '@type': 'result',
-        content: result
-      };
-    } else if (type === 'failed') {
-      jobData.msg.object = {
-        '@type': 'error',
-        content: result ? result : "job failed for unknown reason"
-      };
+    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 message to client as completed for failed job
-    await this.sendToClient(jobData.sessionId, type, jobData.msg);
+    // 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, jobData.msg);
+    await this.broadcastToSharedPeers(jobData.sessionId, msg);
   }
 
   /**
@@ -181,19 +185,16 @@ export default class PlatformInstance {
    * @param sessionId
    * @param errorMessage
    */
-  private reportError(sessionId: string, errorMessage: any) {
-    const errorObject: ActivityObject = {
+  private async reportError(sessionId: string, errorMessage: any) {
+    const errorObject: ActivityStream = {
       context: this.name,
-      '@type': 'error',
-      actor: this.actor,
-      object: {
-        '@type': 'error',
-        content: errorMessage
-      }
+      type: 'error',
+      actor: { id: this.actor },
+      error: errorMessage
     };
-    this.sendToClient(sessionId, 'message', errorObject);
+    this.sendToClient(sessionId, errorObject);
     this.sessions.clear();
-    this.destroy();
+    await this.destroy();
   }
 
   /**
@@ -226,7 +227,7 @@ export default class PlatformInstance {
           this.reportError(sessionId, data[1]);
         } else {
           // treat like a message to clients
-          this.sendToClient(sessionId, 'message', data[1]);
+          this.sendToClient(sessionId, data[1]);
         }
       }
     };

package/src/platform.ts

@@ -3,9 +3,9 @@ import hash from "object-hash";
 import config from './config';
 import Queue from 'bull';
 import { getPlatformId, decryptJobData } from "./common";
-import { ActivityObject, JobDataDecrypted, JobEncrypted } from "./sockethub";
+import { ActivityStream, JobDataDecrypted, JobEncrypted } from "./sockethub";
 import { MessageFromParent } from './platform-instance';
-import {getSessionStore} from "./store";
+import { getSessionStore } from "./store";
 
 // command-line params
 const parentId = process.argv[2];
@@ -23,7 +23,7 @@ logger(`platform handler initialized for ${platformName} ${identifier}`);
 
 export interface PlatformSession {
   debug(msg: string): void;
-  sendToClient(msg: ActivityObject, special?: string): void;
+  sendToClient(msg: ActivityStream, special?: string): void;
   updateActor(credentials: object): void;
 }
 
@@ -31,7 +31,7 @@ export interface PlatformSession {
  * Handle any uncaught errors from the platform by alerting the worker and shutting down.
  */
 process.on('uncaughtException', (err) => {
-  console.log('UNCAUGHT EXCEPTION IN PLATFORM');
+  console.log('EXCEPTION IN PLATFORM');
   // eslint-disable-next-line security-node/detect-crlf
   console.log(err.stack);
   process.send(['error', err.toString()]);
@@ -84,7 +84,7 @@ function getCredentials(actorId: string, sessionId: string, sessionSecret: strin
     if (platform.credentialsHash) {
       if (platform.credentialsHash !== hash(credentials.object)) {
         return cb('provided credentials do not match existing platform instance for actor '
-            + platform.actor['@id']);
+            + platform.actor.id);
       }
     } else {
       platform.credentialsHash = hash(credentials.object);
@@ -101,11 +101,11 @@ function getJobHandler(secret: string) {
   return (job: JobEncrypted, done: Function) => {
     const jobData: JobDataDecrypted = decryptJobData(job, secret);
     const jobLog = debug(`${loggerPrefix}:${jobData.sessionId}`);
-    jobLog(`job ${jobData.title}: ${jobData.msg['@type']}`);
+    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,
+    return getCredentials(jobData.msg.actor.id, jobData.sessionId, sessionSecret,
       (err, credentials) => {
         if (err) { return done(new Error(err)); }
         let jobCallbackCalled = false;
@@ -113,17 +113,33 @@ function getJobHandler(secret: string) {
           if (jobCallbackCalled) { return; }
           jobCallbackCalled = true;
           if (err) {
-            done(err instanceof Error ? err : new Error(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']))) {
+          (platform.config.requireCredentials.includes(jobData.msg.type))) {
           // add the credentials object if this method requires it
-          platform[jobData.msg['@type']](jobData.msg, credentials, doneCallback);
+          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);
+          platform[jobData.msg.type](jobData.msg, doneCallback);
         }
       });
   };
@@ -135,7 +151,7 @@ function getJobHandler(secret: string) {
  * @param command string containing the type of command to be sent. 'message' or 'close'
  */
 function getSendFunction(command: string) {
-  return function (msg: ActivityObject, special?: string) {
+  return function (msg: ActivityStream, special?: string) {
     process.send([command, msg, special]);
   };
 }
@@ -146,8 +162,8 @@ function getSendFunction(command: string) {
  * @param credentials
  */
 function updateActor(credentials) {
-  identifier = getPlatformId(platformName, credentials.actor['@id']);
-  logger(`platform actor updated to ${credentials.actor['@id']} identifier ${identifier}`);
+  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}`);