Websocket refactor (#7)

* blocking all messages now by default
* reconnect working and much cleaner
* overall much cleaner implementation
* Adding support for resuming Sibelius sessions

Author: smithkyle

.gitignore

@@ -1,3 +1,5 @@
+sibelius-session.json
+
 # Logs
 logs
 *.log

DoricoRemote.js

@@ -10,10 +10,12 @@ class DoricoRemote extends WebSocketClient {
     }
 
     onOpen() {
-        this.sendHandshake();
+        this._sendHandshake();
+
+        super.onOpen();
     }
 
-    sendHandshake() {
+    _sendHandshake() {
         const message = {
             message: 'connect',
             clientName: this.appName,
@@ -24,10 +26,10 @@ class DoricoRemote extends WebSocketClient {
             message.sessionToken = this.sessionToken;
         }
 
-        this.sendMessage(message);
+        this.send(message);
     }
 
-    onMessage(data) {
+    _processHandshake(data) {
         if (data.message === 'sessiontoken' && data.sessionToken) {
             this.sessionToken = data.sessionToken;
             console.log(`Received sessiontoken: ${this.sessionToken} - completing handshake`);
@@ -37,32 +39,24 @@ class DoricoRemote extends WebSocketClient {
                 sessionToken: this.sessionToken
             }
 
-            this.sendMessage(message);
+            this.send(message);
         }
         else if (data.message === 'response' && data.code === 'kConnected') {
             console.log(`Handshake complete for ${this.appName}`);
             this.handshakeDone = true;  // Handshake is now complete
-            this.sendQueuedMessages();  // Now safe to send queued messages
-        }
-        
-        if (this.callbackAddress && this.callbackAddress.length > 0) {
-            receive(this.callbackAddress, data)
+            this._processQueue();  // Now safe to send queued messages
         }
     }
 
-    onClose(event) {
-        if (event.code === 1000) {
-            console.log('Connection closed cleanly - send a command to open a new connection');
-            // this.sessionToken = null;
-            // this.handshakeDone = false;
-        } else {
-            console.log('Connection lost, retrying...');
+    onMessage(data) {
+        if (!this.handshakeDone && data.message === 'sessiontoken') {
+            this._processHandshake(data);
         }
-    }
-
-    close() {
-        if (this.socket?.readyState === WebSocket.OPEN) {
-            this.socket.close(1000, 'Unload');
+        
+        super.onMessage(data);
+        
+        if (this.callbackAddress && this.callbackAddress.length > 0) {
+            receive(this.callbackAddress, data)
         }
     }
 }

SibeliusConnect.js

@@ -1,4 +1,8 @@
-const WebSocketClient = require('./WebSocketClient.js')
+const fs = nativeRequire('fs');
+
+const WebSocketClient = require('./WebSocketClient.js');
+
+const SIB_SESSION_FILE = 'sibelius-session.json'
 
 class SibeliusConnect extends WebSocketClient {
     constructor({ appName = 'Sibelius Connect Remote', callbackAddress = '/SibeliusCallback', port = 1898, plugins = [] } = {}) {
@@ -10,53 +14,109 @@ class SibeliusConnect extends WebSocketClient {
         this.handshakeDone = false;
     }
 
-    onOpen() {
-        this.sendHandshake();
+    onOpen(resolve) {
+        // reset the message queue so we don't send a bunch of queued commands
+        // on reconnect, and because we need to send the handshake message first
+        this.messageQueue = [];
+        this._sendHandshake();
+        
+        super.onOpen(resolve);
     }
 
-    sendHandshake() {
+    _sendHandshake() {
         const message = {
             handshakeVersion: '1.0',
             clientName: this.appName,
             message: 'connect',
         };
 
+        const sessionData = loadJSON(SIB_SESSION_FILE, (e) => {
+            console.log(`${SIB_SESSION_FILE} not found - starting new session`)
+        });
+        this.sessionToken = sessionData?.sessionToken;
+
         if (this.sessionToken) {
             message.sessionToken = this.sessionToken;
         } else if (this.plugins.length > 0) {
             // We can't send a new list of plugins unless we're starting a new session
             message.plugins = this.plugins;
         }
 
-        this.sendMessage(message);
+        this.send(message);
+
+        if (message.sessionToken) {
+            // Sibelius doesn't send a response if reconnecting with a sessionToken,
+            // so we will simulate receiving the sessionToken again
+            this.onMessage({ data: JSON.stringify(sessionData) })
+        }
     }
 
-    onMessage(data) {
+    _processHandshake(data) {
+        console.log(data)
         if (data.sessionToken) {
             this.sessionToken = data.sessionToken;
             console.log('Received sessionToken:', this.sessionToken);
-            this.handshakeDone = true;  // Handshake is now complete
-            this.sendQueuedMessages();  // Now safe to send queued messages
+            saveJSON(SIB_SESSION_FILE, data, (e) => console.log("unable to save sessionToken", e));
+            this.handshakeDone = true;
+        }
+        else {
+            console.error("Handshake failed");
+        }
+    }
+
+    onMessage(event) {
+        const data = JSON.parse(event.data);
+
+        if (!this.handshakeDone && data.sessionToken) {
+            this._processHandshake(data);
         }
 
+        super.onMessage(event);
+
         if (this.callbackAddress && this.callbackAddress.length > 0) {
-            receive(this.callbackAddress, data)
+            receive(this.callbackAddress, data);
         }
     }
 
     onClose(event) {
         if (event.code === 1000) {
-            console.log('Connection closed cleanly - send a command to open a new connection');
+            console.log('Connection closing cleanly - will attempt a fresh connection');
             this.sessionToken = null;
             this.handshakeDone = false;
-        } else {
-            console.log('Connection lost, retrying...');
+            this.cleanupSocket();
+            this.shouldReconnect = true;
+            
+            this._removeSessionFile(`${__dirname}/${SIB_SESSION_FILE}`);
+        }
+
+        super.onClose(event)
+    }
+
+    _removeSessionFile(file) {
+        if (!fs.existsSync(file)) {
+            return;
         }
+        fs.unlink(file, (error) => {
+            if (error) {
+                console.warn(`Error removing ${file}`, error);
+                this.shouldReconnect = false;
+                return;
+            }
+
+            console.log(`Removed ${file}`);
+        })
     }
 
-    close() {
-        if (this.socket?.readyState === WebSocket.OPEN) {
-            this.socket.close(1000, 'Unload');
+    async send(message) {
+        if (!this.socket) {
+            await this.connect()
+        }
+
+        try {
+            super.send(message);
+        }
+        catch (e) {
+            console.error('caught error', e)
         }
     }
 }