livekit-client 2.17.1 → 2.17.3

package/src/room/data-track/outgoing/OutgoingDataTrackManager.test.ts

@@ -0,0 +1,392 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { subscribeToEvents } from '../../../utils/subscribeToEvents';
+import { EncryptionProvider } from '../e2ee';
+import { DataTrackHandle } from '../handle';
+import { DataTrackPacket, FrameMarker } from '../packet';
+import OutgoingDataTrackManager, {
+  DataTrackOutgoingManagerCallbacks,
+  Descriptor,
+} from './OutgoingDataTrackManager';
+import { DataTrackPublishError } from './errors';
+
+/** A fake "encryption" provider used for test purposes. Adds a prefix to the payload. */
+const PrefixingEncryptionProvider: EncryptionProvider = {
+  encrypt(payload: Uint8Array) {
+    const prefix = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+
+    const output = new Uint8Array(prefix.length + payload.length);
+    output.set(prefix, 0);
+    output.set(payload, prefix.length);
+
+    return {
+      payload: output,
+      iv: new Uint8Array(12), // Just leaving this empty, is this a bad idea?
+      keyIndex: 0,
+    };
+  },
+};
+
+describe('DataTrackOutgoingManager', () => {
+  it('should test track publishing (ok case)', async () => {
+    const manager = new OutgoingDataTrackManager();
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuPublishRequest',
+    ]);
+
+    // 1. Publish a data track
+    const publishRequestPromise = manager.publishRequest({ name: 'test' });
+
+    // 2. This publish request should be sent along to the SFU
+    const sfuPublishEvent = await managerEvents.waitFor('sfuPublishRequest');
+    expect(sfuPublishEvent.name).toStrictEqual('test');
+    expect(sfuPublishEvent.usesE2ee).toStrictEqual(false);
+    const handle = sfuPublishEvent.handle;
+
+    // 3. Respond to the SFU publish request with an OK response
+    manager.receivedSfuPublishResponse(handle, {
+      type: 'ok',
+      data: {
+        sid: 'bogus-sid',
+        pubHandle: sfuPublishEvent.handle,
+        name: 'test',
+        usesE2ee: false,
+      },
+    });
+
+    // Make sure that the original input event resolves.
+    const localDataTrack = await publishRequestPromise;
+    expect(localDataTrack.isPublished()).toStrictEqual(true);
+  });
+
+  it('should test track publishing (error case)', async () => {
+    const manager = new OutgoingDataTrackManager();
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuPublishRequest',
+    ]);
+
+    // 1. Publish a data track
+    const publishRequestPromise = manager.publishRequest({ name: 'test' });
+
+    // 2. This publish request should be sent along to the SFU
+    const sfuPublishEvent = await managerEvents.waitFor('sfuPublishRequest');
+
+    // 3. Respond to the SFU publish request with an ERROR response
+    manager.receivedSfuPublishResponse(sfuPublishEvent.handle, {
+      type: 'error',
+      error: DataTrackPublishError.limitReached(),
+    });
+
+    // Make sure that the rejection bubbles back to the caller
+    expect(publishRequestPromise).rejects.toThrowError('Data track publication limit reached');
+  });
+
+  it('should test track publishing (cancellation half way through)', async () => {
+    const manager = new OutgoingDataTrackManager();
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuPublishRequest',
+      'sfuUnpublishRequest',
+    ]);
+
+    // 1. Publish a data track
+    const controller = new AbortController();
+    const publishRequestPromise = manager.publishRequest({ name: 'test' }, controller.signal);
+
+    // 2. This publish request should be sent along to the SFU
+    const sfuPublishEvent = await managerEvents.waitFor('sfuPublishRequest');
+    expect(sfuPublishEvent.name).toStrictEqual('test');
+    expect(sfuPublishEvent.usesE2ee).toStrictEqual(false);
+    const handle = sfuPublishEvent.handle;
+
+    // 3. Explictly cancel the publish
+    controller.abort();
+
+    // 4. Make sure an unpublish event is sent so that the SFU cleans up things properly
+    // on its end as well
+    const sfuUnpublishEvent = await managerEvents.waitFor('sfuUnpublishRequest');
+    expect(sfuUnpublishEvent.handle).toStrictEqual(handle);
+
+    // 5. Make sure cancellation is bubbled up as an error to stop further execution
+    expect(publishRequestPromise).rejects.toStrictEqual(DataTrackPublishError.cancelled());
+  });
+
+  it.each([
+    // Single packet payload case
+    [
+      new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05]),
+      [
+        {
+          header: {
+            extensions: {
+              e2ee: null,
+              userTimestamp: null,
+            },
+            frameNumber: 0,
+            marker: FrameMarker.Single,
+            sequence: 0,
+            timestamp: expect.anything(),
+            trackHandle: 5,
+          },
+          payload: new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05]),
+        },
+      ],
+    ],
+
+    // Multi packet payload case
+    [
+      new Uint8Array(24_000).fill(0xbe),
+      [
+        {
+          header: {
+            extensions: {
+              e2ee: null,
+              userTimestamp: null,
+            },
+            frameNumber: 0,
+            marker: FrameMarker.Start,
+            sequence: 0,
+            timestamp: expect.anything(),
+            trackHandle: 5,
+          },
+          payload: new Uint8Array(15988 /* 16k mtu - 12 header bytes */).fill(0xbe),
+        },
+        {
+          header: {
+            extensions: {
+              e2ee: null,
+              userTimestamp: null,
+            },
+            frameNumber: 0,
+            marker: FrameMarker.Final,
+            sequence: 1,
+            timestamp: expect.anything(),
+            trackHandle: 5,
+          },
+          payload: new Uint8Array(8012 /* 24k payload - (16k mtu - 12 header bytes) */).fill(0xbe),
+        },
+      ],
+    ],
+  ])(
+    'should test track payload sending',
+    async (inputBytes: Uint8Array, outputPacketsJson: Array<unknown>) => {
+      // Create a manager prefilled with a descriptor
+      const manager = OutgoingDataTrackManager.withDescriptors(
+        new Map([
+          [
+            DataTrackHandle.fromNumber(5),
+            Descriptor.active(
+              {
+                sid: 'bogus-sid',
+                pubHandle: 5,
+                name: 'test',
+                usesE2ee: false,
+              },
+              null,
+            ),
+          ],
+        ]),
+      );
+      const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+        'packetsAvailable',
+      ]);
+
+      const localDataTrack = manager.createLocalDataTrack(5)!;
+      expect(localDataTrack).not.toStrictEqual(null);
+
+      // Kick off sending the bytes...
+      localDataTrack.tryPush(inputBytes);
+
+      // ... and make sure the corresponding events are emitted to tell the SFU to send the packets
+      for (const outputPacketJson of outputPacketsJson) {
+        const packetBytes = await managerEvents.waitFor('packetsAvailable');
+        const [packet] = DataTrackPacket.fromBinary(packetBytes.bytes);
+
+        expect(packet.toJSON()).toStrictEqual(outputPacketJson);
+      }
+    },
+  );
+
+  it('should send e2ee encrypted datatrack payload', async () => {
+    const manager = new OutgoingDataTrackManager({
+      encryptionProvider: PrefixingEncryptionProvider,
+    });
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuPublishRequest',
+      'packetsAvailable',
+    ]);
+
+    // 1. Publish a data track
+    const publishRequestPromise = manager.publishRequest({ name: 'test' });
+
+    // 2. This publish request should be sent along to the SFU
+    const sfuPublishEvent = await managerEvents.waitFor('sfuPublishRequest');
+    expect(sfuPublishEvent.name).toStrictEqual('test');
+    expect(sfuPublishEvent.usesE2ee).toStrictEqual(true); // NOTE: this is true, e2ee is enabled!
+    const handle = sfuPublishEvent.handle;
+
+    // 3. Respond to the SFU publish request with an OK response
+    manager.receivedSfuPublishResponse(handle, {
+      type: 'ok',
+      data: {
+        sid: 'bogus-sid',
+        pubHandle: sfuPublishEvent.handle,
+        name: 'test',
+        usesE2ee: true, // NOTE: this is true, e2ee is enabled!
+      },
+    });
+
+    // Get the connected local data track
+    const localDataTrack = await publishRequestPromise;
+    expect(localDataTrack.isPublished()).toStrictEqual(true);
+
+    // Kick off sending the payload bytes
+    localDataTrack.tryPush(new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05]));
+
+    // Make sure the packet that was sent was encrypted with the PrefixingEncryptionProvider
+    const packetBytes = await managerEvents.waitFor('packetsAvailable');
+    const [packet] = DataTrackPacket.fromBinary(packetBytes.bytes);
+
+    expect(packet.toJSON()).toStrictEqual({
+      header: {
+        extensions: {
+          e2ee: {
+            iv: new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            keyIndex: 0,
+            lengthBytes: 13,
+            tag: 1,
+          },
+          userTimestamp: null,
+        },
+        frameNumber: 0,
+        marker: 3,
+        sequence: 0,
+        timestamp: expect.anything(),
+        trackHandle: 1,
+      },
+      payload: new Uint8Array([
+        // Encryption added prefix
+        0xde, 0xad, 0xbe, 0xef,
+        // Actual payload
+        0x01, 0x02, 0x03, 0x04, 0x05,
+      ]),
+    });
+  });
+
+  it('should test track unpublishing', async () => {
+    // Create a manager prefilled with a descriptor
+    const manager = OutgoingDataTrackManager.withDescriptors(
+      new Map([
+        [
+          DataTrackHandle.fromNumber(5),
+          Descriptor.active(
+            {
+              sid: 'bogus-sid',
+              pubHandle: 5,
+              name: 'test',
+              usesE2ee: false,
+            },
+            null,
+          ),
+        ],
+      ]),
+    );
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuUnpublishRequest',
+    ]);
+
+    // Make sure the descriptor is in there
+    expect(manager.getDescriptor(5)?.type).toStrictEqual('active');
+
+    // Unpublish data track
+    const unpublishRequestPromise = manager.unpublishRequest(DataTrackHandle.fromNumber(5));
+
+    const sfuUnpublishEvent = await managerEvents.waitFor('sfuUnpublishRequest');
+    expect(sfuUnpublishEvent.handle).toStrictEqual(5);
+
+    manager.receivedSfuUnpublishResponse(DataTrackHandle.fromNumber(5));
+
+    await unpublishRequestPromise;
+
+    // Make sure data track is no longer
+    expect(manager.getDescriptor(5)).toStrictEqual(null);
+  });
+
+  it('should query currently active descriptors', async () => {
+    // Create a manager prefilled with a descriptor
+    const manager = OutgoingDataTrackManager.withDescriptors(
+      new Map([
+        [
+          DataTrackHandle.fromNumber(2),
+          Descriptor.active(
+            {
+              sid: 'bogus-sid-2',
+              pubHandle: 2,
+              name: 'twotwotwo',
+              usesE2ee: false,
+            },
+            null,
+          ),
+        ],
+        [
+          DataTrackHandle.fromNumber(6),
+          Descriptor.active(
+            {
+              sid: 'bogus-sid-6',
+              pubHandle: 6,
+              name: 'sixsixsix',
+              usesE2ee: false,
+            },
+            null,
+          ),
+        ],
+      ]),
+    );
+
+    const result = await manager.queryPublished();
+
+    expect(result).toStrictEqual([
+      { sid: 'bogus-sid-2', pubHandle: 2, name: 'twotwotwo', usesE2ee: false },
+      { sid: 'bogus-sid-6', pubHandle: 6, name: 'sixsixsix', usesE2ee: false },
+    ]);
+  });
+
+  it('should shutdown cleanly', async () => {
+    // Create a manager prefilled with a descriptor
+    const pendingDescriptor = Descriptor.pending();
+    const manager = OutgoingDataTrackManager.withDescriptors(
+      new Map<DataTrackHandle, Descriptor>([
+        [DataTrackHandle.fromNumber(2), pendingDescriptor],
+        [
+          DataTrackHandle.fromNumber(6),
+          Descriptor.active(
+            {
+              sid: 'bogus-sid-6',
+              pubHandle: 6,
+              name: 'sixsixsix',
+              usesE2ee: false,
+            },
+            null,
+          ),
+        ],
+      ]),
+    );
+    const managerEvents = subscribeToEvents<DataTrackOutgoingManagerCallbacks>(manager, [
+      'sfuUnpublishRequest',
+    ]);
+
+    // Shut down the manager
+    const shutdownPromise = manager.shutdown();
+
+    // The pending data track should be cancelled
+    expect(pendingDescriptor.completionFuture.promise).rejects.toThrowError('Room disconnected');
+
+    // And the active data track should be requested to be unpublished
+    const unpublishEvent = await managerEvents.waitFor('sfuUnpublishRequest');
+    expect(unpublishEvent.handle).toStrictEqual(6);
+
+    // Acknowledge that the unpublish has occurred
+    manager.receivedSfuUnpublishResponse(DataTrackHandle.fromNumber(6));
+
+    await shutdownPromise;
+  });
+});

package/src/room/data-track/outgoing/OutgoingDataTrackManager.ts

@@ -0,0 +1,302 @@
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
+import { LoggerNames, getLogger } from '../../../logger';
+import type { Throws } from '../../../utils/throws';
+import { Future } from '../../utils';
+import { type EncryptionProvider } from '../e2ee';
+import type { DataTrackFrame } from '../frame';
+import { DataTrackHandle, DataTrackHandleAllocator } from '../handle';
+import { DataTrackExtensions } from '../packet/extensions';
+import { type DataTrackInfo, LocalDataTrack } from '../track';
+import {
+  DataTrackPublishError,
+  DataTrackPublishErrorReason,
+  DataTrackPushFrameError,
+  DataTrackPushFrameErrorReason,
+} from './errors';
+import DataTrackOutgoingPipeline from './pipeline';
+import {
+  type DataTrackOptions,
+  type OutputEventPacketsAvailable,
+  type OutputEventSfuPublishRequest,
+  type OutputEventSfuUnpublishRequest,
+  type SfuPublishResponseResult,
+} from './types';
+
+const log = getLogger(LoggerNames.DataTracks);
+
+export type PendingDescriptor = {
+  type: 'pending';
+  completionFuture: Future<
+    LocalDataTrack,
+    | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
+    | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
+    | DataTrackPublishError<DataTrackPublishErrorReason.Timeout>
+    | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>
+    | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>
+    | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>
+  >;
+};
+export type ActiveDescriptor = {
+  type: 'active';
+  info: DataTrackInfo;
+
+  pipeline: DataTrackOutgoingPipeline;
+
+  /** Resolves when the descriptor is unpublished. */
+  unpublishingFuture: Future<void, never>;
+};
+export type Descriptor = PendingDescriptor | ActiveDescriptor;
+
+export const Descriptor = {
+  pending(): PendingDescriptor {
+    return {
+      type: 'pending',
+      completionFuture: new Future(),
+    };
+  },
+  active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor {
+    return {
+      type: 'active',
+      info,
+      pipeline: new DataTrackOutgoingPipeline({ info, encryptionProvider }),
+      unpublishingFuture: new Future(),
+    };
+  },
+};
+
+export type DataTrackOutgoingManagerCallbacks = {
+  /** Request sent to the SFU to publish a track. */
+  sfuPublishRequest: (event: OutputEventSfuPublishRequest) => void;
+  /** Request sent to the SFU to unpublish a track. */
+  sfuUnpublishRequest: (event: OutputEventSfuUnpublishRequest) => void;
+  /** Serialized packets are ready to be sent over the transport. */
+  packetsAvailable: (event: OutputEventPacketsAvailable) => void;
+};
+
+type DataTrackLocalManagerOptions = {
+  /**
+   * Provider to use for encrypting outgoing frame payloads.
+   *
+   * If none, end-to-end encryption will be disabled for all published tracks.
+   */
+  encryptionProvider?: EncryptionProvider;
+};
+
+/** How long to wait when attempting to publish before timing out. */
+const PUBLISH_TIMEOUT_MILLISECONDS = 10_000;
+
+export default class OutgoingDataTrackManager extends (EventEmitter as new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>) {
+  private encryptionProvider: EncryptionProvider | null;
+
+  private handleAllocator = new DataTrackHandleAllocator();
+
+  private descriptors = new Map<DataTrackHandle, Descriptor>();
+
+  constructor(options?: DataTrackLocalManagerOptions) {
+    super();
+    this.encryptionProvider = options?.encryptionProvider ?? null;
+  }
+
+  static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>) {
+    const manager = new OutgoingDataTrackManager();
+    manager.descriptors = descriptors;
+    return manager;
+  }
+
+  /**
+   * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
+   * @internal
+   */
+  getDescriptor(handle: DataTrackHandle) {
+    return this.descriptors.get(handle) ?? null;
+  }
+
+  createLocalDataTrack(handle: DataTrackHandle) {
+    const descriptor = this.getDescriptor(handle);
+    if (descriptor?.type !== 'active') {
+      return null;
+    }
+    return new LocalDataTrack(descriptor.info, this);
+  }
+
+  /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
+   * subscribers.
+   * @internal
+   */
+  tryProcessAndSend(
+    handle: DataTrackHandle,
+    payload: Uint8Array,
+  ): Throws<
+    void,
+    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>
+    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>
+  > {
+    const descriptor = this.getDescriptor(handle);
+    if (descriptor?.type !== 'active') {
+      throw DataTrackPushFrameError.trackUnpublished();
+    }
+
+    const frame: DataTrackFrame = {
+      payload,
+      extensions: new DataTrackExtensions(),
+    };
+
+    try {
+      for (const packet of descriptor.pipeline.processFrame(frame)) {
+        this.emit('packetsAvailable', { bytes: packet.toBinary() });
+      }
+    } catch (err) {
+      // NOTE: In the rust implementation this "dropped" error means something different (not enough room
+      // in the track mpsc channel)
+      throw DataTrackPushFrameError.dropped(err);
+    }
+  }
+
+  /** Client requested to publish a track. */
+  async publishRequest(options: DataTrackOptions, signal?: AbortSignal) {
+    const handle = this.handleAllocator.get();
+    if (!handle) {
+      throw DataTrackPublishError.limitReached();
+    }
+
+    const timeoutSignal = AbortSignal.timeout(PUBLISH_TIMEOUT_MILLISECONDS);
+    const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+
+    if (this.descriptors.has(handle)) {
+      // @throws-transformer ignore - this should be treated as a "panic" and not be caught
+      throw new Error('Descriptor for handle already exists');
+    }
+
+    const descriptor = Descriptor.pending();
+    this.descriptors.set(handle, descriptor);
+
+    const onAbort = () => {
+      const existingDescriptor = this.descriptors.get(handle);
+      if (!existingDescriptor) {
+        log.warn(`No descriptor for ${handle}`);
+        return;
+      }
+      this.descriptors.delete(handle);
+
+      // Let the SFU know that the publish has been cancelled
+      this.emit('sfuUnpublishRequest', { handle });
+
+      if (existingDescriptor.type === 'pending') {
+        existingDescriptor.completionFuture.reject?.(
+          timeoutSignal.aborted
+            ? DataTrackPublishError.timeout()
+            : // NOTE: the below cancelled case was introduced by web / there isn't a corresponding case in the rust version.
+              DataTrackPublishError.cancelled(),
+        );
+      }
+    };
+    combinedSignal.addEventListener('abort', onAbort);
+
+    this.emit('sfuPublishRequest', {
+      handle,
+      name: options.name,
+      usesE2ee: this.encryptionProvider !== null,
+    });
+
+    const localDataTrack = await descriptor.completionFuture.promise;
+    combinedSignal.removeEventListener('abort', onAbort);
+    return localDataTrack;
+  }
+
+  /** Get information about all currently published tracks. */
+  async queryPublished() {
+    const descriptorInfos = Array.from(this.descriptors.values())
+      .filter((descriptor): descriptor is ActiveDescriptor => descriptor.type === 'active')
+      .map((descriptor) => descriptor.info);
+
+    return descriptorInfos;
+  }
+
+  /** Client request to unpublish a track. */
+  async unpublishRequest(handle: DataTrackHandle) {
+    const descriptor = this.descriptors.get(handle);
+    if (!descriptor) {
+      log.warn(`No descriptor for ${handle}`);
+      return;
+    }
+    if (descriptor.type !== 'active') {
+      log.warn(`Track ${handle} not active`);
+      return;
+    }
+
+    this.emit('sfuUnpublishRequest', { handle });
+
+    await descriptor.unpublishingFuture.promise;
+  }
+
+  /** SFU responded to a request to publish a data track. */
+  receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult) {
+    const descriptor = this.descriptors.get(handle);
+    if (!descriptor) {
+      log.warn(`No descriptor for ${handle}`);
+      return;
+    }
+    this.descriptors.delete(handle);
+
+    if (descriptor.type !== 'pending') {
+      log.warn(`Track ${handle} already active`);
+      return;
+    }
+
+    if (result.type === 'ok') {
+      const info = result.data;
+
+      const encryptionProvider = info.usesE2ee ? this.encryptionProvider : null;
+      this.descriptors.set(info.pubHandle, Descriptor.active(info, encryptionProvider));
+
+      const localDataTrack = this.createLocalDataTrack(info.pubHandle);
+      if (!localDataTrack) {
+        // @throws-transformer ignore - this should be treated as a "panic" and not be caught
+        throw new Error(
+          'DataTrackOutgoingManager.handleSfuPublishResponse: localDataTrack was not created after active descriptor stored.',
+        );
+      }
+
+      descriptor.completionFuture.resolve?.(localDataTrack);
+    } else {
+      descriptor.completionFuture.reject?.(result.error);
+    }
+  }
+
+  /** SFU notification that a track has been unpublished. */
+  receivedSfuUnpublishResponse(handle: DataTrackHandle) {
+    const descriptor = this.descriptors.get(handle);
+    if (!descriptor) {
+      log.warn(`No descriptor for ${handle}`);
+      return;
+    }
+    this.descriptors.delete(handle);
+
+    if (descriptor.type !== 'active') {
+      log.warn(`Track ${handle} not active`);
+      return;
+    }
+
+    descriptor.unpublishingFuture.resolve?.();
+  }
+
+  /** Shuts down the manager and all associated tracks. */
+  async shutdown() {
+    for (const descriptor of this.descriptors.values()) {
+      switch (descriptor.type) {
+        case 'pending':
+          descriptor.completionFuture.reject?.(DataTrackPublishError.disconnected());
+          break;
+        case 'active':
+          // Abandon any unpublishing descriptors that were in flight and assume they will get
+          // cleaned up automatically with the connection shutdown.
+          descriptor.unpublishingFuture.resolve?.();
+
+          await this.unpublishRequest(descriptor.info.pubHandle);
+          break;
+      }
+    }
+    this.descriptors.clear();
+  }
+}