fixes #82

app/api/projects/ProjectPut.js

@@ -11,9 +11,9 @@ module.exports = ( req, res ) => {
 
   Project.findOne( { _id: req.params.projectId } )
     .then( resource => PermissionCheck( req.user, 'read', resource ) )
-    .then( resource => resource.set( req.body ).save() )
-    .then( resource => {
-      res.send( { success: true, message: `Patched ${Object.keys(req.body)} for ${req.params.projectId}.` } )
+    .then( resource => resource.set( req.body ).save( ) )
+    .then( ( ) => {
+      res.send( { success: true, message: `Patched ${Object.keys( req.body )} for ${req.params.projectId}.` } )
     } )
     .catch( err => {
       winston.error( err )

app/ws/ClientStore.js

@@ -1,47 +1,67 @@
 const winston = require( '../../config/logger' )
 const chalk = require( 'chalk' )
+const redis = require( 'redis' )
+
+
 
 // this is where we keep track on each process what clients are connected.
 module.exports = {
   clients: [ ],
 
+  redisClient: redis.createClient( process.env.REDIS_URL ),
   // adds a ws to the local store, and initialises a heartbeat pinger
-  add ( ws ) {
-    // setup vars
-    ws.alive = true
-    ws.missedPingsCount = 0
-
-    // setup pinging system
-    ws.pinger = setInterval( ws => {
-      if ( !ws.alive ) {
-        ws.missedPingsCount++
-        if ( ws.missedPingsCount > 25 ) { ws.send( 'Warning: you missed 25 pings. 50 missed pings will get you kicked.' ) }
-        if ( ws.missedPingsCount > 50 ) {
-          winston.error( chalk.red( 'Removing client socket, missed too many pings.' ) )
-          ws.send( 'You missed 50 pings. Bye!' )
-          this.remove( ws )
-          return
+  add( ws ) {
+    this.redisClient.get( ws.clientId, ( err, reply ) => {
+      if ( reply !== null ) {
+        winston.debug( `duplicate client id found: ${ws.clientId}. Will not add.` )
+        ws.send( 'dupe key boss. try a new identity.' )
+        ws.clientId = 'dupe'
+        ws.close( )
+        return
+      }
+      // add his identity to the redis datastore
+      this.redisClient.set( ws.clientId, ws.clientId )
+
+      // setup vars
+      ws.alive = true
+      ws.missedPingsCount = 0
+
+      // setup pinging system
+      ws.pinger = setInterval( ws => {
+        if ( !ws.alive ) {
+          ws.missedPingsCount++
+          if ( ws.missedPingsCount > 25 ) { ws.send( 'Warning: you missed 25 pings. 50 missed pings will get you kicked.' ) }
+          if ( ws.missedPingsCount > 50 ) {
+            winston.error( chalk.red( 'Removing client socket, missed too many pings.' ) )
+            ws.send( 'You missed 50 pings. Bye!' )
+            this.remove( ws )
+            return
+          }
+          ws.alive = false
         }
         ws.alive = false
-      }
-      ws.alive = false
-      ws.send( 'ping' )
-    }, 10000, ws ) // ping every 10 seconds, after 500 seconds of no pingbacks we kick the socket
-
-    // push to my amazing datastore
-    this.clients.push( ws )
-    winston.debug( chalk.green("(add) Clients: " + this.clients.length + ".") )
-    winston.debug( chalk.blue( `There are now ${this.clients.length} ws clients in ${process.pid}: ${this.clients.map( cl => cl.clientId )}` ) )
+        ws.send( 'ping' )
+      }, 10000, ws ) // ping every 10 seconds, after 500 seconds of no pingbacks we kick the socket
+
+      // push to my amazing datastore
+      this.clients.push( ws )
+      winston.debug( chalk.green( "(add) Clients: " + this.clients.length + "." ) )
+      winston.debug( chalk.blue( `There are now ${this.clients.length} ws clients in ${process.pid}: ${this.clients.map( cl => cl.clientId )}` ) )
+    } )
   },
 
-  remove ( ws ) {
+  remove( ws ) {
+    // escape the  jaws of destruction
+    if ( this.clients.indexOf( ws ) === -1 ) return
     // stop pinging this guy
     clearInterval( ws.pinger )
     // cut him out
-    this.clients.splice( this.clients.indexOf( ws ), 1 )
-    ws.close()
+    this.clients = this.clients.filter( c => c.clientId !== ws.clientId )
+    ws.close( )
+
+    this.redisClient.del( ws.clientId, ( ) => {} )
 
     winston.debug( chalk.bgRed( 'Socket removed', ws.clientId ) )
-    winston.debug( chalk.blue( `There are now ${this.clients.length} ws clients in ${process.pid}.` ) )
+    winston.debug( chalk.blue( `There are now ${this.clients.length} ws clients in ${process.pid}.\n${this.clients.map( c =>  c.clientId ) }` ) )
   }
 }

app/ws/RadioTower.js

@@ -33,17 +33,6 @@ module.exports = {
             winston.error( err.message )
           } )
       }
-      if ( channel === 'id-check' ) {
-        //  TODO
-        console.log( 'id checking bot', message )
-        let existingClient = ClientStore.clients.find( client => client.clientId === message )
-        if ( existingClient ) {
-          console.log( 'Heya boy.' )
-          this.publisher.publish( 'id-check-response', 'true' )
-        }
-
-        //return existingClient === null
-      }
     } )
   },
 

app/ws/SpeckleSockets.js

@@ -8,19 +8,16 @@ const radioTower = require( './RadioTower' )
 
 const User = require( '../../models/User' )
 
+// start a redis publisher & subscriber
+let redisPublisher = redis.createClient( process.env.REDIS_URL )
+redisPublisher.on( 'connect', ( ) => {
+  winston.debug( `${process.pid} connected to redis.` )
+} )
+
 module.exports = function( wss ) {
   // start a redis subscriber in the radio tower
   radioTower.initRedis( )
 
-  // start a redis publisher
-  let redisPublisher = redis.createClient( process.env.REDIS_URL )
-  let redisSubscriber = redis.createClient( process.env.REDIS_URL )
-  redisSubscriber.subscribe( 'id-check-response' )
-
-  redisPublisher.on( 'connect', ( ) => {
-    winston.debug( `${process.pid} connected to redis.` )
-  } )
-
   wss.on( 'connection', function( ws, req ) {
     winston.debug( chalk.blue( `Ws connection request in PID ${process.pid}` ) )
 
@@ -32,13 +29,6 @@ module.exports = function( wss ) {
     }
     let token = location.query.access_token
 
-    redisPublisher.publish( 'id-check', location.query.client_id )
-    redisSubscriber.on( 'message', ( channel, message ) => {
-      if ( channel !== 'id-check-response' ) return
-      ws.send('Bad boy, dupe ids and all that.')
-      ws.close( )
-    } )
-
     ws.authorised = false
     ws.clientId = location.query.client_id
     ws.rooms = [ location.query.stream_id ]
@@ -63,7 +53,6 @@ module.exports = function( wss ) {
         ws.missedPingsCount = 0
         return
       }
-
       // pub to redis otherwise
       redisPublisher.publish( 'speckle-message', JSON.stringify( { content: message, clientId: ws.clientId } ) )
     } )

config/logger.js

@@ -1,11 +1,8 @@
 'use strict'
 const fs = require( 'fs' )
-const path = require( 'path' )
 const { createLogger, format, transports } = require( 'winston' )
-const drf = require( 'winston-daily-rotate-file' )
+require( 'winston-daily-rotate-file' )
 
-
-const env = process.env.NODE_ENV || 'dev'
 const logDir = 'logs'
 
 if ( !fs.existsSync( logDir ) ) {
@@ -26,10 +23,7 @@ const logger = createLogger( {
   transports: [
     new transports.Console( {
       level: 'debug',
-      format: format.combine(
-        format.colorize( ),
-        format.timestamp( { format: 'YYYY-MM-DD HH:mm:ss' } ),
-        format.printf( info => `${info.timestamp} ${info.level}: ${info.message}` ), )
+      format: format.combine( format.colorize( ), format.timestamp( { format: 'YYYY-MM-DD HH:mm:ss' } ), format.printf( info => `${info.timestamp} ${info.level}: ${info.message}` ) )
     } ),
     drfTransport
   ]

config/passport.js

@@ -1,7 +1,4 @@
 'use strict'
-const winston = require( '../config/logger' )
-const chalk = require( 'chalk' )
-
 var JwtStrategy = require( 'passport-jwt' ).Strategy
 var AnonymousStrategy = require( 'passport-anonymous' )
 var ExtractJwt = require( 'passport-jwt' ).ExtractJwt
@@ -19,11 +16,9 @@ module.exports = function ( passport ) {
     User.findOne( { _id: jwtPayload._id } )
       .then( user => {
         if ( !user ) throw new Error( 'No user found.' )
-        // winston.debug( chalk.bgBlue( 'Strict authentication' ), chalk.bgGreen( 'OK' ) )
         done( null, user )
       } )
       .catch( err => {
-        // winston.debug( chalk.bgBlue( 'Strict authentication' ), chalk.bgRed( 'FAILED' ) )
         done( err, false ) // not ok
       } )
   } ) )

server.js

@@ -7,6 +7,7 @@ const passport = require( 'passport' )
 const chalk = require( 'chalk' )
 const mongoose = require( 'mongoose' ).set( 'debug', false )
 const expressWinston = require( 'express-winston' )
+const redis = require( 'redis' )
 const logger = require( './config/logger' )
 
 // load up .env
@@ -42,6 +43,13 @@ if ( cluster.isMaster ) {
     cluster.fork( )
   } )
 
+  // flush redis
+  let redisClient = redis.createClient( process.env.REDIS_URL )
+  redisClient.on( 'connect', ( ) => {
+    logger.debug( `Flushing redis database.` )
+    redisClient.flushdb( )
+  } )
+
   /////////////////////////////////////////////////////////////////////////
   /// CHILD processes                                                /////.
   /////////////////////////////////////////////////////////////////////////