@webex/plugin-meetings 3.8.0-next.49 → 3.8.0-next.50

package/src/reachability/clusterReachability.ts

@@ -49,6 +49,7 @@ export class ClusterReachability extends EventsScope {
   private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
+  public readonly reachedSubnets: Set<string> = new Set();
 
   /**
    * Constructor for ClusterReachability
@@ -234,27 +235,13 @@ export class ClusterReachability extends EventsScope {
    */
   private registerIceGatheringStateChangeListener() {
     this.pc.onicegatheringstatechange = () => {
-      const {COMPLETE} = ICE_GATHERING_STATE;
-
-      if (this.pc.iceConnectionState === COMPLETE) {
+      if (this.pc.iceGatheringState === ICE_GATHERING_STATE.COMPLETE) {
         this.closePeerConnection();
         this.finishReachabilityCheck();
       }
     };
   }
 
-  /**
-   * Checks if we have the results for all the protocols (UDP and TCP)
-   *
-   * @returns {boolean} true if we have all results, false otherwise
-   */
-  private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp', 'xtls'].every(
-      (protocol) =>
-        this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
-    );
-  }
-
   /**
    * Saves the latency in the result for the given protocol and marks it as reachable,
    * emits the "resultReady" event if this is the first result for that protocol,
@@ -264,9 +251,15 @@ export class ClusterReachability extends EventsScope {
    * @param {string} protocol
    * @param {number} latency
    * @param {string|null} [publicIp]
+   * @param {string|null} [serverIp]
    * @returns {void}
    */
-  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
+  private saveResult(
+    protocol: 'udp' | 'tcp' | 'xtls',
+    latency: number,
+    publicIp?: string | null,
+    serverIp?: string | null
+  ) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -294,6 +287,10 @@ export class ClusterReachability extends EventsScope {
     } else {
       this.addPublicIP(protocol, publicIp);
     }
+
+    if (serverIp) {
+      this.reachedSubnets.add(serverIp);
+    }
   }
 
   /**
@@ -351,21 +348,25 @@ export class ClusterReachability extends EventsScope {
 
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+          let serverIp = null;
+          if ('url' in e.candidate) {
+            const stunServerUrlRegex = /stun:([\d.]+):\d+/;
+
+            const match = (e.candidate as any).url.match(stunServerUrlRegex);
+            if (match) {
+              // eslint-disable-next-line prefer-destructuring
+              serverIp = match[1];
+            }
+          }
+
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
 
           this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          this.saveResult(protocol, latencyInMilliseconds);
-          // we don't add public IP for TCP, because in the case of relay candidates
-          // e.candidate.address is the TURN server address, not the client's public IP
-        }
-
-        if (this.haveWeGotAllResults()) {
-          this.closePeerConnection();
-          this.finishReachabilityCheck();
+          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
         }
       }
     };

package/src/reachability/index.ts

@@ -138,6 +138,60 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Checks if the given subnet is reachable
+   * @param {string} mediaServerIp - media server ip
+   * @returns {boolean | null} true if reachable, false if not reachable, null if mediaServerIp is not provided
+   * @public
+   * @memberof Reachability
+   */
+  public isSubnetReachable(mediaServerIp?: string): boolean | null {
+    if (!mediaServerIp) {
+      LoggerProxy.logger.error(`Reachability:index#isSubnetReachable --> mediaServerIp is null`);
+
+      return null;
+    }
+
+    const subnetFirstOctet = mediaServerIp.split('.')[0];
+
+    LoggerProxy.logger.info(
+      `Reachability:index#isSubnetReachable --> Looking for subnet: ${subnetFirstOctet}.X.X.X`
+    );
+
+    const matchingReachedClusters = Object.values(this.clusterReachability).reduce(
+      (acc, cluster) => {
+        const reachedSubnetsArray = Array.from(cluster.reachedSubnets);
+
+        let logMessage = `Reachability:index#isSubnetReachable --> Cluster ${cluster.name} reached [`;
+        for (let i = 0; i < reachedSubnetsArray.length; i += 1) {
+          const subnet = reachedSubnetsArray[i];
+          const reachedSubnetFirstOctet = subnet.split('.')[0];
+
+          if (subnetFirstOctet === reachedSubnetFirstOctet) {
+            acc.add(cluster.name);
+          }
+
+          logMessage += `${subnet}`;
+          if (i < reachedSubnetsArray.length - 1) {
+            logMessage += ',';
+          }
+        }
+        logMessage += `]`;
+
+        LoggerProxy.logger.info(logMessage);
+
+        return acc;
+      },
+      new Set<string>()
+    );
+
+    LoggerProxy.logger.info(
+      `Reachability:index#isSubnetReachable --> Found ${matchingReachedClusters.size} clusters that use the subnet ${subnetFirstOctet}.X.X.X`
+    );
+
+    return matchingReachedClusters.size > 0;
+  }
+
   /**
    * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
    * @param {string} trigger - explains the reason for starting reachability

package/test/unit/spec/meeting/index.js

@@ -253,6 +253,7 @@ describe('plugin-meetings', () => {
       getReachabilityResults: sinon.stub().resolves(undefined),
       getReachabilityMetrics: sinon.stub().resolves({}),
       stopReachability: sinon.stub(),
+      isSubnetReachable: sinon.stub().returns(true),
     };
     webex.internal.llm.on = sinon.stub();
     webex.internal.newMetrics.callDiagnosticLatencies = new CallDiagnosticLatencies(
@@ -2128,6 +2129,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric2: 'some value2',
             }),
             stopReachability: sinon.stub(),
+            isSubnetReachable: sinon.stub().returns(false),
           };
 
           const forceRtcMetricsSend = sinon.stub().resolves();
@@ -2183,6 +2185,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               selectedCandidatePairChanges: 2,
+              isSubnetReachable: false,
               numTransports: 1,
               iceCandidatesCount: 0,
             }
@@ -2229,6 +2232,7 @@ describe('plugin-meetings', () => {
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              isSubnetReachable: true,
             })
           );
 
@@ -2243,6 +2247,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
             }),
+            isSubnetReachable: sinon.stub().returns(true),
           };
 
           meeting.waitForRemoteSDPAnswer = sinon.stub().rejects();
@@ -2293,6 +2298,7 @@ describe('plugin-meetings', () => {
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               iceCandidatesCount: 0,
+              isSubnetReachable: true,
             }
           );
         });
@@ -2350,6 +2356,7 @@ describe('plugin-meetings', () => {
               signalingState: 'have-local-offer',
               connectionState: 'connecting',
               iceConnectionState: 'checking',
+              isSubnetReachable: true,
             })
           );
 
@@ -2407,6 +2414,7 @@ describe('plugin-meetings', () => {
               signalingState: 'have-local-offer',
               connectionState: 'connecting',
               iceConnectionState: 'checking',
+              isSubnetReachable: true,
             })
           );
 
@@ -2744,6 +2752,7 @@ describe('plugin-meetings', () => {
             isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
             getReachabilityMetrics: sinon.stub().resolves(),
             stopReachability: sinon.stub(),
+            isSubnetReachable: sinon.stub().returns(true),
           };
           const MOCK_CLIENT_ERROR_CODE = 2004;
           const generateClientErrorCodeForIceFailureStub = sinon
@@ -2923,6 +2932,7 @@ describe('plugin-meetings', () => {
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               iceCandidatesCount: 0,
+              isSubnetReachable: true,
             },
           ]);
 
@@ -2953,6 +2963,7 @@ describe('plugin-meetings', () => {
               .resolves(false),
             getReachabilityMetrics: sinon.stub().resolves({}),
             stopReachability: sinon.stub(),
+            isSubnetReachable: sinon.stub().returns(true),
           };
           const getErrorPayloadForClientErrorCodeStub =
             (webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
@@ -3120,6 +3131,7 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: true,
               isJoinWithMediaRetry: false,
               iceCandidatesCount: 0,
+              isSubnetReachable: true,
             },
           ]);
           meeting.roap.doTurnDiscovery;
@@ -3248,6 +3260,7 @@ describe('plugin-meetings', () => {
               someReachabilityMetric2: 'some value2',
             }),
             stopReachability: sinon.stub(),
+            isSubnetReachable: sinon.stub().returns(true),
           };
           meeting.iceCandidatesCount = 3;
           meeting.iceCandidateErrors.set('701_error', 3);
@@ -3275,6 +3288,7 @@ describe('plugin-meetings', () => {
               iceCandidatesCount: 3,
               '701_error': 3,
               '701_turn_host_lookup_received_error': 1,
+              isSubnetReachable: true,
             }
           );
 
@@ -3337,6 +3351,7 @@ describe('plugin-meetings', () => {
               iceConnectionState: 'unknown',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
+              isSubnetReachable: true,
               iceCandidatesCount: 0,
             }
           );
@@ -3398,6 +3413,7 @@ describe('plugin-meetings', () => {
               numTransports: 1,
               '701_error': 2,
               '701_turn_host_lookup_received_error': 1,
+              isSubnetReachable: true,
               iceCandidatesCount: 0,
             }
           );

package/test/unit/spec/reachability/clusterReachability.ts

@@ -174,59 +174,6 @@ describe('ClusterReachability', () => {
       assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
-    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
-
-      // check the right events were emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 1);
-      assert.deepEqual(emittedEvents[Events.resultReady][0], {
-        protocol: 'udp',
-        result: 'reachable',
-        latencyInMilliseconds: 100,
-        clientMediaIPs: ['somePublicIp'],
-      });
-
-      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 2);
-      assert.deepEqual(emittedEvents[Events.resultReady][1], {
-        protocol: 'tcp',
-        result: 'reachable',
-        latencyInMilliseconds: 200,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
-      });
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 3);
-      assert.deepEqual(emittedEvents[Events.resultReady][2], {
-        protocol: 'xtls',
-        result: 'reachable',
-        latencyInMilliseconds: 300,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'reachable', latencyInMilliseconds: 300},
-      });
-    });
-
     it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
@@ -275,7 +222,7 @@ describe('ClusterReachability', () => {
 
       await testUtils.flushPromises();
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -293,7 +240,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(30);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -436,6 +383,9 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -474,6 +424,10 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await clock.tickAsync(10);
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -486,5 +440,37 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 20},
       });
     });
+
+    it('should gather correctly reached subnets', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:4.3.2.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), [
+        '1.2.3.4',
+        '4.3.2.1',
+        'someTurnRelayIp'
+      ]);
+    });
+
+    it('should store only unique subnet address', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:9000'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '1.2.3.4'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['1.2.3.4']);
+    });
   });
 });

package/test/unit/spec/reachability/index.ts

@@ -2686,3 +2686,38 @@ describe('sendMetric', () => {
     });
   });
 });
+
+describe('isSubnetReachable', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+
+    reachability.setFakeClusterReachability({
+      cluster1: {
+        reachedSubnets: new Set(['1.2.3.4', '2.3.4.5']),
+      },
+      cluster2: {
+        reachedSubnets: new Set(['3.4.5.6', '4.5.6.7']),
+      },
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('returns true if the subnet is reachable', () => {
+    assert(reachability.isSubnetReachable('1.2.3.4'));
+  });
+
+  it(`returns false if the subnet is unreachable`, () => {
+    assert(!reachability.isSubnetReachable('11.2.3.4'));
+  });
+
+  it('returns null if the subnet is not provided', () => {
+    assert.isNull(reachability.isSubnetReachable(undefined));
+  });
+});