@soundworks/core 4.0.0-alpha.5 → 4.0.0-alpha.7

package/src/server/SharedStateCollection.js

@@ -0,0 +1,36 @@
+import BaseSharedStateCollection from '../common/BaseSharedStateCollection.js';
+
+// this file exists only for documentation purposesSharedStateCollection.js
+
+/**
+ * @callback server.SharedStateCollection~onUpdateCallback
+ * @param {server.SharedState} state - State that triggered the update.
+ * @param {Object} newValues - Key / value pairs of the updates that have been
+ *  applied to the state.
+ * @param {Object} oldValues - Key / value pairs of the updated params before
+ *  the updates has been applied to the state.
+ * @param {Mixed} [context=null] - Optionnal context object that has been passed
+ *  with the values updates in the `set` call.
+ */
+
+/**
+ * The `SharedStateCollection` interface represent a collection of all states
+ * created from a given schema name on the network, at the execption of the ones
+ * created by the current node.
+ *
+ * ```
+ * const collection = await server.stateManager.getCollection('my-schema');
+ * const allValues = collection.getValues();
+ * collection.onUpdate((state, newValues, oldValues, context) => {
+ *   // do something
+ * });
+ * ```
+ * @memberof server
+ * @extends BaseSharedStateCollection
+ * @inheritdoc
+ * @hideconstructor
+ */
+class SharedStateCollection extends BaseSharedStateCollection {}
+
+export default SharedStateCollection;
+

package/src/server/Sockets.js

@@ -2,9 +2,9 @@ import { Worker } from 'node:worker_threads';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import querystring from 'querystring';
 import { WebSocketServer } from 'ws';
 import WebSocket from 'ws';
-import querystring from 'querystring';
 
 import Socket from './Socket.js';
 
@@ -69,13 +69,13 @@ class Sockets {
 
     // init ws server
     this._wss = new WebSocketServer({
-      server: server.httpServer,
+      noServer: true,
       path: `/${config.path}`, // @note - update according to existing config files (aka cosima-apps)
     });
 
     this._wss.on('connection', (ws, req) => {
       const queryString = querystring.decode(req.url.split('?')[1]);
-      const { role, key } = queryString;
+      const { role, key, token } = queryString;
       const binary = !!(parseInt(queryString.binary));
 
       if (binary) {
@@ -96,8 +96,29 @@ class Sockets {
         socket.addToRoom('*');
         socket.addToRoom(role);
 
-        onConnectionCallback(role, socket);
+        onConnectionCallback(role, socket, token);
+      }
+    });
+
+    // check if client can connect
+    server.httpServer.on('upgrade', async (req, socket, head) => {
+      const queryString = querystring.decode(req.url.split('?')[1]);
+
+      const { role, token } = queryString;
+
+      if (server.isProtected(role)) {
+        // we don't have any ip in the upgrade request, so we just check the
+        // connection token is pending
+        const allowed = server.isValidConnectionToken(token);
+
+        if (!allowed) {
+          socket.destroy('not allowed');
+        }
       }
+
+      this._wss.handleUpgrade(req, socket, head, (ws) => {
+        this._wss.emit('connection', ws, req);
+      });
     });
   }
 

package/src/server/StateManager.js

@@ -359,7 +359,9 @@ class StateManager extends BaseStateManager {
           client.transport.emit(CREATE_RESPONSE, reqId, stateId, remoteId, schemaName, sendedSchema, currentValues);
 
           this._observers.forEach(observer => {
-            observer.transport.emit(OBSERVE_NOTIFICATION, [schemaName, stateId, nodeId]);
+            if (observer.id !== nodeId) {
+              observer.transport.emit(OBSERVE_NOTIFICATION, schemaName, stateId, nodeId);
+            }
           });
         } catch (err) {
           client.transport.emit(CREATE_ERROR, reqId, err.message);
@@ -428,7 +430,7 @@ class StateManager extends BaseStateManager {
         const { schemaName, id, _creatorId } = state;
         // only track application states
         // (e.g. do not propagate infos about audit state)
-        if (!PRIVATE_STATES.includes(schemaName)) {
+        if (!PRIVATE_STATES.includes(schemaName) && _creatorId !== client.id) {
           statesInfos.push([schemaName, id, _creatorId]);
         }
       });

package/src/server/crypto.js

@@ -0,0 +1,38 @@
+import crypto from 'node:crypto';
+import { v4 as uuidv4 } from 'uuid';
+
+// adapted from https://dev.to/jobizil/encrypt-and-decrypt-data-in-nodejs-using-aes-256-cbc-2l6d
+// generate a new key and init vector each time the server restart, we don't need
+// any persistency here
+const secretKey = uuidv4();
+const secretIv = uuidv4();
+const encryptionMethod = 'aes-256-cbc';
+
+const key = crypto
+  .createHash('sha512')
+  .update(secretKey)
+  .digest('hex')
+  .substring(0, 32);
+
+const encryptionIV = crypto
+  .createHash('sha512')
+  .update(secretIv)
+  .digest('hex')
+  .substring(0, 16);
+
+
+export function encryptData(obj) {
+  const data = JSON.stringify(obj);
+  const cipher = crypto.createCipheriv(encryptionMethod, key, encryptionIV)
+  return Buffer.from(
+    cipher.update(data, 'utf8', 'hex') + cipher.final('hex')
+  ).toString('base64')
+}
+
+export function decryptData(encryptedData) {
+  const buff = Buffer.from(encryptedData, 'base64')
+  const decipher = crypto.createDecipheriv(encryptionMethod, key, encryptionIV)
+
+  const decrypted = `${decipher.update(buff.toString('utf8'), 'hex', 'utf8')}${decipher.final('utf8')}`
+  return JSON.parse(decrypted);
+}

package/.github/workflows/main.yml

@@ -1,15 +0,0 @@
-name: "Unit Tests"
-on: push
-
-jobs:
-    test:
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v3.3.0
-            - name: 'Install Node'
-              uses: actions/setup-node@v3.6.0
-            - name: Install dependencies
-              run: npm install 
-            - name: "Run Test"
-              run: npm test -- tests/**.spec.js