Improved websocket to ensure the reconnection

src/services/websockets.service.ts

@@ -1,89 +1,135 @@
-import { AnkFlag } from 'pkg/sdk_client';
+import { AnkFlag } from '../../pkg/sdk_client'; // Vérifie le chemin vers pkg
 import Services from './service';
 
-let ws: WebSocket;
+let ws: WebSocket | null = null;
 let messageQueue: string[] = [];
+let reconnectInterval = 1000; // Délai initial de 1s avant reconnexion
+const MAX_RECONNECT_INTERVAL = 30000; // Max 30s
+let isConnecting = false;
+let urlReference: string = '';
+let pingIntervalId: any = null;
+
 export async function initWebsocket(url: string) {
-  ws = new WebSocket(url);
+  urlReference = url;
-
+  connect();
-  if (ws !== null) {
+}
-    ws.onopen = async (event) => {
+
-      console.log('WebSocket connection established');
+function connect() {
-
+  if (isConnecting || (ws && ws.readyState === WebSocket.OPEN)) return;
-      while (messageQueue.length > 0) {
+  isConnecting = true;
-        const message = messageQueue.shift();
+
-        if (message) {
+  console.log(`[WS] 🔌 Tentative de connexion à ${urlReference}...`);
-          ws.send(message);
+  ws = new WebSocket(urlReference);
-        }
+
-      }
+  ws.onopen = async () => {
-    };
+    console.log('[WS] ✅ Connexion établie !');
-
+    isConnecting = false;
-    // Listen for messages
+    reconnectInterval = 1000; // Reset du délai
-    ws.onmessage = (event) => {
+
-      const msgData = event.data;
+    // Démarrer le Heartbeat (Ping pour garder la connexion vivante)
-
+    startHeartbeat();
-      // console.log("Received text message: ", msgData);
+
-      (async () => {
+    // Vider la file d'attente (messages envoyés pendant la coupure)
-        if (typeof msgData === 'string') {
+    while (messageQueue.length > 0) {
-          try {
+      const message = messageQueue.shift();
-            const parsedMessage = JSON.parse(msgData);
+      if (message) ws?.send(message);
-            const services = await Services.getInstance();
+    }
-            switch (parsedMessage.flag) {
+  };
-              case 'Handshake':
+
-                await services.handleHandshakeMsg(url, parsedMessage.content);
+  ws.onmessage = (event) => {
-                break;
+    const msgData = event.data;
-              case 'NewTx':
+    if (typeof msgData === 'string') {
-                await services.parseNewTx(parsedMessage.content);
+      (async () => {
-                break;
+        try {
-              case 'Cipher':
+          const parsedMessage = JSON.parse(msgData);
-                await services.parseCipher(parsedMessage.content);
+          const services = await Services.getInstance();
-                break;
+
-              case 'Commit':
+          // Gestion des messages
-                // Basically if we see this it means we have an error
+          switch (parsedMessage.flag) {
-                await services.handleCommitError(parsedMessage.content);
+            case 'Handshake':
-                break;
+              await services.handleHandshakeMsg(urlReference, parsedMessage.content);
-            }
+              break;
-          } catch (error) {
+            case 'NewTx':
-            console.error('Received an invalid message:', error);
+              await services.parseNewTx(parsedMessage.content);
-          }
+              break;
-        } else {
+            case 'Cipher':
-          console.error('Received a non-string message');
+              await services.parseCipher(parsedMessage.content);
-        }
+              break;
-      })();
+            case 'Commit':
-    };
+              await services.handleCommitError(parsedMessage.content);
-
+              break;
-    // Listen for possible errors
+            // Ajoute d'autres cas si nécessaire
-    ws.onerror = (event) => {
+            default:
-      console.error('WebSocket error:', event);
+            // console.log('[WS] Message reçu:', parsedMessage.flag);
-    };
+          }
-
+        } catch (error) {
-    // Listen for when the connection is closed
+          console.error('[WS] Erreur traitement message:', error);
-    ws.onclose = (event) => {
+        }
-      console.log('WebSocket is closed now.');
+      })();
-    };
+    }
-  }
+  };
+
+  ws.onerror = (event) => {
+    console.error('[WS] 💥 Erreur:', event);
+    // Pas besoin de reconnecter ici, onclose sera appelé juste après
+  };
+
+  ws.onclose = (event) => {
+    isConnecting = false;
+    stopHeartbeat();
+    console.warn(`[WS] ⚠️ Déconnecté (Code: ${event.code}). Reconnexion dans ${reconnectInterval / 1000}s...`);
+
+    // Reconnexion exponentielle (1s, 1.5s, 2.25s...)
+    setTimeout(() => {
+      connect();
+      reconnectInterval = Math.min(reconnectInterval * 1.5, MAX_RECONNECT_INTERVAL);
+    }, reconnectInterval);
+  };
+}
+
+function startHeartbeat() {
+  stopHeartbeat();
+  // Envoie un ping toutes les 30 secondes pour éviter que le serveur ou le navigateur ne coupe la connexion
+  pingIntervalId = setInterval(() => {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      // Adapter selon ce que ton serveur attend comme Ping, ou envoyer un message vide
+      // ws.send(JSON.stringify({ flag: 'Ping', content: '' }));
+    }
+  }, 30000);
+}
+
+function stopHeartbeat() {
+  if (pingIntervalId) clearInterval(pingIntervalId);
 }
 
-// Method to send messages
 export function sendMessage(flag: AnkFlag, message: string): void {
-  if (ws.readyState === WebSocket.OPEN) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
     const networkMessage = {
       flag: flag,
       content: message,
     };
-    console.log('Sending message of type:', flag);
     ws.send(JSON.stringify(networkMessage));
   } else {
-    console.error('WebSocket is not open. ReadyState:', ws.readyState);
+    console.warn(`[WS] Pas connecté. Message '${flag}' mis en file d'attente.`);
-    messageQueue.push(message);
+    const networkMessage = {
+      flag: flag,
+      content: message,
+    };
+    messageQueue.push(JSON.stringify(networkMessage));
+
+    // Si on n'est pas déjà en train de se connecter, on force une tentative
+    if (!isConnecting) connect();
   }
 }
 
 export function getUrl(): string {
-  return ws.url;
+  return urlReference;
 }
 
-// Method to close the WebSocket connection
 export function close(): void {
-  ws.close();
+  if (ws) {
+    ws.onclose = null; // On évite la reconnexion auto si fermeture volontaire
+    stopHeartbeat();
+    ws.close();
+  }
 }