@livedigital/client 3.48.0 → 3.49.1

package/src/engine/ChannelStateSynchronizer/ChannelStateSynchronizer.ts

@@ -1,448 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { serializeError } from 'serialize-error';
-import {
-  CHANNEL_EVENTS, CLIENT_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS,
-} from '../../constants/events';
-import Media from '../media';
-import { MyPeer } from '../MyPeer';
-import Network from '../network';
-import { Peers } from '../Peers';
-import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { debounce, deepEqualObject } from '../../helpers/common';
-import { TOKEN } from '../../inversify.tokens';
-import { PeerShortData } from '../../types/common';
-import EventsQueue from '../EventsQueue';
-import Logger from '../Logger';
-import Peer from '../Peer';
-import {
-  RestoreChannelStateResult,
-  RestoredLocalPeersStateResult,
-  RestoredProducersStateResult,
-  RestoredTracksResult,
-} from './types';
-import { ChannelState } from '../../proto/generated/channel/channel_state';
-import { Peer as ChannelMessagePeer } from '../../proto/generated/peer/peer';
-import { PeerRole as ChannelMessagePeerRole } from '../../proto/generated/peer/peer_role';
-import {
-  convertChannelMessagePeerToPeerResponse,
-  convertChannelMessageProducerToProducerData,
-} from '../../helpers/channelMessageConverter';
-import { FIVE_SECONDS_IN_MS } from '../../constants/common';
-import { retryAsync } from '../../helpers/retry';
-import { BaseTrack } from '../../types/media';
-import { Producer } from '../../proto/generated/producer/producer';
-
-const RESTORE_STATE_DEBOUNCE_TIME_MS = 3000;
-
-@injectable()
-class ChannelStateSynchronizer {
-  readonly #logger: Logger;
-
-  readonly debouncedTriggerChannelStateEvent: (
-    this: ChannelStateSynchronizer,
-  ) => void;
-
-  constructor(
-    @inject(TOKEN.Network) private readonly network: Network,
-    @inject(TOKEN.Media) private readonly media: Media,
-    @inject(TOKEN.MyPeer) private readonly myPeer: MyPeer,
-    @inject(TOKEN.EventsQueue) private readonly eventsQueue: EventsQueue,
-    @inject(TOKEN.ClientEventEmitter) private readonly clientEventEmitter: EnhancedEventEmitter,
-    @inject(TOKEN.Peers) private readonly peers: Peers,
-    @inject(TOKEN.LoggerFactory) loggerFactory: (namespace: string) => Logger,
-  ) {
-    this.#logger = loggerFactory('ChannelStateSyncEventHandler');
-
-    this.debouncedTriggerChannelStateEvent = debounce(
-      this.triggerChannelStateEvent.bind(this),
-      RESTORE_STATE_DEBOUNCE_TIME_MS,
-    );
-
-    this.watchNetworkState();
-  }
-
-  async handleChannelStateEvent(channelState: ChannelState): Promise<void> {
-    if (this.network.peersLoaded) {
-      await this.restoreState(channelState);
-    } else {
-      this.loadChannelState(channelState);
-    }
-
-    this.clientEventEmitter.emit(CLIENT_EVENTS.channelStateSynced);
-  }
-
-  private watchNetworkState(): void {
-    this.clientEventEmitter.on(CLIENT_EVENTS.connectionRestored, () => {
-      this.debouncedTriggerChannelStateEvent();
-    });
-  }
-
-  async triggerChannelStateEvent(): Promise<void> {
-    const triggerChannelStateEventWithRetry = async (): Promise<void> => await new Promise(async (resolve, reject) => {
-      const messageId = await this.network.triggerChannelStateEvent('host');
-      const timeout = setTimeout(() => {
-        if (this.eventsQueue.isMessageReceived(messageId)) {
-          this.#logger.info('Channel state event received', {
-            case: 'ChannelStateSynchronizer.triggerChannelStateEvent',
-          });
-
-          resolve();
-        } else {
-          reject(new Error('Channel state event not received'));
-        }
-      }, FIVE_SECONDS_IN_MS);
-
-      const abortOnConnectionLost = (): void => {
-        clearTimeout(timeout);
-        this.clientEventEmitter.off(CLIENT_EVENTS.connectionLost, abortOnConnectionLost);
-        resolve();
-      };
-
-      this.clientEventEmitter.on(CLIENT_EVENTS.connectionLost, abortOnConnectionLost);
-    });
-
-    try {
-      await retryAsync(triggerChannelStateEventWithRetry, {
-        maxRetries: 5,
-        actionName: 'triggerChannelStateEventWithRetry',
-        logger: this.#logger,
-      });
-    } catch (error: unknown) {
-      this.#logger.warn('Failed to trigger channel state event', {
-        case: 'ChannelStateSynchronizer.triggerChannelStateEvent',
-        error: serializeError(error),
-      });
-    }
-  }
-
-  loadChannelState(channelState: ChannelState): void {
-    this.#logger.info('Loading channel state', { case: 'loadChannelState' });
-
-    try {
-      const localPeers = this.peers.hosts().map((peer) => peer.shortData);
-      const clusterPeers = channelState.peers.filter((peer) => peer.role === ChannelMessagePeerRole.PEER_ROLE_HOST);
-
-      this.setMissingPeers(localPeers, clusterPeers);
-      this.restoreLocalPeersState(clusterPeers);
-      this.network.peersLoaded = true;
-    } catch (error: unknown) {
-      this.#logger.error('Failed to load channel state', {
-        case: 'loadState',
-        error: serializeError(error),
-      });
-    }
-  }
-
-  async restoreState(channelState: ChannelState): Promise<RestoreChannelStateResult> {
-    const { peers } = channelState;
-    const result: RestoreChannelStateResult = {
-      missingPeers: [],
-      removedPeers: [],
-      missingProducers: [],
-      removedProducers: [],
-      fixedProducersState: [],
-      fixedConsumersState: [],
-      restoredAppDataPeers: [],
-    };
-
-    try {
-      if (!this.network.isNetworkActive) {
-        this.#logger.info('Connection inactive, skipping restore local state', { case: 'restoreLocalState' });
-
-        return result;
-      }
-
-      this.#logger.info('Restoring local state', { case: 'restoreLocalState' });
-
-      const localPeers = this.peers.hosts().map((peer) => peer.shortData);
-      const clusterPeers = peers.filter((peer) => peer.role === ChannelMessagePeerRole.PEER_ROLE_HOST);
-
-      const { removedProducers, fixedProducersState } = await this.restoreRemoteProducersState(clusterPeers);
-      result.fixedProducersState.push(...fixedProducersState);
-      result.removedProducers.push(...removedProducers);
-
-      result.removedPeers.push(...this.removeUnnecessaryPeers(localPeers, clusterPeers));
-      result.missingPeers.push(...this.setMissingPeers(localPeers, clusterPeers));
-
-      const restoreLocalStateResult = this.restoreLocalPeersState(clusterPeers);
-      result.missingProducers.push(...restoreLocalStateResult.missingProducers);
-      result.removedProducers.push(...restoreLocalStateResult.removedProducers);
-      result.restoredAppDataPeers.push(...restoreLocalStateResult.restoredAppDataPeers);
-      result.fixedProducersState.push(...restoreLocalStateResult.fixedProducersState);
-      result.fixedConsumersState.push(...restoreLocalStateResult.fixedConsumersState);
-
-      return result;
-    } catch (error) {
-      this.#logger.info('Failed to restore local state', {
-        case: 'restoreLocalState',
-        error: serializeError(error),
-      });
-
-      return result;
-    }
-  }
-
-  private async restoreRemoteProducersState(
-    clusterPeers: ChannelMessagePeer[],
-  ): Promise<RestoredProducersStateResult> {
-    const results: RestoredProducersStateResult = {
-      removedProducers: [],
-      fixedProducersState: [],
-    };
-
-    const myLocalPeer = this.myPeer.get();
-    const myClusterPeer = clusterPeers.find((peer) => peer.id === this.myPeer.id);
-
-    if (!myLocalPeer || !myClusterPeer) {
-      return results;
-    }
-
-    // removing extra producers from server
-    const publishedLocalTracks = new Map<string, BaseTrack>();
-    this.media.getAllTracks().forEach((track) => {
-      if (!track.producerId) {
-        return;
-      }
-
-      publishedLocalTracks.set(track.producerId, track);
-    });
-
-    const localProducersIds = new Set(publishedLocalTracks.keys());
-    const unnecessaryLocalProducers = myClusterPeer.producers.filter((cp) => !localProducersIds.has(cp.id));
-
-    await Promise.all(unnecessaryLocalProducers.map(async (producer) => {
-      await this.network.closeRemoteProducer(producer.id);
-      myLocalPeer.producers.delete(producer.id);
-      results.removedProducers.push(producer.id);
-      this.#logger.info('Unnecessary local producer closed', {
-        case: 'restoreLocalState',
-        removedProducerId: producer.id,
-        removedProducerPeerId: producer.peerId,
-      });
-    }));
-
-    // repair producers state on server
-    const wrongStateProducers: { cp: Producer; localTrack: BaseTrack }[] = [];
-
-    for (const cp of myClusterPeer.producers) {
-      const localTrack = publishedLocalTracks.get(cp.id);
-
-      if (!localTrack) {
-        continue;
-      }
-
-      if (localTrack.isPaused !== cp.paused) {
-        wrongStateProducers.push({ cp, localTrack });
-      }
-    }
-
-    await Promise.all(wrongStateProducers.map(async ({ cp, localTrack }) => {
-      if (localTrack.isPaused) {
-        await this.network.pauseRemoteProducer(cp.id);
-      } else {
-        await this.network.resumeRemoteProducer(cp.id);
-      }
-
-      results.fixedProducersState.push(cp.id);
-      cp.paused = localTrack.isPaused;
-
-      this.#logger.info('Remote producer state repaired', {
-        case: 'restoreLocalState',
-        removedProducerId: cp.id,
-        removedProducerPeerId: cp.peerId,
-        paused: localTrack.isPaused,
-      });
-    }));
-
-    return results;
-  }
-
-  private removeUnnecessaryPeers(localPeers: PeerShortData[], clusterPeers: ChannelMessagePeer[]): string[] {
-    const results: string[] = [];
-    const unnecessaryPeers = localPeers
-      .filter((localPeer) => !clusterPeers.find((remotePeer) => remotePeer.id === localPeer.id));
-
-    unnecessaryPeers.forEach((unnecessaryPeer) => {
-      this.peers.remove(unnecessaryPeer.id).catch((error: unknown) => {
-        this.#logger.error('Failed to remove peer', {
-          error: serializeError(error),
-        });
-      });
-      results.push(unnecessaryPeer.id);
-      this.#logger.info('Unnecessary peer removed', {
-        case: 'restoreLocalState',
-        removedPeerId: unnecessaryPeer.id,
-      });
-    });
-
-    return results;
-  }
-
-  private setMissingPeers(localPeers: PeerShortData[], clusterPeers: ChannelMessagePeer[]): string[] {
-    const results: string[] = [];
-    clusterPeers.forEach((clusterPeer) => {
-      const peer = localPeers.find((localPeer) => localPeer.id === clusterPeer.id);
-
-      if (peer) {
-        return;
-      }
-
-      const newPeer = this.peers.add(convertChannelMessagePeerToPeerResponse(clusterPeer));
-      results.push(newPeer.id);
-      this.#logger.info('Missing peer added to storage', {
-        case: 'restoreLocalState',
-        peerId: clusterPeer.id,
-      });
-    });
-
-    return results;
-  }
-
-  private restoreLocalPeersState(clusterPeers: ChannelMessagePeer[]): RestoredLocalPeersStateResult {
-    const clusterPeersMap = new Map(clusterPeers.map((peer) => [peer.id, peer]));
-    const localPeers = this.peers.hosts();
-
-    const result: RestoredLocalPeersStateResult = {
-      removedProducers: [],
-      missingProducers: [],
-      restoredAppDataPeers: [],
-      fixedConsumersState: [],
-      fixedProducersState: [],
-    };
-
-    localPeers.forEach((localPeer) => {
-      const clusterPeer = clusterPeersMap.get(localPeer.id);
-
-      if (!clusterPeer) {
-        this.#logger.warn('Found new local peer, skip restoring state', {
-          case: 'restoreLocalState',
-          newPeerId: localPeer.id,
-        });
-
-        return;
-      }
-
-      result.removedProducers.push(...this.removeUnnecessaryProducers(localPeer, clusterPeer));
-
-      const isAppDataRestored = this.restoreAppData(localPeer, clusterPeer);
-
-      if (isAppDataRestored) {
-        result.restoredAppDataPeers.push(localPeer.id);
-      }
-
-      const {
-        fixedProducersState,
-        fixedConsumersState,
-        missingProducers,
-      } = this.restoreTracksState(localPeer, clusterPeer);
-
-      result.fixedProducersState.push(...fixedProducersState);
-      result.fixedConsumersState.push(...fixedConsumersState);
-      result.missingProducers.push(...missingProducers);
-    });
-
-    this.#logger.info('Peers state restored', { case: 'restoreLocalState' });
-
-    return result;
-  }
-
-  private removeUnnecessaryProducers(localPeer: Peer, clusterPeer: ChannelMessagePeer): string[] {
-    const result: string[] = [];
-    const unnecessaryProducers = localPeer.getProducers()
-      .filter((lp) => !clusterPeer.producers.find((cp) => cp.id === lp.id));
-    unnecessaryProducers.forEach((producer) => {
-      localPeer.observer.safeEmit(MEDIASOUP_EVENTS.producerClose, producer);
-      result.push(producer.id);
-      this.#logger.info('Unnecessary producer removed', {
-        case: 'restoreLocalState',
-        removedProducerId: producer.id,
-        removedProducerPeerId: producer.peerId,
-      });
-    });
-
-    return result;
-  }
-
-  private restoreTracksState(localPeer: Peer, clusterPeer: ChannelMessagePeer): RestoredTracksResult {
-    const result: RestoredTracksResult = {
-      missingProducers: [],
-      fixedProducersState: [],
-      fixedConsumersState: [],
-    };
-
-    clusterPeer.producers.forEach((clusterPeerProducer) => {
-      const localProducer = localPeer.producers.get(clusterPeerProducer.id);
-
-      if (!localProducer) {
-        localPeer.observer.safeEmit(
-          MEDIASOUP_EVENTS.newProducer,
-          convertChannelMessageProducerToProducerData(clusterPeerProducer),
-        );
-        result.missingProducers.push(clusterPeerProducer.id);
-        this.#logger.info('Missing producer added to storage', {
-          case: 'restoreLocalState',
-          producerId: clusterPeerProducer.id,
-          producerPeerId: clusterPeerProducer.peerId,
-        });
-
-        return;
-      }
-
-      const { paused } = clusterPeerProducer;
-
-      if (localProducer.paused !== paused) {
-        localProducer.setPaused(paused);
-        const producerStateEvent = localProducer.paused ? PEER_EVENTS.publisherPaused : PEER_EVENTS.publisherResumed;
-        localPeer.observer.safeEmit(producerStateEvent, {
-          producerId: localProducer.id,
-          kind: localProducer.kind,
-          label: localProducer.label,
-          paused: localProducer.paused,
-        });
-        result.fixedProducersState.push(clusterPeerProducer.id);
-
-        this.#logger.info('Producer state fixed', {
-          case: 'restoreLocalState',
-          producerId: clusterPeerProducer.id,
-          producerPeerId: clusterPeerProducer.peerId,
-        });
-      }
-
-      const consumer = localPeer.tracks.get(localProducer.label);
-
-      if (consumer?.consumerId && consumer.consumer?.paused !== clusterPeerProducer.paused) {
-        const { consumerId } = consumer;
-        const eventName = localProducer.paused ? MEDIASOUP_EVENTS.pauseConsumer : MEDIASOUP_EVENTS.resumeConsumer;
-        localPeer.observer.safeEmit(eventName, consumerId);
-        result.fixedConsumersState.push(consumerId);
-        this.#logger.info('Consumer state fixed', {
-          case: 'restoreLocalState',
-          consumerId,
-          consumerProducerId: clusterPeerProducer.id,
-          consumerProducerPeerId: clusterPeerProducer.peerId,
-        });
-      }
-    });
-
-    return result;
-  }
-
-  private restoreAppData(localPeer: Peer, clusterPeer: ChannelMessagePeer): boolean {
-    const isSameAppData = deepEqualObject(localPeer.appData, clusterPeer.appData);
-
-    if (isSameAppData) {
-      return false;
-    }
-
-    localPeer.observer.emit(CHANNEL_EVENTS.updatePeerAppData, clusterPeer.appData);
-    this.#logger.info('Application data restored', {
-      case: 'restoreLocalState',
-      peerId: localPeer.id,
-      appData: clusterPeer.appData,
-    });
-
-    return true;
-  }
-}
-
-export default ChannelStateSynchronizer;

package/src/engine/ChannelStateSynchronizer/types.ts

@@ -1,22 +0,0 @@
-export interface RestoredProducersStateResult {
-  removedProducers: string[];
-  fixedProducersState: string[];
-}
-
-export interface RestoredTracksResult {
-  missingProducers: string[];
-  fixedProducersState: string[];
-  fixedConsumersState: string[];
-}
-
-export interface RestoredLocalPeersStateResult extends RestoredTracksResult {
-  removedProducers: string[];
-  restoredAppDataPeers: string[];
-}
-
-export type RestoreChannelStateResult = {
-  removedPeers: string[];
-  missingPeers: string[];
-} & RestoredProducersStateResult
-& RestoredTracksResult
-& RestoredLocalPeersStateResult;