@livedigital/client 3.14.0 → 3.14.1

package/src/engine/handlers/ChannelStateSyncEventHandler.ts

@@ -1,270 +0,0 @@
-import { decompressSync, strFromU8 } from 'fflate';
-import { serializeError } from 'serialize-error';
-import { LogMessageHandler } from '../../types/common';
-import Engine from '../index';
-import Logger from '../Logger';
-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;
-
-  #confirmedMissingPeers: string[] = [];
-
-  #confirmedMissingProducers: string[] = [];
-
-  #confirmedProducersWithInconsistentState: string[] = [];
-
-  #lastProbablyInconsistencyCheckResults: LastProbablyInconsistencyCheckResults = [];
-
-  constructor(params: { engine: Engine, onLogMessage?: LogMessageHandler }) {
-    const { engine, onLogMessage } = params;
-    this.engine = engine;
-    this.logger = new Logger({
-      logLevel: engine.logLevel,
-      namespace: 'ChannelStateSyncEventHandler',
-      onLogMessage,
-    });
-  }
-
-  async handle(payload: Buffer): Promise<void> {
-    try {
-      const { event, data } = await this.parseChannelStateSyncEventPayload(payload);
-      if (event === 'channel-state') {
-        this.handleChannelStateEvent(data);
-      }
-    } catch (error: unknown) {
-      this.logger.error('handleChannelStateSyncEvent()', {
-        error: serializeError(error),
-      });
-    }
-  }
-
-  private handleChannelStateEvent(remoteState: ChannelState) {
-    const localState = this.getLocalState();
-    this.processStateInconsistency(localState, remoteState);
-  }
-
-  private processStateInconsistency(localState: ChannelState, remoteState: ChannelState) {
-    this.notifyIfHasConfirmedInconsistency(localState, remoteState);
-    this.prepareProbableInconsistencyStats(localState, remoteState);
-  }
-
-  private notifyIfHasConfirmedInconsistency(localState: ChannelState, remoteState: ChannelState) {
-    remoteState.peers.forEach((remotePeer) => {
-      const peer = localState.peers.find((p) => p.id === remotePeer.id);
-      if (!peer) {
-        this.notifyIfConfirmedPeerInconsistency(remotePeer.id);
-        return;
-      }
-
-      this.resetPeerInconsistency(remotePeer.id);
-
-      remotePeer.producers.forEach((remoteProducer) => {
-        const producer = peer.producers.find((p) => p.id === remoteProducer.id);
-        if (!producer) {
-          this.notifyIfConfirmedProducerInconsistency(remoteProducer.id);
-          return;
-        }
-
-        this.resetProducerInconsistency(producer.id);
-
-        const isInconsistentState = producer.paused !== remoteProducer.paused;
-        if (isInconsistentState) {
-          this.notifyIfConfirmedProducerStateInconsistency(producer.id, {
-            localPaused: producer.paused,
-            remotePaused: remoteProducer.paused,
-          });
-
-          return;
-        }
-
-        this.resetProducerStateInconsistency(producer.id);
-      });
-    });
-  }
-
-  private prepareProbableInconsistencyStats(localState: ChannelState, remoteState: ChannelState) {
-    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) => {
-      if (this.#confirmedMissingPeers.includes(remotePeer.id)) {
-        // already alerted about
-        return;
-      }
-
-      const localPeer = localState.peers.find((peer) => peer.id === remotePeer.id);
-      if (!localPeer) {
-        probablyMissingPeers.push(remotePeer.id);
-      }
-
-      if (!localPeer) {
-        return;
-      }
-
-      remotePeer.producers.forEach((remoteProducer) => {
-        if (this.#confirmedMissingProducers.includes(remoteProducer.id)) {
-          // already alerted about
-          return;
-        }
-
-        const localProducer = localPeer.producers.find((producer) => producer.id === remoteProducer.id);
-        if (!localProducer) {
-          probablyMissingProducers.push(remoteProducer.id);
-        }
-
-        if (!localProducer) {
-          return;
-        }
-
-        if (this.#confirmedProducersWithInconsistentState.includes(remoteProducer.id)) {
-          // already alerted about
-          return;
-        }
-
-        const isInconsistentState = localProducer.paused !== remoteProducer.paused;
-        if (isInconsistentState) {
-          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 async parseChannelStateSyncEventPayload(data: Blob | Buffer): Promise<ChannelStateSyncEventPayload> {
-    const arrayData = 'arrayBuffer' in data
-      ? new Uint8Array(await data.arrayBuffer())
-      : new Uint8Array(data);
-    const decompressed = decompressSync(arrayData);
-    return JSON.parse(strFromU8(decompressed)) as ChannelStateSyncEventPayload;
-  }
-
-  private getLocalState(): ChannelState {
-    const { hostPeers } = this.engine;
-    return {
-      peers: hostPeers.map((peer) => ({
-        id: peer.id,
-        producers: peer.getProducers().map((producer) => ({
-          id: producer.id,
-          paused: producer.paused,
-        })),
-      })),
-    };
-  }
-
-  private getIsConnectionActive() {
-    try {
-      this.engine.checkConnectionActivity();
-      return true;
-    } catch (error: unknown) {
-      return false;
-    }
-  }
-}
-
-export default ChannelStateSyncEventHandler;