@webex/plugin-meetings 3.1.0-next.9 → 3.2.0

package/src/reachability/index.ts

@@ -296,6 +296,63 @@ export default class Reachability {
     return reachable;
   }
 
+  /**
+   * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
+   * of the media clusters where reachable with any of the protocols. This is done
+   * irrespective of the config, so for example:
+   * if config.meetings.experimental.enableTlsReachability === false,
+   * it will return false, because TLS reachability won't be tested,
+   * so we can't say for sure that media backend is unreachable over TLS.
+   *
+   * @returns {boolean}
+   */
+  async isWebexMediaBackendUnreachable() {
+    let unreachable = false;
+
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
+
+    if (reachabilityData) {
+      try {
+        const reachabilityResults: ReachabilityResults = JSON.parse(reachabilityData);
+
+        const protocols = {
+          udp: {tested: false, reachable: undefined},
+          tcp: {tested: false, reachable: undefined},
+          xtls: {tested: false, reachable: undefined},
+        };
+
+        Object.values(reachabilityResults).forEach((result) => {
+          Object.keys(protocols).forEach((protocol) => {
+            if (
+              result[protocol]?.result === 'reachable' ||
+              result[protocol]?.result === 'unreachable'
+            ) {
+              protocols[protocol].tested = true;
+
+              // we need at least 1 'reachable' result to mark the whole protocol as reachable
+              if (result[protocol].result === 'reachable') {
+                protocols[protocol].reachable = true;
+              }
+            }
+          });
+        });
+
+        unreachable = Object.values(protocols).every(
+          (protocol) => protocol.tested && !protocol.reachable
+        );
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+        );
+      }
+    }
+
+    return unreachable;
+  }
+
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
@@ -314,6 +371,9 @@ export default class Reachability {
       if (result.tcp.result === 'unreachable') {
         unreachableList.push({name: key, protocol: 'tcp'});
       }
+      if (result.xtls.result === 'unreachable') {
+        unreachableList.push({name: key, protocol: 'xtls'});
+      }
     });
 
     return unreachableList;

package/src/roap/request.ts

@@ -61,7 +61,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
     ipVersion?: IP_VERSION;
     locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
+    const {roapMessage, locusSelfUrl, mediaId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
       LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
@@ -82,14 +82,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
       `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    // @ts-ignore
-    this.webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.media.request',
-      options: {
-        meetingId,
-      },
-    });
-
     return locusMediaRequest
       .send({
         type: 'RoapMessage',
@@ -101,13 +93,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         ipVersion,
       })
       .then((res) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-          },
-        });
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
@@ -131,14 +116,6 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.response',
-          options: {
-            meetingId,
-            rawError: err,
-          },
-        });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:`, err);
         LoggerProxy.logger.error(
           `Roap:request#sendRoapRequest --> roapMessage that caused error:${JSON.stringify(

package/src/statsAnalyzer/index.ts

@@ -998,12 +998,11 @@ export class StatsAnalyzer extends EventsScope {
         result.qualityLimitationReason;
       this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges =
         result.qualityLimitationResolutionChanges;
-      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent =
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsSent =
         result.retransmittedPacketsSent;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesSent = result.retransmittedBytesSent;
       this.statsResults[mediaType][sendrecvType].totalBytesSent = result.bytesSent;
       this.statsResults[mediaType][sendrecvType].headerBytesSent = result.headerBytesSent;
-      this.statsResults[mediaType][sendrecvType].retransmittedBytesSent =
-        result.retransmittedBytesSent;
       this.statsResults[mediaType][sendrecvType].requestedBitrate = result.requestedBitrate;
       this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
     }
@@ -1136,6 +1135,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].fecPacketsReceived = result.fecPacketsReceived;
       this.statsResults[mediaType][sendrecvType].totalBytesReceived = result.bytesReceived;
       this.statsResults[mediaType][sendrecvType].headerBytesReceived = result.headerBytesReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsReceived =
+        result.retransmittedPacketsReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesReceived =
+        result.retransmittedBytesReceived;
 
       this.statsResults[mediaType][sendrecvType].meanRtpJitter.push(result.jitter);
 

package/src/statsAnalyzer/mqaUtil.ts

@@ -237,10 +237,16 @@ export const getVideoReceiverMqa = ({
   const lastPacketsLost = getLastTotalValue('totalPacketsLost');
   const lastBytesReceived = getLastTotalValue('totalBytesReceived');
 
+  const lastRtxPacketsReceived = getLastTotalValue('totalRtxPacketsReceived');
+  const lastRtxBytesReceived = getLastTotalValue('totalRtxBytesReceived');
+
   const packetsLost = getTotalValue('totalPacketsLost');
   const totalPacketsReceived = getTotalValue('totalPacketsReceived');
   const totalBytesReceived = getTotalValue('totalBytesReceived');
 
+  const totalRtxPacketsReceived = getTotalValue('totalRtxPacketsReceived');
+  const totalRtxBytesReceived = getTotalValue('totalRtxBytesReceived');
+
   const meanRemoteJitter = Object.keys(statsResults)
     .filter((mt) => mt.includes(baseMediaType))
     .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
@@ -266,10 +272,15 @@ export const getVideoReceiverMqa = ({
 
   // Calculate the outgoing bitrate
   const totalBytesReceivedInaMin = totalBytesReceived - lastBytesReceived;
+  const totalRtxBytesReceivedInaMin = totalRtxBytesReceived - lastRtxBytesReceived;
 
   videoReceiver.common.rtpBitrate = totalBytesReceivedInaMin
     ? (totalBytesReceivedInaMin * 8) / 60
     : 0;
+  videoReceiver.common.rtxPackets = totalRtxPacketsReceived - lastRtxPacketsReceived;
+  videoReceiver.common.rtxBitrate = totalRtxBytesReceivedInaMin
+    ? (totalRtxBytesReceivedInaMin * 8) / 60
+    : 0;
 };
 
 export const getVideoReceiverStreamMqa = ({
@@ -349,11 +360,15 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
   const lastPacketsSent = getLastTotalValue('totalPacketsSent');
   const lastBytesSent = getLastTotalValue('totalBytesSent');
   const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
+  const lastRtxPacketsSent = getLastTotalValue('totalRtxPacketsSent');
+  const lastRtxBytesSent = getLastTotalValue('totalRtxBytesSent');
 
   const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
   const totalPacketsSent = getTotalValue('totalPacketsSent');
   const totalBytesSent = getTotalValue('totalBytesSent');
   const availableOutgoingBitrate = getTotalValue('availableOutgoingBitrate');
+  const totalRtxPacketsSent = getTotalValue('totalRtxPacketsSent');
+  const totalRtxBytesSent = getTotalValue('totalRtxBytesSent');
 
   videoSender.common.common.direction =
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
@@ -389,8 +404,11 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
 
   // Calculate the outgoing bitrate
   const totalBytesSentInaMin = totalBytesSent - lastBytesSent;
+  const totalRtxBytesSentInaMin = totalRtxBytesSent - lastRtxBytesSent;
 
   videoSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
+  videoSender.common.rtxPackets = totalRtxPacketsSent - lastRtxPacketsSent;
+  videoSender.common.rtxBitrate = totalRtxBytesSentInaMin ? (totalRtxBytesSentInaMin * 8) / 60 : 0;
 };
 
 export const getVideoSenderStreamMqa = ({

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

@@ -906,12 +906,12 @@ describe('plugin-meetings', () => {
 
       describe('#isTranscriptionSupported', () => {
         it('should return false if the feature is not supported for the meeting', () => {
-          meeting.locusInfo.controls = {transcribe: {transcribing: false}};
+          meeting.locusInfo.controls = {transcribe: {caption: false}};
 
           assert.equal(meeting.isTranscriptionSupported(), false);
         });
         it('should return true if webex assitant is enabled', () => {
-          meeting.locusInfo.controls = {transcribe: {transcribing: true}};
+          meeting.locusInfo.controls = {transcribe: {caption: true}};
 
           assert.equal(meeting.isTranscriptionSupported(), true);
         });
@@ -1302,6 +1302,31 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('#handleLLMOnline', () => {
+        beforeEach(() => {
+          webex.internal.llm.off = sinon.stub();
+        });
+
+        it('turns off llm online, emits transcription connected events', () => {
+          meeting.handleLLMOnline();
+          assert.calledOnceWithExactly(
+            webex.internal.llm.off,
+            'online',
+            meeting.handleLLMOnline
+          );
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'handleLLMOnline',
+            },
+            EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
+          );
+        });
+      });
+
       describe('#join', () => {
         let sandbox = null;
         let setCorrelationIdSpy;
@@ -1351,15 +1376,10 @@ describe('plugin-meetings', () => {
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(meeting.setLocus);
             assert.equal(result, joinMeetingResult);
-
             assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {
-                file: 'meeting/index',
-                function: 'join',
-              },
-              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
+              webex.internal.llm.on,
+              'online',
+              meeting.handleLLMOnline
             );
           });
 
@@ -6166,11 +6186,22 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
-          sandbox.stub(meeting, 'cleanupLocalStreams');
+          meeting.statsAnalyzer = {
+            stopAnalyzer: sinon.stub().returns(Promise.resolve())
+          };
+
+          meeting.reconnectionManager = {
+            cleanUp: sinon.stub()
+          };
 
-          sandbox.stub(meeting.mediaProperties, 'setMediaDirection');
+          meeting.cleanupLocalStreams=sinon.stub();
+          meeting.closeRemoteStreams = sinon.stub().returns(Promise.resolve());
+          meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+          meeting.unsetRemoteStreams = sinon.stub();
+          meeting.unsetPeerConnections = sinon.stub();
+          meeting.addMedia = sinon.stub().returns(Promise.resolve());
+          meeting.mediaProperties.setMediaDirection = sinon.stub();
 
-          sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
           sandbox
             .stub(MeetingUtil, 'joinMeeting')
             .returns(
@@ -6232,9 +6263,11 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should reconnectMedia after DX joins after moveTo', async () => {
+        it('should cleanup on moveTo & addMedia after', async () => {
           await meeting.moveTo('resourceId');
 
+          assert.equal(meeting.isMoveToInProgress, true);
+
           await meeting.locusInfo.emitScoped(
             {
               file: 'locus-info',
@@ -6242,26 +6275,26 @@ describe('plugin-meetings', () => {
             },
             'SELF_OBSERVING'
           );
+          
 
-          // beacuse we are calling callback so we need to wait
-
-          assert.called(meeting.cleanupLocalStreams);
-
-          // give queued Promise callbacks a chance to run
-          await Promise.resolve();
-
-          assert.called(meeting.mediaProperties.setMediaDirection);
-
-          assert.calledWith(meeting.reconnectionManager.reconnectMedia, {
-            mediaDirection: {
-              sendVideo: false,
-              receiveVideo: false,
-              sendAudio: false,
-              receiveAudio: false,
-              sendShare: false,
-              receiveShare: true,
-            },
-          });
+          // Verify that the event handler behaves as expected
+          expect(meeting.statsAnalyzer.stopAnalyzer.calledOnce).to.be.true;
+          expect(meeting.closeRemoteStreams.calledOnce).to.be.true;
+          await testUtils.flushPromises();
+          expect(meeting.closePeerConnections.calledOnce).to.be.true;
+          await testUtils.flushPromises();
+          expect(meeting.cleanupLocalStreams.calledOnce).to.be.true;
+          expect(meeting.unsetRemoteStreams.calledOnce).to.be.true;
+          expect(meeting.unsetPeerConnections.calledOnce).to.be.true;
+          expect(meeting.reconnectionManager.cleanUp.calledOnce).to.be.true;
+          expect(meeting.mediaProperties.setMediaDirection.calledOnce).to.be.true;
+          expect(meeting.addMedia.calledOnceWithExactly({
+            audioEnabled: false,
+            videoEnabled: false,
+            shareVideoEnabled: true
+          })).to.be.true;
+          await testUtils.flushPromises();
+          assert.equal(meeting.isMoveToInProgress, false);
         });
 
         it('should throw an error if moveTo call fails', async () => {
@@ -6269,6 +6302,7 @@ describe('plugin-meetings', () => {
           try {
             await meeting.moveTo('resourceId');
           } catch {
+            assert.equal(meeting.isMoveToInProgress, false);
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
               correlation_id: meeting.correlationId,
@@ -6290,6 +6324,7 @@ describe('plugin-meetings', () => {
               'SELF_OBSERVING'
             );
           } catch {
+            assert.equal(meeting.isMoveToInProgress, false);
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
               correlation_id: meeting.correlationId,
@@ -7852,6 +7887,7 @@ describe('plugin-meetings', () => {
       describe('#setUpLocusInfoSelfListener', () => {
         it('listens to the self unadmitted guest event', (done) => {
           meeting.startKeepAlive = sinon.stub();
+          meeting.updateLLMConnection = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
           assert.calledOnceWithExactly(meeting.startKeepAlive);
           assert.calledThrice(TriggerProxy.trigger);
@@ -7862,6 +7898,7 @@ describe('plugin-meetings', () => {
             'meeting:self:lobbyWaiting',
             {payload: test1}
           );
+          assert.calledOnce(meeting.updateLLMConnection);
           done();
         });
         it('listens to the self admitted guest event', (done) => {

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -106,6 +106,12 @@ describe('LocusMediaRequest.send()', () => {
       },
     });
 
+    mockWebex.internal = {
+      newMetrics: {
+        submitClientEvent: sinon.stub()
+      },
+    };
+
     locusMediaRequest = new LocusMediaRequest({
       device: {
         url: 'deviceUrl',
@@ -113,6 +119,7 @@ describe('LocusMediaRequest.send()', () => {
         regionCode: 'regionCode',
       },
       correlationId: 'correlationId',
+      meetingId: 'meetingId',
       preferTranscoding: true,
     }, {
       parent: mockWebex,
@@ -134,6 +141,27 @@ describe('LocusMediaRequest.send()', () => {
     await sendRoapMessage('OFFER');
 
     webexRequestStub.resetHistory();
+    mockWebex.internal.newMetrics.submitClientEvent.resetHistory();
+  }
+
+  const checkMetrics = (expectedMetrics: boolean = true) => {
+    if (expectedMetrics) {
+      assert.calledWith(mockWebex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.request',
+        options: {
+          meetingId: 'meetingId',
+        },
+      });
+
+      assert.calledWith(mockWebex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.response',
+        options: {
+          meetingId: 'meetingId',
+        },
+      });
+    } else {
+      assert.notCalled(mockWebex.internal.newMetrics.submitClientEvent);
+    }
   }
 
   it('sends a roap message', async () => {
@@ -146,6 +174,21 @@ describe('LocusMediaRequest.send()', () => {
       uri: 'fakeMeetingSelfUrl/media',
       body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
     });
+
+    checkMetrics();
+  });
+
+  it('sends correct metric event when roap message fails', async () => {
+    webexRequestStub.rejects({code: 300, message: 'fake error'});
+    await assert.isRejected(sendRoapMessage('OFFER'));
+
+    assert.calledWith(mockWebex.internal.newMetrics.submitClientEvent, {
+      name: 'client.locus.media.response',
+      options: {
+        meetingId: 'meetingId',
+        rawError: {code: 300, message: 'fake error'},
+      },
+    });
   });
 
   it('sends a local mute request', async () => {
@@ -160,6 +203,8 @@ describe('LocusMediaRequest.send()', () => {
       uri: 'fakeMeetingSelfUrl/media',
       body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: false}),
     });
+
+    checkMetrics(false);
   });
 
   it('sends a local mute request with sequence', async () => {
@@ -207,6 +252,7 @@ describe('LocusMediaRequest.send()', () => {
       body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
     });
 
+    checkMetrics(false);
   });
 
   it('sends a local mute request with the last audio/video mute values', async () => {
@@ -225,6 +271,7 @@ describe('LocusMediaRequest.send()', () => {
       body: createExpectedLocalMuteBody({audioMuted: true, videoMuted: false}),
     });
 
+    checkMetrics(false);
   });
 
   it('sends only roap when roap and local mute are requested', async () => {
@@ -242,6 +289,8 @@ describe('LocusMediaRequest.send()', () => {
       uri: 'fakeMeetingSelfUrl/media',
       body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: false}),
     });
+
+    checkMetrics();
   });
 
   describe('queueing', () => {

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

@@ -370,16 +370,6 @@ describe('plugin-meetings', () => {
           sequence: {},
           type: 'LocalMute',
         });
-
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.locus.media.request',
-          options: {meetingId: meeting.id},
-        });
-
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.locus.media.response',
-          options: {meetingId: meeting.id},
-        });
       });
     });
 

package/test/unit/spec/meeting/voicea-meeting.ts

@@ -101,14 +101,7 @@ describe('plugin-meetings', () => {
                     ],
                     transcript_language_code: "en"
                 }
-            ],
-            transcript: {
-                text: "Don't bother me talking I'm just going to get the transcript data that is interim and I needed if I keep talking, I get the interim data",
-                csis: [
-                    1234867712
-                ],
-                transcript_language_code: "en"
-            }
+            ]
         };
     });
 
@@ -160,7 +153,6 @@ describe('plugin-meetings', () => {
             it('should process new final captions correctly', () => {
                 let transcriptData = fakeMeeting.transcription;
                 let transcriptId = fakeVoiceaPayload.transcriptId;
-                delete fakeVoiceaPayload.transcripts;
 
                 // Assuming that processNewCaptions is a pure function that doesn't mutate the input but returns a new state
                 processNewCaptions({
@@ -169,7 +161,7 @@ describe('plugin-meetings', () => {
                 });
 
                 // Check if speaker details are cached if needed
-                const csisKey = fakeVoiceaPayload.transcript.csis[0];
+                const csisKey = fakeVoiceaPayload.transcripts[0].csis[0];
                 const speaker = transcriptData.speakerProxy[csisKey];
                 expect(speaker).to.exist;
 
@@ -178,6 +170,7 @@ describe('plugin-meetings', () => {
 
                 //check if the interim caption is removed
                 const oldInterimCaption = transcriptData.captions.find(caption => caption.id === `${transcriptId}_${speaker.speakerId}`);
+                console.log(oldInterimCaption);
                 expect(oldInterimCaption).to.not.exist;
 
                 // Check the final caption data
@@ -186,8 +179,8 @@ describe('plugin-meetings', () => {
                 expect(newCaption).to.include({
                   id: transcriptId,
                   isFinal: fakeVoiceaPayload.isFinal,
-                  text: fakeVoiceaPayload.transcript.text,
-                  currentSpokenLanguage: fakeVoiceaPayload.transcript.transcript_language_code,
+                  text: fakeVoiceaPayload.transcripts[0].text,
+                  currentSpokenLanguage: fakeVoiceaPayload.transcripts[0].transcript_language_code,
                 });
 
                 // Check the speaker data in the new caption
@@ -197,7 +190,6 @@ describe('plugin-meetings', () => {
             it('should process new interim captions correctly', () => {
                 let transcriptData = fakeMeeting.transcription;
                 let transcriptId = fakeVoiceaPayload.transcriptId;
-                delete fakeVoiceaPayload.transcript;
 
                 transcriptData.captions.splice(transcriptData.length - 1, 1);
                 fakeVoiceaPayload.isFinal = false;
@@ -232,7 +224,6 @@ describe('plugin-meetings', () => {
             it('should process interim captions with an existing one correctly', () => {
                 let transcriptData = fakeMeeting.transcription;
                 let transcriptId = fakeVoiceaPayload.transcriptId;
-                delete fakeVoiceaPayload.transcript;
                 fakeVoiceaPayload.isFinal = false;
 
                 processNewCaptions({