@webex/internal-plugin-device 3.12.0-next.8 → 3.12.0-task-refactor.1

package/src/device.js

@@ -6,13 +6,7 @@ import {orderBy} from 'lodash';
 import uuid from 'uuid';
 
 import METRICS from './metrics';
-import {
-  FEATURE_COLLECTION_NAMES,
-  DEVICE_EVENT_REGISTRATION_SUCCESS,
-  MIN_DEVICES_FOR_CLEANUP,
-  MAX_DELETION_CONFIRMATION_ATTEMPTS,
-  DELETION_CONFIRMATION_DELAY_MS,
-} from './constants';
+import {FEATURE_COLLECTION_NAMES, DEVICE_EVENT_REGISTRATION_SUCCESS} from './constants';
 import FeaturesModel from './features/features-model';
 import IpNetworkDetector from './ipNetworkDetector';
 import {CatalogDetails} from './types';
@@ -460,117 +454,46 @@ const Device = WebexPlugin.extend({
     });
   },
   /**
-   * Fetches devices matching the current device type.
-   * @returns {Promise<Array>} filtered device list
+   * Fetches the web devices and deletes the third of them which are not recent devices in use
+   * @returns {Promise<void, Error>}
    */
-  _getDevicesOfCurrentType() {
-    const {deviceType} = this._getBody();
-
+  deleteDevices() {
+    // Fetch devices with a GET request
     return this.request({
       method: 'GET',
       service: 'wdm',
       resource: 'devices',
-    }).then((response) => response.body.devices.filter((item) => item.deviceType === deviceType));
-  },
-
-  /**
-   * Waits until the server-side device count drops to or below targetCount,
-   * polling up to maxAttempts times with a delay between each check.
-   * @param {number} targetCount - resolve when device count drops to this value or below
-   * @param {number} [attempt=0]
-   * @returns {Promise<void>}
-   */
-  _waitForDeviceCountBelowLimit(targetCount, attempt = 0) {
-    if (attempt >= MAX_DELETION_CONFIRMATION_ATTEMPTS) {
-      this.logger.warn('device: max confirmation attempts reached, proceeding anyway');
-
-      return Promise.resolve();
-    }
-
-    return new Promise((resolve) => setTimeout(resolve, DELETION_CONFIRMATION_DELAY_MS))
-      .then(() => this._getDevicesOfCurrentType())
-      .then((devices) => {
-        this.logger.info(
-          `device: confirmation check ${attempt + 1}/${MAX_DELETION_CONFIRMATION_ATTEMPTS}, ` +
-            `${devices.length} devices remaining (target: ≤ ${targetCount})`
-        );
-
-        if (devices.length <= targetCount) {
-          this.logger.info('device: device count is now safely below limit');
-
-          return Promise.resolve();
-        }
-
-        return this._waitForDeviceCountBelowLimit(targetCount, attempt + 1);
-      })
-      .catch((error) => {
-        this.logger.warn(
-          `device: confirmation check ${attempt + 1} failed, proceeding anyway:`,
-          error
-        );
+    })
+      .then((response) => {
+        const {devices} = response.body;
 
-        return Promise.resolve();
-      });
-  },
+        const {deviceType} = this._getBody();
 
-  /**
-   * Fetches the web devices and deletes the oldest third, then waits
-   * for the server to confirm the count is below the limit.
-   * @returns {Promise<void>}
-   */
-  deleteDevices() {
-    let targetCount;
+        // Filter devices of type deviceType
+        const webDevices = devices.filter((item) => item.deviceType === deviceType);
 
-    return this._getDevicesOfCurrentType()
-      .then((webDevices) => {
         const sortedDevices = orderBy(webDevices, [(item) => new Date(item.modificationTime)]);
 
-        if (sortedDevices.length <= MIN_DEVICES_FOR_CLEANUP) {
-          this.logger.info(
-            `device: only ${sortedDevices.length} devices found (minimum ${MIN_DEVICES_FOR_CLEANUP}), skipping cleanup`
+        // If there are more than two devices, delete the last third
+        if (sortedDevices.length > 2) {
+          const totalItems = sortedDevices.length;
+          const countToDelete = Math.ceil(totalItems / 3);
+          const urlsToDelete = sortedDevices.slice(0, countToDelete).map((item) => item.url);
+
+          return Promise.race(
+            urlsToDelete.map((url) => {
+              return this.request({
+                uri: url,
+                method: 'DELETE',
+              });
+            })
           );
-
-          return Promise.resolve();
         }
 
-        const devicesToDelete = sortedDevices.slice(0, Math.ceil(sortedDevices.length / 3));
-        targetCount = sortedDevices.length - Math.min(5, devicesToDelete.length);
-
-        this.logger.info(
-          `device: deleting ${devicesToDelete.length} of ${webDevices.length} devices`
-        );
-
-        return Promise.all(
-          devicesToDelete.map((device) =>
-            this.request({uri: device.url, method: 'DELETE'})
-              .then(() => ({status: 'fulfilled'}))
-              .catch((reason) => ({status: 'rejected', reason}))
-          )
-        ).then((results) => {
-          const failed = results.filter((r) => r.status === 'rejected');
-
-          if (failed.length > 0) {
-            this.logger.warn(
-              `device: ${failed.length} of ${devicesToDelete.length} deletions failed (best-effort, continuing)`
-            );
-          }
-          this.logger.info(
-            `device: deleted ${devicesToDelete.length - failed.length} of ${
-              devicesToDelete.length
-            } devices`
-          );
-        });
-      })
-      .then(() =>
-        targetCount !== undefined
-          ? this._waitForDeviceCountBelowLimit(targetCount, 0)
-          : Promise.resolve()
-      )
-      .then(() => {
-        this.logger.info('device: device count confirmed below limit, cleanup successful');
+        return Promise.resolve();
       })
       .catch((error) => {
-        this.logger.error('device: failed to delete devices:', error);
+        this.logger.error('Failed to retrieve devices:', error);
 
         return Promise.reject(error);
       });
@@ -596,11 +519,7 @@ const Device = WebexPlugin.extend({
 
       return this._registerInternal(deviceRegistrationOptions).catch((error) => {
         if (error?.body?.message === 'User has excessive device registrations') {
-          this.logger.info('device: excessive device registrations detected, initiating cleanup');
-
           return this.deleteDevices().then(() => {
-            this.logger.info('device: device cleanup complete, retrying registration');
-
             return this._registerInternal(deviceRegistrationOptions);
           });
         }
@@ -867,34 +786,6 @@ const Device = WebexPlugin.extend({
     return Promise.reject(new Error('device: failed to get the current websocket url'));
   },
 
-  /**
-   * Get sanitized processed debug features from session storage
-   * these should be JSON encoded and in the form {feature1: true, feature2: false}
-   *
-   * @returns {Array<Object>} - Array of sanitized debug feature toggles
-   */
-  getDebugFeatures() {
-    const sanitizedDebugFeatures = [];
-    if (this.config.debugFeatureTogglesKey) {
-      const debugFeaturesString = this.webex
-        .getWindow()
-        .sessionStorage.getItem(this.config.debugFeatureTogglesKey);
-      if (debugFeaturesString) {
-        const debugFeatures = JSON.parse(debugFeaturesString);
-        Object.entries(debugFeatures).forEach(([key, value]) => {
-          sanitizedDebugFeatures.push({
-            key,
-            val: value ? 'true' : 'false',
-            mutable: true,
-            lastModified: new Date().toISOString(),
-          });
-        });
-      }
-    }
-
-    return sanitizedDebugFeatures;
-  },
-
   /**
    * Process a successful device registration.
    *
@@ -923,14 +814,6 @@ const Device = WebexPlugin.extend({
       // When using the etag feature cache, user and entitlement features are still returned
       this.features.user.reset(features.user);
       this.features.entitlement.reset(features.entitlement);
-    } else if (this.config.debugFeatureTogglesKey && body?.features?.developer) {
-      // Add the debug feature toggles from session storage if available
-      try {
-        const debugFeatures = this.getDebugFeatures();
-        body.features.developer.push(...debugFeatures);
-      } catch (error) {
-        this.logger.error('Failed to parse debug feature toggles from session storage:', error);
-      }
     }
 
     // Assign the recieved DTO from **WDM** to this device.
@@ -1063,13 +946,6 @@ const Device = WebexPlugin.extend({
     // Prototype the extended class in order to preserve the parent member.
     Reflect.apply(WebexPlugin.prototype.initialize, this, args);
 
-    this.listenToOnce(this.webex, 'change:config', () => {
-      // If debug feature toggles exist, clear the etag to ensure developer feature toggles are fetched
-      if (this.getDebugFeatures(this.config.debugFeatureTogglesKey).length > 0) {
-        this.set('etag', undefined);
-      }
-    });
-
     // Initialize feature events and listeners.
     FEATURE_COLLECTION_NAMES.forEach((collectionName) => {
       this.features.on(`change:${collectionName}`, (model, value, options) => {

package/src/ipNetworkDetector.ts

@@ -188,7 +188,7 @@ const IpNetworkDetector = WebexPlugin.extend({
 
       results = await this.gatherLocalCandidates(pc);
     } finally {
-      pc?.close();
+      pc.close();
       this.state = STATE.IDLE;
     }