@webex/plugin-meetings 3.12.0-next.92 → 3.12.0-next.93

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

@@ -509,6 +509,67 @@ describe('createMediaConnection', () => {
     );
   });
 
+  it('passes iceTransportPolicy to MultistreamRoapMediaConnection when provided', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      iceTransportPolicy: 'relay',
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        iceTransportPolicy: 'relay',
+        disableAudioTwcc: true,
+        enableAV1SlidesSupport: false,
+      },
+      'meeting id'
+    );
+  });
+
+  it('does not pass iceTransportPolicy to MultistreamRoapMediaConnection when undefined', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      iceTransportPolicy: undefined,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        disableAudioTwcc: true,
+        enableAV1SlidesSupport: false,
+      },
+      'meeting id'
+    );
+  });
+
   it('MultistreamRoapMediaConnection disable audio twcc by default', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
       .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')

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

@@ -94,6 +94,7 @@ import {
   MeetingNotActiveError,
   UserInLobbyError,
   AddMediaFailed,
+  MediaConnectionTimedOutError,
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
@@ -264,6 +265,7 @@ describe('plugin-meetings', () => {
     webex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
     webex.meetings.reachability = {
       isAnyPublicClusterReachable: sinon.stub().resolves(true),
+      isAnyClusterReachableViaProtocol: sinon.stub().resolves(false),
       getReachabilityResults: sinon.stub().resolves(undefined),
       getReachabilityMetrics: sinon.stub().resolves({}),
       stopReachability: sinon.stub(),
@@ -513,6 +515,7 @@ describe('plugin-meetings', () => {
           localWebex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
           localWebex.meetings.reachability = {
             isAnyPublicClusterReachable: sinon.stub().resolves(true),
+            isAnyClusterReachableViaProtocol: sinon.stub().resolves(false),
             getReachabilityResults: sinon.stub().resolves(undefined),
             getReachabilityMetrics: sinon.stub().resolves({}),
             stopReachability: sinon.stub(),
@@ -1015,8 +1018,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            fakeTurnServerInfo,
             false,
+            fakeTurnServerInfo,
+            undefined,
             mediaOptions
           );
 
@@ -1048,8 +1052,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            undefined,
             false,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1083,8 +1088,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(
             meeting.addMediaInternal,
             sinon.match.any,
-            undefined,
             false,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1638,8 +1644,9 @@ describe('plugin-meetings', () => {
           assert.calledWith(
             meeting.addMediaInternal.firstCall,
             sinon.match.any,
-            fakeTurnServerInfo,
             false,
+            fakeTurnServerInfo,
+            undefined,
             mediaOptions
           );
 
@@ -1647,8 +1654,9 @@ describe('plugin-meetings', () => {
           assert.calledWith(
             meeting.addMediaInternal.secondCall,
             sinon.match.any,
-            undefined,
             true,
+            undefined,
+            undefined,
             mediaOptions
           );
 
@@ -1666,7 +1674,7 @@ describe('plugin-meetings', () => {
 
           meeting.addMediaInternal = sinon
             .stub()
-            .callsFake((icePhaseCallback, _turnServerInfo, _forceTurnDiscovery) => {
+            .callsFake((icePhaseCallback, _forceTurnDiscovery, _turnServerInfo) => {
               const defer = new Defer();
 
               icePhaseCallbacks.push(icePhaseCallback);
@@ -1880,6 +1888,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match.has('videoEnabled', false).and(sinon.match.has('allowMediaInLobby', true))
           );
         });
@@ -1900,6 +1909,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match.has('audioEnabled', false).and(sinon.match.has('allowMediaInLobby', true))
           );
         });
@@ -1921,6 +1931,7 @@ describe('plugin-meetings', () => {
             sinon.match.any,
             sinon.match.any,
             sinon.match.any,
+            sinon.match.any,
             sinon.match({
               sendVideo: true,
               receiveVideo: false,
@@ -1930,6 +1941,97 @@ describe('plugin-meetings', () => {
           );
         });
 
+        describe('shouldRetryMediaWithOnlyTurnTLS', () => {
+          it('should pass iceTransportPolicy=relay for multistream when previous error is DTLS failure over UDP and TLS is reachable', async () => {
+            meeting.isMultistream = true;
+            const dtlsError = new AddMediaFailed({iceConnected: true, connectionType: 'UDP'});
+
+            webex.meetings.reachability.isAnyClusterReachableViaProtocol = sinon.stub().resolves(true);
+
+            addMediaInternalStub.onFirstCall().rejects(dtlsError);
+            addMediaInternalStub.onSecondCall().resolves(test4);
+
+            await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+            assert.calledWith(
+              meeting.addMediaInternal.secondCall,
+              sinon.match.any,
+              sinon.match.any,
+              sinon.match.any,
+              'relay',
+              mediaOptions
+            );
+          });
+
+          [
+            {
+              title: 'TLS is not reachable',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'UDP'}),
+              tlsReachable: false,
+              isMultistream: true,
+            },
+            {
+              title: 'error is not AddMediaFailed',
+              prevError: new Error('generic error'),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'error is AddMediaFailed but not DTLS failure',
+              prevError: new AddMediaFailed({iceConnected: false, connectionType: 'UDP'}),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'error is DTLS failure but connectionType is not UDP',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'TURN-TLS'}),
+              tlsReachable: true,
+              isMultistream: true,
+            },
+            {
+              title: 'isMultistream is false',
+              prevError: new AddMediaFailed({iceConnected: true, connectionType: 'UDP'}),
+              tlsReachable: true,
+              isMultistream: false,
+            },
+          ].forEach(({title, prevError, tlsReachable, isMultistream}) => {
+            it(`should pass iceTransportPolicy=undefined when ${title}`, async () => {
+              meeting.join = sinon.stub().callsFake(() => {
+                meeting.isMultistream = isMultistream;
+                return Promise.resolve(fakeJoinResult);
+              });
+              webex.meetings.reachability.isAnyClusterReachableViaProtocol = sinon.stub().resolves(tlsReachable);
+
+              addMediaInternalStub.onFirstCall().rejects(prevError);
+              addMediaInternalStub.onSecondCall().resolves(test4);
+
+              await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+              assert.calledWith(
+                meeting.addMediaInternal.secondCall,
+                sinon.match.any,
+                sinon.match.any,
+                sinon.match.any,
+                undefined,
+                mediaOptions
+              );
+            });
+          });
+
+          it('should pass iceTransportPolicy=undefined on first attempt (no prevError)', async () => {
+            await meeting.joinWithMedia({joinOptions, mediaOptions});
+
+            assert.calledWith(
+              meeting.addMediaInternal.firstCall,
+              sinon.match.any,
+              sinon.match.any,
+              sinon.match.any,
+              undefined,
+              mediaOptions
+            );
+          });
+        });
+
         it('should throw immediately if RTCPeerConnection is not available', async () => {
           supportsRTCPeerConnectionStub.returns(CapabilityState.NOT_CAPABLE);
 
@@ -3270,9 +3372,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               selectedCandidatePairChanges: 2,
@@ -3398,9 +3502,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               selectedCandidatePairChanges: 2,
@@ -4168,9 +4274,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: true,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               iceCandidatesCount: 0,
@@ -4195,6 +4303,161 @@ describe('plugin-meetings', () => {
           assert.isOk(errorThrown);
         });
 
+        [
+          {iceConnected: true, title: 'iceConnected=true'},
+          {iceConnected: false, title: 'iceConnected=false'},
+        ].forEach(({iceConnected, title}) => {
+          it(`should propagate ${title} from waitForMediaConnectionConnected rejection to AddMediaFailed`, async () => {
+            webex.meetings.reachability = {
+              isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
+              getReachabilityMetrics: sinon.stub().resolves({}),
+              stopReachability: sinon.stub(),
+              isSubnetReachable: sinon.stub().returns(true),
+            };
+            webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
+              sinon.stub().returns({fatal: true});
+            sinon.stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure').returns(2004);
+
+            meeting.meetingState = 'ACTIVE';
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().rejects({iceConnected});
+
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:fake:443'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            const forceRtcMetricsSend = sinon.stub().resolves();
+            Media.createMediaConnection = sinon.stub().returns({
+              close: sinon.stub(),
+              forceRtcMetricsSend,
+              getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+              initiateOffer: sinon.stub().resolves({}),
+              on: sinon.stub(),
+            });
+
+            let thrownError;
+            await meeting.addMedia({mediaSettings: {}}).catch((err) => {
+              thrownError = err;
+            });
+
+            assert.instanceOf(thrownError, AddMediaFailed);
+            assert.equal(thrownError.iceConnected, iceConnected);
+          });
+        });
+
+        describe('iceTransportPolicy=relay handling', () => {
+          let createMediaConnectionStub;
+
+          beforeEach(() => {
+            webex.meetings.reachability = {
+              isWebexMediaBackendUnreachable: sinon.stub().resolves(false),
+              isAnyClusterReachableViaProtocol: sinon.stub().resolves(true),
+              getReachabilityMetrics: sinon.stub().resolves({}),
+              stopReachability: sinon.stub(),
+              isSubnetReachable: sinon.stub().returns(true),
+            };
+            webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
+              sinon.stub().returns({fatal: true});
+            sinon.stub(CallDiagnosticUtils, 'generateClientErrorCodeForIceFailure').returns(2004);
+
+            meeting.meetingState = 'ACTIVE';
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+
+            createMediaConnectionStub = sinon.stub().returns({
+              close: sinon.stub(),
+              forceRtcMetricsSend: sinon.stub().resolves(),
+              getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+              initiateOffer: sinon.stub().resolves({}),
+              on: sinon.stub(),
+            });
+            Media.createMediaConnection = createMediaConnectionStub;
+          });
+
+          [
+            {
+              title: 'should drop iceTransportPolicy=relay when TURN discovery returns no turn server info',
+              turnServerInfo: undefined,
+              turnDiscoverySkippedReason: 'reachability',
+            },
+            {
+              title: 'should drop iceTransportPolicy=relay when TURN discovery returns turnServerInfo with empty urls',
+              turnServerInfo: {urls: [], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            },
+          ].forEach(({title, turnServerInfo, turnDiscoverySkippedReason}) => {
+            it(title, async () => {
+              meeting.roap.doTurnDiscovery = sinon.stub().returns({
+                turnServerInfo,
+                turnDiscoverySkippedReason,
+              });
+
+              await meeting.addMediaInternal(
+                () => 'JOIN_MEETING_FINAL',
+                false,
+                undefined,
+                'relay',
+                {mediaSettings: {}}
+              );
+
+              assert.calledOnce(createMediaConnectionStub);
+              const config = createMediaConnectionStub.firstCall.args[3];
+              assert.isUndefined(config.iceTransportPolicy);
+
+              const successCall = Metrics.sendBehavioralMetric.getCalls().find(
+                (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS
+              );
+              assert.isDefined(successCall);
+              assert.equal(successCall.args[1].iceTransportPolicy, 'all');
+            });
+          });
+
+          it('should send ADD_MEDIA_SUCCESS metric with iceTransportPolicy=relay when relay is used', async () => {
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:turn-server:443?transport=tcp'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            await meeting.addMediaInternal(
+              () => 'JOIN_MEETING_FINAL',
+              false,
+              undefined,
+              'relay',
+              {mediaSettings: {}}
+            );
+
+            const successCall = Metrics.sendBehavioralMetric.getCalls().find(
+              (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS
+            );
+            assert.isDefined(successCall);
+            assert.equal(successCall.args[1].iceTransportPolicy, 'relay');
+          });
+
+          it('should send ADD_MEDIA_FAILURE metric with iceTransportPolicy=relay when relay attempt fails', async () => {
+            meeting.roap.doTurnDiscovery = sinon.stub().returns({
+              turnServerInfo: {urls: ['turns:turn-server:443?transport=tcp'], username: 'u', password: 'p'},
+              turnDiscoverySkippedReason: undefined,
+            });
+
+            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().rejects(
+              new MediaConnectionTimedOutError('timed out', true)
+            );
+
+            await assert.isRejected(meeting.addMediaInternal(
+              () => 'JOIN_MEETING_FINAL',
+              false,
+              undefined,
+              'relay',
+              {mediaSettings: {}}
+            ));
+
+            const failureCall = Metrics.sendBehavioralMetric.getCalls().find(
+              (call) => call.args[0] === BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE
+            );
+            assert.isDefined(failureCall);
+            assert.equal(failureCall.args[1].iceTransportPolicy, 'relay');
+          });
+        });
+
         it('should resolve if waitForMediaConnectionConnected() rejects the first time but resolves the second time', async () => {
           const FAKE_ERROR = {fatal: true};
           webex.meetings.reachability = {
@@ -4384,6 +4647,7 @@ describe('plugin-meetings', () => {
               isMultistream: false,
               retriedWithTurnServer: true,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               iceCandidatesCount: 0,
               subnet_reachable: null,
               selected_cluster: null,
@@ -4547,6 +4811,7 @@ describe('plugin-meetings', () => {
               isMultistream: false,
               retriedWithTurnServer: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
               iceCandidatesCount: 3,
@@ -4612,9 +4877,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               subnet_reachable: null,
@@ -4675,9 +4942,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               '701_error': 2,
@@ -4739,6 +5008,7 @@ describe('plugin-meetings', () => {
             isMultistream: false,
             retriedWithTurnServer: false,
             isJoinWithMediaRetry: false,
+            iceTransportPolicy: 'all',
             iceCandidatesCount: 0,
             reachability_public_udp_success: 5,
             subnet_reachable: false,
@@ -4804,9 +5074,11 @@ describe('plugin-meetings', () => {
               retriedWithTurnServer: false,
               isMultistream: false,
               isJoinWithMediaRetry: false,
+              iceTransportPolicy: 'all',
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              connectionType: 'udp',
               selectedCandidatePairChanges: 2,
               numTransports: 1,
               reachability_public_udp_success: 5,
@@ -7139,13 +7411,14 @@ describe('plugin-meetings', () => {
                 sinon.stub(meeting.locusMediaRequest, 'downgradeFromMultistreamToTranscoded');
               });
 
-              const runCheck = async (turnServerInfo, forceTurnDiscovery) => {
+              const runCheck = async (turnServerInfo, forceTurnDiscovery, iceTransportPolicy) => {
                 // we're calling addMediaInternal() with mic stream,
                 // so that we also verify that audioMute, videoMute info is correctly sent to backend
                 const addMediaPromise = meeting.addMediaInternal(
                   () => '',
-                  turnServerInfo,
                   forceTurnDiscovery,
+                  turnServerInfo,
+                  iceTransportPolicy,
                   {
                     localStreams: {microphone: fakeMicrophoneStream},
                   }
@@ -7199,6 +7472,10 @@ describe('plugin-meetings', () => {
                 // at this point the meeting should have been downgraded to transcoded
                 assert.equal(meeting.isMultistream, false);
 
+                // iceTransportPolicy must be reset to undefined on downgrade to transcoded,
+                // otherwise the transcoded retry could gather direct candidates while metrics report relay
+                assert.isUndefined(meeting.addMediaData.iceTransportPolicy);
+
                 // old stats analyzer stopped and new one created
                 assert.calledOnce(initialStatsAnalyzer.stopAnalyzer);
                 assert.calledOnceWithExactly(
@@ -7289,6 +7566,11 @@ describe('plugin-meetings', () => {
                   true
                 );
               });
+
+              it('resets iceTransportPolicy to undefined when falling back from multistream (relay) to transcoded', async () => {
+                // simulate a relay-only retry falling back to transcoded and verify iceTransportPolicy is reset
+                await runCheck(undefined, false, 'relay');
+              });
             });
           }
         })

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

@@ -160,6 +160,75 @@ describe('isAnyPublicClusterReachable', () => {
   });
 });
 
+describe('isAnyClusterReachableViaProtocol', () => {
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const checkReachableViaProtocol = async (
+    mockStorage: any,
+    protocol: 'udp' | 'tcp' | 'xtls',
+    expectedValue: boolean
+  ) => {
+    if (mockStorage) {
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
+    }
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.isAnyClusterReachableViaProtocol(protocol);
+
+    assert.equal(result, expectedValue);
+  };
+
+  ['udp', 'tcp', 'xtls'].forEach((protocol: 'udp' | 'tcp' | 'xtls') => {
+    it(`returns true when at least one cluster is reachable via ${protocol}`, async () => {
+      await checkReachableViaProtocol(
+        {
+          clusterA: {[protocol]: {result: 'reachable'}},
+          clusterB: {[protocol]: {result: 'unreachable'}},
+        },
+        protocol,
+        true
+      );
+    });
+
+    it(`returns false when no cluster is reachable via ${protocol}`, async () => {
+      await checkReachableViaProtocol(
+        {
+          clusterA: {[protocol]: {result: 'unreachable'}},
+          clusterB: {[protocol]: {result: 'unreachable'}},
+        },
+        protocol,
+        false
+      );
+    });
+  });
+
+  it('returns false when storage read throws an error', async () => {
+    // don't put anything in storage so .get() rejects
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.isAnyClusterReachableViaProtocol('xtls');
+
+    assert.equal(result, false);
+  });
+
+  it('returns false when stored data is empty', async () => {
+    await checkReachableViaProtocol({}, 'xtls', false);
+  });
+});
+
 describe('isWebexMediaBackendUnreachable', () => {
   let webex;