@livedigital/client 3.10.0 → 3.11.0

package/dist/types/channelStateSyncronizer.d.ts

@@ -11,3 +11,9 @@ export interface ChannelStateSyncEventPayload {
     event: 'channel-state';
     data: ChannelState;
 }
+export interface ProbablyInconsistencyCheckResult {
+    probablyMissingPeers: string[];
+    probablyMissingProducers: string[];
+    probablyProducersWithInconsistentState: string[];
+}
+export declare type LastProbablyInconsistencyCheckResults = ProbablyInconsistencyCheckResult[];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/handlers/ChannelStateSyncEventHandler.ts

@@ -3,25 +3,28 @@ import { serializeError } from 'serialize-error';
 import { LogMessageHandler } from '../../types/common';
 import Engine from '../index';
 import Logger from '../Logger';
-import { ChannelState, ChannelStateSyncEventPayload } from '../../types/channelStateSyncronizer';
+import {
+  ChannelState,
+  ChannelStateSyncEventPayload,
+  LastProbablyInconsistencyCheckResults,
+  ProbablyInconsistencyCheckResult,
+} from '../../types/channelStateSyncronizer';
+
+const MAX_CHECK_RETRIES_BEFORE_CONFIRM = 2;
 
 class ChannelStateSyncEventHandler {
   private readonly engine: Engine;
 
   private readonly logger: Logger;
 
-  #probablyMissingPeers: string[] = [];
-
   #confirmedMissingPeers: string[] = [];
 
-  #probablyMissingProducers: string[] = [];
-
   #confirmedMissingProducers: string[] = [];
 
-  #probablyProducersWithInconsistentState: string[] = [];
-
   #confirmedProducersWithInconsistentState: string[] = [];
 
+  #lastProbablyInconsistencyCheckResults: LastProbablyInconsistencyCheckResults = [];
+
   constructor(params: { engine: Engine, onLogMessage?: LogMessageHandler }) {
     const { engine, onLogMessage } = params;
     this.engine = engine;
@@ -57,70 +60,47 @@ class ChannelStateSyncEventHandler {
 
   private notifyIfHasConfirmedInconsistency(localState: ChannelState, remoteState: ChannelState) {
     remoteState.peers.forEach((remotePeer) => {
-      const localPeer = localState.peers.find((peer) => peer.id === remotePeer.id);
-      if (!localPeer && this.#probablyMissingPeers.includes(remotePeer.id)) {
-        this.#confirmedMissingPeers.push(remotePeer.id);
-        this.logger.error('Peer is missing', {
-          case: 'channel-state-sync',
-          peerId: remotePeer.id,
-        });
-      }
-
-      if (!localPeer) {
+      const peer = localState.peers.find((p) => p.id === remotePeer.id);
+      if (!peer) {
+        this.notifyIfConfirmedPeerInconsistency(remotePeer.id);
         return;
       }
 
-      const confirmedMissingPeerIdx = this.#confirmedMissingPeers.indexOf(remotePeer.id);
-      if (confirmedMissingPeerIdx > -1) {
-        delete this.#confirmedMissingPeers[confirmedMissingPeerIdx];
-      }
+      this.resetPeerInconsistency(remotePeer.id);
 
       remotePeer.producers.forEach((remoteProducer) => {
-        const localProducer = localPeer.producers.find((producer) => producer.id === remoteProducer.id);
-        if (!localProducer && this.#probablyMissingProducers.includes(remoteProducer.id)) {
-          this.#confirmedMissingProducers.push(remoteProducer.id);
-          this.logger.error('Producer is missing', {
-            case: 'channel-state-sync',
-            producerId: remoteProducer.id,
-          });
-        }
-
-        if (!localProducer) {
+        const producer = peer.producers.find((p) => p.id === remoteProducer.id);
+        if (!producer) {
+          this.notifyIfConfirmedProducerInconsistency(remoteProducer.id);
           return;
         }
 
-        const confirmedMissingProducerIdx = this.#confirmedMissingProducers.indexOf(remoteProducer.id);
-        if (confirmedMissingProducerIdx > -1) {
-          delete this.#confirmedMissingProducers[confirmedMissingProducerIdx];
-        }
+        this.resetProducerInconsistency(producer.id);
 
-        const isInconsistentState = localProducer.paused !== remoteProducer.paused;
-        if (isInconsistentState && this.#probablyProducersWithInconsistentState.includes(remoteProducer.id)) {
-          this.#confirmedProducersWithInconsistentState.push(remoteProducer.id);
-          this.logger.error('Producer is in inconsistent state', {
-            case: 'channel-state-sync',
-            producerId: remoteProducer.id,
-            localPaused: localProducer.paused,
+        const isInconsistentState = producer.paused !== remoteProducer.paused;
+        if (isInconsistentState) {
+          this.notifyIfConfirmedProducerStateInconsistency(producer.id, {
+            localPaused: producer.paused,
             remotePaused: remoteProducer.paused,
           });
-        }
-
-        if (!isInconsistentState) {
-          const confirmedProducerWithInconsistentStateIdx = this
-            .#confirmedProducersWithInconsistentState.indexOf(remoteProducer.id);
 
-          if (confirmedProducerWithInconsistentStateIdx > -1) {
-            delete this.#confirmedProducersWithInconsistentState[confirmedProducerWithInconsistentStateIdx];
-          }
+          return;
         }
+
+        this.resetProducerStateInconsistency(producer.id);
       });
     });
   }
 
   private prepareProbableInconsistencyStats(localState: ChannelState, remoteState: ChannelState) {
-    this.#probablyMissingPeers = [];
-    this.#probablyMissingProducers = [];
-    this.#probablyProducersWithInconsistentState = [];
+    const probablyMissingPeers: string[] = [];
+    const probablyMissingProducers: string[] = [];
+    const probablyProducersWithInconsistentState: string[] = [];
+
+    if (!this.getIsConnectionActive()) {
+      this.#lastProbablyInconsistencyCheckResults = [];
+      return;
+    }
 
     // fill probably missings for the second check
     remoteState.peers.forEach((remotePeer) => {
@@ -131,7 +111,7 @@ class ChannelStateSyncEventHandler {
 
       const localPeer = localState.peers.find((peer) => peer.id === remotePeer.id);
       if (!localPeer) {
-        this.#probablyMissingPeers.push(remotePeer.id);
+        probablyMissingPeers.push(remotePeer.id);
       }
 
       if (!localPeer) {
@@ -146,7 +126,7 @@ class ChannelStateSyncEventHandler {
 
         const localProducer = localPeer.producers.find((producer) => producer.id === remoteProducer.id);
         if (!localProducer) {
-          this.#probablyMissingProducers.push(remoteProducer.id);
+          probablyMissingProducers.push(remoteProducer.id);
         }
 
         if (!localProducer) {
@@ -160,10 +140,100 @@ class ChannelStateSyncEventHandler {
 
         const isInconsistentState = localProducer.paused !== remoteProducer.paused;
         if (isInconsistentState) {
-          this.#probablyProducersWithInconsistentState.push(remoteProducer.id);
+          probablyProducersWithInconsistentState.push(remoteProducer.id);
         }
       });
     });
+
+    if (this.#lastProbablyInconsistencyCheckResults.length === MAX_CHECK_RETRIES_BEFORE_CONFIRM) {
+      this.#lastProbablyInconsistencyCheckResults.shift();
+    }
+
+    this.#lastProbablyInconsistencyCheckResults.push({
+      probablyMissingPeers,
+      probablyMissingProducers,
+      probablyProducersWithInconsistentState,
+    });
+  }
+
+  private isReachedMaxCheckRetries(storageKey: keyof ProbablyInconsistencyCheckResult, id: string) {
+    let retries = 0;
+    this.#lastProbablyInconsistencyCheckResults.forEach((checkResults) => {
+      if (checkResults[storageKey].includes(id)) {
+        retries += 1;
+      }
+    });
+
+    return retries >= MAX_CHECK_RETRIES_BEFORE_CONFIRM;
+  }
+
+  private isAlreadyAlertedAbout(storage: string[], id: string) {
+    return storage.includes(id);
+  }
+
+  notifyIfConfirmedPeerInconsistency(peerId: string): void {
+    const isReachedMaxCheckRetries = this.isReachedMaxCheckRetries('probablyMissingPeers', peerId);
+    const isAlreadyAlertedAbout = this.isAlreadyAlertedAbout(this.#confirmedMissingPeers, peerId);
+    if (isReachedMaxCheckRetries && !isAlreadyAlertedAbout) {
+      this.#confirmedMissingPeers.push(peerId);
+      this.logger.warn('Peer is missing', {
+        case: 'channel-state-sync',
+        missingPeerId: peerId,
+      });
+    }
+  }
+
+  private resetPeerInconsistency(peerId: string) {
+    const confirmedMissingPeerIdx = this.#confirmedMissingPeers.indexOf(peerId);
+    if (confirmedMissingPeerIdx > -1) {
+      // issue resolved
+      delete this.#confirmedMissingPeers[confirmedMissingPeerIdx];
+    }
+  }
+
+  private notifyIfConfirmedProducerInconsistency(producerId: string) {
+    const isReachedMaxCheckRetries = this.isReachedMaxCheckRetries('probablyMissingProducers', producerId);
+    const isAlreadyAlertedAbout = this.isAlreadyAlertedAbout(this.#confirmedMissingProducers, producerId);
+    if (isReachedMaxCheckRetries && !isAlreadyAlertedAbout) {
+      this.#confirmedMissingProducers.push(producerId);
+      this.logger.warn('Producer is missing', {
+        case: 'channel-state-sync',
+        missingProducerId: producerId,
+      });
+    }
+  }
+
+  private resetProducerInconsistency(producerId: string) {
+    const confirmedMissingProducerIdx = this.#confirmedMissingProducers.indexOf(producerId);
+    if (confirmedMissingProducerIdx > -1) {
+      // issue resolved
+      delete this.#confirmedMissingProducers[confirmedMissingProducerIdx];
+    }
+  }
+
+  private notifyIfConfirmedProducerStateInconsistency(producerId: string, meta: Record<string, unknown>) {
+    const isReachedMaxCheckRetries = this.isReachedMaxCheckRetries(
+      'probablyProducersWithInconsistentState', producerId,
+    );
+    const isAlreadyAlertedAbout = this.isAlreadyAlertedAbout(this.#confirmedProducersWithInconsistentState, producerId);
+    if (isReachedMaxCheckRetries && !isAlreadyAlertedAbout) {
+      this.#confirmedProducersWithInconsistentState.push(producerId);
+      this.logger.warn('Producer is in inconsistent state', {
+        case: 'channel-state-sync',
+        producerId,
+        ...meta,
+      });
+    }
+  }
+
+  private resetProducerStateInconsistency(producerId: string) {
+    const confirmedProducersWithInconsistentStateIdx = this
+      .#confirmedProducersWithInconsistentState.indexOf(producerId);
+
+    if (confirmedProducersWithInconsistentStateIdx > -1) {
+      // issue resolved
+      delete this.#confirmedProducersWithInconsistentState[confirmedProducersWithInconsistentStateIdx];
+    }
   }
 
   private parseChannelStateSyncEventPayload(data: Buffer): ChannelStateSyncEventPayload {
@@ -183,6 +253,15 @@ class ChannelStateSyncEventHandler {
       })),
     };
   }
+
+  private getIsConnectionActive() {
+    try {
+      this.engine.checkConnectionActivity();
+      return true;
+    } catch (error: unknown) {
+      return false;
+    }
+  }
 }
 
 export default ChannelStateSyncEventHandler;

package/src/engine/index.ts

@@ -272,7 +272,7 @@ class Engine {
 
       this.removeClientEventEmitterListeners();
 
-      this.network.reset();
+      await this.network.reset();
       this.network.socket.disconnect();
 
       this.logger.debug('release()', {
@@ -345,7 +345,7 @@ class Engine {
     return this.peersRepository.get(id);
   }
 
-  public async confirmActivity(): Promise<void> {
+  public async checkConnectionActivity() {
     if (!this.channel || this.isChannelJoining) {
       throw new Error('Connect to the channel first');
     }
@@ -353,7 +353,10 @@ class Engine {
     if (!this.network.socket.connection?.active) {
       throw new Error('Socket is inactive');
     }
+  }
 
+  public async confirmActivity(): Promise<void> {
+    this.checkConnectionActivity();
     await this.network.socket.request(CHANNEL_EVENTS.activityConfirm);
   }
 

package/src/engine/network/index.ts

@@ -98,7 +98,11 @@ class Network {
     }
   }
 
-  public reset() {
+  public async reset() {
+    await Promise.all([
+      this.closeReceiveTransport(),
+      this.closeSendTransport(),
+    ]);
     this.stopRestartIceAtempts();
     this.removeEventListeners();
   }

package/src/types/channelStateSyncronizer.ts

@@ -12,3 +12,11 @@ export interface ChannelStateSyncEventPayload {
   event: 'channel-state';
   data: ChannelState;
 }
+
+export interface ProbablyInconsistencyCheckResult {
+  probablyMissingPeers: string[],
+  probablyMissingProducers: string[],
+  probablyProducersWithInconsistentState: string[],
+}
+
+export type LastProbablyInconsistencyCheckResults = ProbablyInconsistencyCheckResult[];