prep for production server

src/channels/channelBase.ts

@@ -48,7 +48,7 @@ class ChannelBase {
   broadcastMessage(from: ClientBase|null, message: string) {
     for (let client of this.clients) {
       if (client != from) {
-        client.ws.send(message);
+        client.ws.send(JSON.stringify(message));
         logger.accessLog.info(`sent to ${client.id}`, { data: { message: message }});
       } else {
         logger.accessLog.info(`client is same as sender: ${client.id}`, { data: { message: message }});

src/messageManager.ts

@@ -17,7 +17,8 @@ let schema = {
   user_id: Joi.number().integer(),
   user_exam_id: Joi.number().integer(),
   user_name: Joi.string(),
-  exam_title: Joi.string()
+  exam_title: Joi.string(),
+  message: Joi.string(),
 };
 
 module.exports = {

src/server.ts

@@ -15,99 +15,81 @@ import ChannelManager from './channelManager';
 import ClientBase from './clients/clientBase';
 import MHSClient from './clients/sites/mhsClient';
 
-var privateKey  = fs.readFileSync(app.privateKey, 'utf8');
-var certificate = fs.readFileSync(app.certificate, 'utf8');
-var options = {key: privateKey, cert: certificate, hostname: app.hostname};
 
-const application = express();
+if (app.environment == 'development') {
-const server = https.createServer(options, application);
+  var privateKey  = fs.readFileSync(app.privateKey, 'utf8');
-const wss = new WebSocket.Server({ noServer: true, maxPayload:250000, host: app.hostname });
+  var certificate = fs.readFileSync(app.certificate, 'utf8');
+  var options = {key: privateKey, cert: certificate, hostname: app.hostname};
 
-application.use(express.json());
+  const application = express();
-application.use('', routes);
+  const server = https.createServer(options, application);
+  var wss = new WebSocket.Server({ server: server, maxPayload:250000, host: app.hostname });
+
+  application.use(express.json());
+  application.use('', routes);
+
+  server.listen(app.port, () => {
+    console.log(`Braid v${app.version} is running!\n`);
+    logger.accessLog.info(`Braid v${app.version} is running!\n`);
+  });
+} else {
+  var wss = new WebSocket.Server({ noServer: true, maxPayload:250000, host: app.hostname });
+}
 
 let clientManager = new ClientManager();
 let channelManager = new ChannelManager();
 
 function connectionManager() {
-  wss.on('connection', (ws: WebSocket, request: object, args: string) => {
+  wss.on('connection', (ws: WebSocket, request: any, args: string) => {
-    var data = JSON.parse(args).data
+    var result = JSON.parse(validateJWT(request));
-    logger.accessLog.info(`Client Connected: ${data.user_id}`);
 
-    if (!channelManager.channelExists(data.channel)) {
+    if (result.error) {
-      channelManager.createChannel(data);
+      ws.send(`Unable to validate JWT, please try again or contact support...`);
-    }
+      ws.close();
+    } else {
+      var data = result.data;
+      logger.accessLog.info(`Client Connected: ${data.user_id}`);
 
-    if (clientManager.clientExists(data.user_id)) {
+      if (!channelManager.channelExists(data.channel)) {
-      var client: ClientBase|MHSClient|null = clientManager.getClient(data.user_id);
+        channelManager.createChannel(data);
+      }
+
+      if (clientManager.clientExists(data.user_id)) {
+        var client: ClientBase|MHSClient|null = clientManager.getClient(data.user_id);
+
+        if (client != null) {
+          client.replaceWebSocket(ws);
+        }
+      } else {
+        var client: ClientBase|MHSClient|null = clientManager.addClient(data, channelManager, ws);
+      }
 
       if (client != null) {
-        client.replaceWebSocket(ws);
+        channelManager.addClientToChannel(client, data.channel);
-      }
-    } else {
-      var client: ClientBase|MHSClient|null = clientManager.addClient(data, channelManager, ws);
-    }
-
-    if (client != null) {
-      channelManager.addClientToChannel(client, data.channel);
-    }
-
-    //remove any channels that have no users in them
-    logger.accessLog.info(`Purging empty channels...`);
-    channelManager.purgeEmptyChannels();
-
-    ws.send(`Hi there, welcome to braid, Measures Web Socket server. Connecting all our services!\nYou are currently in channel: ${data.channel}`);
-  });
-}
-
-function verifyConnection(request: any) {
-  return new Promise((resolve, reject) => {
-    var data = url.parse(request.url, true).query;
-    var token = data.token || (app.environment == 'development' ? app.devToken : '');
-    var accepted = true;
-    var result: string;
-
-    jwt.verify(token, app.secret, app.signOptions, function(err, decoded) {
-      if (err) {
-        console.log(err);
-        accepted = false;
       }
 
-      result = JSON.stringify(decoded)
+      //remove any channels that have no users in them
-      accepted ? resolve(result) : reject('rejected');
+      logger.accessLog.info(`Purging empty channels...`);
-    });
+      channelManager.purgeEmptyChannels();
-  });
-}
 
-function serverUpgrade() {
+      ws.send(`Hi there, welcome to braid, Measures Web Socket server. Connecting all our services!\nYou are currently in channel: ${data.channel}`);
-  server.on('upgrade', async function upgrade(request, socket, head) {
-    let args: {};
-
-    try {
-      args = await verifyConnection(request);
-    } catch (e) {
-      socket.destroy();
-      logger.accessLog.info('Connection Terminated');
-      return;
     }
-
-    wss.handleUpgrade(request, socket, head, function done(ws) {
-      wss.emit('connection', ws, request, args);
-    });
   });
 }
 
-function listenForConnection() {
+function validateJWT(request: any) {
-  server.listen(app.port, () => {
+  try {
-    console.log(`Braid v${app.version} is running!\n`);
+    var query = url.parse(request.url, true).query
-    logger.accessLog.info(`Braid v${app.version} is running!\n`);
+    var token = query.token || (app.environment == 'development' ? app.devToken : '');
-  });
+    return JSON.stringify(jwt.verify(token, app.secret, app.signOptions));
+  } catch (e) {
+    console.log(e);
+    return JSON.stringify({error: e});
+  }
 }
 
 function startServer() {
   connectionManager();
-  serverUpgrade();
-  listenForConnection();
 }
 
 startServer();