detox 21.0.0-rc.6 → 21.0.0-rc.8

package/src/devices/allocation/DeviceAllocator.js

@@ -1,43 +1,89 @@
-// @ts-nocheck
-const log = require('../../utils/logger').child({ cat: 'device' });
+/**
+ * @typedef {import('./drivers/AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('./drivers/AllocationDriverBase').DeallocOptions} DeallocOptions
+ * @typedef {import('../common/drivers/DeviceCookie').DeviceCookie} DeviceCookie
+ */
+
+const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
   /**
-   * @param allocationDriver { AllocationDriverBase }
+   * @param {AllocationDriverBase} allocationDriver
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
+    this._counter = 0;
+    this._ids = new Map();
+    traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
   }
 
   /**
-   * @param deviceConfig { Object }
-   * @return {Promise<DeviceCookie>}
+   * @returns {Promise<void>}
    */
-  allocate(deviceConfig) {
-    return this._driver.allocate(deviceConfig);
+  async init() {
+    if (typeof this._driver.init === 'function') {
+      await this._driver.init();
+    }
   }
 
   /**
-   * @param {DeviceCookie} deviceCookie
-   * @return {Promise<unknown>}
+   * @param {Detox.DetoxDeviceConfig} deviceConfig
+   * @returns {Promise<DeviceCookie>}
    */
-  postAllocate(deviceCookie) {
-    if (typeof this._driver.postAllocate !== 'function') {
-      return Promise.resolve();
-    }
+  async allocate(deviceConfig) {
+    const tid = this._counter++;
+    return await log.trace.complete({ data: deviceConfig, id: tid }, 'allocate', async () => {
+      const cookie = await this._driver.allocate(deviceConfig);
+      log.debug({ data: cookie }, `settled on ${cookie.name || cookie.id}`);
+      this._ids.set(cookie.id, tid);
+      return cookie;
+    });
+  }
 
-    return this._driver.postAllocate(deviceCookie);
+  /**
+   * @param {DeviceCookie} cookie
+   * @returns {Promise<DeviceCookie>}
+   */
+  async postAllocate(cookie) {
+    const tid = this._ids.get(cookie.id);
+    return await log.trace.complete({ data: cookie, id: tid }, `post-allocate: ${cookie.id}`, async () => {
+      const updatedCookie = typeof this._driver.postAllocate === 'function'
+        ? await this._driver.postAllocate(cookie)
+        : undefined;
+
+      return updatedCookie || cookie;
+    });
   }
 
   /**
-   * @param cookie { DeviceCookie }
-   * @param options { DeallocOptions }
-   * @return {Promise<void>}
+   * @param {DeviceCookie} cookie
+   * @param {DeallocOptions} options
+   * @returns {Promise<void>}
    */
-  free(cookie, options) {
-    return this._driver.free(cookie, options);
+  async free(cookie, options = {}) {
+    const tid = this._ids.get(cookie.id);
+    await log.trace.complete({ data: options, id: tid }, `free: ${cookie.id}`, async () => {
+      await this._driver.free(cookie, options);
+    });
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    if (typeof this._driver.cleanup === 'function') {
+      await this._driver.cleanup();
+    }
+  }
+
+  /**
+   * @returns {void}
+   */
+  emergencyCleanup() {
+    if (typeof this._driver.emergencyCleanup === 'function') {
+      this._driver.emergencyCleanup();
+    }
   }
 }
 

package/src/devices/allocation/DeviceList.js

@@ -0,0 +1,44 @@
+class DeviceListReadonly {
+  constructor(devices = []) {
+    this._devices = new Map(devices.map(device => [device.id, device]));
+  }
+
+  concat(other) {
+    return new DeviceListReadonly([...this, ...other]);
+  }
+
+  getIds() {
+    return [...this._devices.keys()];
+  }
+
+  [Symbol.iterator]() {
+    return this._devices.values();
+  }
+
+  /**
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    return this._devices.has(deviceId);
+  }
+}
+
+class DeviceList extends DeviceListReadonly {
+  filter(predicate) {
+    return new DeviceListReadonly([...this].filter(predicate));
+  }
+
+  add(deviceId, data) {
+    this._devices.set(deviceId, {
+      id: deviceId,
+      ...data,
+    });
+  }
+
+  delete(deviceId) {
+    this._devices.delete(deviceId);
+  }
+}
+
+module.exports = DeviceList;

package/src/devices/allocation/DeviceRegistry.js

@@ -0,0 +1,189 @@
+const ExclusiveLockfile = require('../../utils/ExclusiveLockfile');
+const PIDService = require('../../utils/PIDService');
+const { getDeviceRegistryPath } = require('../../utils/environment');
+const safeAsync = require('../../utils/safeAsync');
+
+const DeviceList = require('./DeviceList');
+
+const readOptions = {
+  encoding: 'utf8',
+};
+
+class DeviceRegistry {
+  constructor({
+    lockfilePath = getDeviceRegistryPath(),
+    sessionId = '',
+    pidService = new PIDService(),
+  } = {}) {
+    /***
+     * @private
+     * @type {string}
+     */
+    this._lockfilePath = lockfilePath;
+    /***
+     * @private
+     * @type {string}
+     */
+    this._sessionId = sessionId;
+    /***
+     * @private
+     */
+    this._pidService = pidService;
+    /***
+     * @protected
+     * @type {ExclusiveLockfile}
+     */
+    this._lockfile = new ExclusiveLockfile(this._lockfilePath, {
+      getInitialState: this._getInitialLockFileState.bind(this),
+      readOptions,
+    });
+  }
+
+  get lockFilePath() {
+    return this._lockfilePath;
+  }
+
+  /**
+   * Safety method to ensure that there are no remains of previously crashed Detox sessions.
+   */
+  async reset() {
+    await this._lockfile.exclusively(() => {
+      const empty = this._getInitialLockFileState();
+      this._lockfile.write(empty);
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async registerDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: true,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async releaseDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: false,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<void>}
+   */
+  async unregisterDevice(getDeviceId) {
+    await this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._deleteDevice(deviceId);
+      }
+    });
+  }
+
+  async unregisterSessionDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const sessionDevices = allDevices.filter(device => device.sessionId === this._sessionId);
+      for (const id of sessionDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  async unregisterZombieDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const zombieDevices = allDevices.filter(device => {
+        return device.sessionId !== this._sessionId && !this._pidService.isAlive(device.pid);
+      });
+
+      for (const id of zombieDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  /**
+   * @returns {Promise<DeviceList>}
+   */
+  async readSessionDevices() {
+    let devices;
+    await this._lockfile.exclusively(() => {
+      devices = this._getSessionDevicesSync();
+    });
+    return devices;
+  }
+
+  getTakenDevicesSync() {
+    const allDevices = this._getRegisteredDevices();
+    const busyDevices = allDevices.filter(device => device.busy);
+    const externalDevices = allDevices.filter(device => device.sessionId !== this._sessionId);
+    return busyDevices.concat(externalDevices);
+  }
+
+  /***
+   * @private
+   */
+  _getInitialLockFileState() {
+    return [];
+  }
+
+  /**
+   * @private
+   */
+  _upsertDevice(deviceId, data) {
+    const devices = this._getRegisteredDevices();
+    devices.add(deviceId, data);
+    this._lockfile.write([...devices]);
+  }
+
+  /**
+   * @private
+   */
+  _deleteDevice(deviceId) {
+    const devices = this._getRegisteredDevices();
+    devices.delete(deviceId);
+    this._lockfile.write([...devices]);
+  }
+
+  /***
+   * @private
+   * @returns {DeviceList}
+   */
+  _getRegisteredDevices() {
+    const devices = this._lockfile.read();
+    return new DeviceList(devices);
+  }
+
+  _getSessionDevicesSync() {
+    const devices = this._getRegisteredDevices();
+    const sessionDevices = devices.filter(device => device.sessionId === this._sessionId);
+    return sessionDevices;
+  }
+}
+
+module.exports = DeviceRegistry;

package/src/devices/allocation/drivers/AllocationDriverBase.d.ts

@@ -0,0 +1,15 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import { DeviceCookie } from '../../common/drivers/DeviceCookie';
+
+export interface DeallocOptions {
+  shutdown?: boolean;
+}
+
+export interface AllocationDriverBase {
+  init?(): Promise<void>;
+  allocate(deviceConfig: any): Promise<DeviceCookie>;
+  postAllocate?(deviceCookie: DeviceCookie): Promise<DeviceCookie | void>;
+  free(cookie: DeviceCookie, options: DeallocOptions): Promise<void>;
+  cleanup?(): Promise<void>;
+  emergencyCleanup?(): void;
+}

package/src/devices/{common/drivers/android/tools → allocation/drivers/android}/FreeDeviceFinder.js

@@ -1,6 +1,6 @@
-const log = require('../../../../../utils/logger').child({ cat: 'device' });
+const log = require('../../../../utils/logger').child({ cat: 'device' });
 
-const DEVICE_LOOKUP_LOG_EVT = 'DEVICE_LOOKUP';
+const DEVICE_LOOKUP = { event: 'DEVICE_LOOKUP' };
 
 class FreeDeviceFinder {
   constructor(adb, deviceRegistry) {
@@ -10,8 +10,9 @@ class FreeDeviceFinder {
 
   async findFreeDevice(deviceQuery) {
     const { devices } = await this.adb.devices();
+    const takenDevices = this.deviceRegistry.getTakenDevicesSync();
     for (const candidate of devices) {
-      if (await this._isDeviceFreeAndMatching(candidate, deviceQuery)) {
+      if (await this._isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery)) {
         return candidate.adbName;
       }
     }
@@ -19,30 +20,30 @@ class FreeDeviceFinder {
   }
 
   /**
-   * @protected
+   * @private
    */
-  async _isDeviceFreeAndMatching(candidate, deviceQuery) {
+  async _isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery) {
     const { adbName } = candidate;
 
-    const isTaken = this.deviceRegistry.includes(adbName);
+    const isTaken = takenDevices.includes(adbName);
     if (isTaken) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is already taken, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is already taken, skipping...`);
       return false;
     }
 
     const isOffline = candidate.status === 'offline';
     if (isOffline) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is offline, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is offline, skipping...`);
       return false;
     }
 
     const isMatching = await this._isDeviceMatching(candidate, deviceQuery);
     if (!isMatching) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} does not match "${deviceQuery}"`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} does not match "${deviceQuery}"`);
       return false;
     }
 
-    log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Found a matching & free device ${candidate.adbName}`);
+    log.debug(DEVICE_LOOKUP, `Found a matching & free device ${candidate.adbName}`);
     return true;
   }
 

package/src/devices/allocation/drivers/android/attached/AttachedAndroidAllocDriver.js

@@ -1,20 +1,26 @@
-// @ts-nocheck
-const AttachedAndroidDeviceCookie = require('../../../../cookies/AttachedAndroidDeviceCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ */
 
-class AttachedAndroidAllocDriver extends AllocationDriverBase {
+/**
+ * @implements {AllocationDriverBase}
+ */
+class AttachedAndroidAllocDriver {
   /**
-   * @param adb { ADB }
-   * @param deviceRegistry { DeviceRegistry }
-   * @param freeDeviceFinder { FreeDeviceFinder }
-   * @param attachedAndroidLauncher { AttachedAndroidLauncher }
+   * @param {object} options
+   * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
+   * @param {import('../../../DeviceRegistry')} options.deviceRegistry
+   * @param {import('../FreeDeviceFinder')} options.freeDeviceFinder
    */
-  constructor({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher }) {
-    super();
+  constructor({ adb, deviceRegistry, freeDeviceFinder }) {
     this._adb = adb;
     this._deviceRegistry = deviceRegistry;
     this._freeDeviceFinder = freeDeviceFinder;
-    this._attachedAndroidLauncher = attachedAndroidLauncher;
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -23,13 +29,13 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    */
   async allocate(deviceConfig) {
     const adbNamePattern = deviceConfig.device.adbName;
-    const adbName = await this._deviceRegistry.allocateDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
+    const adbName = await this._deviceRegistry.registerDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
 
-    return new AttachedAndroidDeviceCookie(adbName);
+    return { id: adbName, adbName };
   }
 
   /**
-   * @param {AttachedAndroidDeviceCookie} deviceCookie
+   * @param {AndroidDeviceCookie} deviceCookie
    * @returns {Promise<void>}
    */
   async postAllocate(deviceCookie) {
@@ -38,16 +44,15 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     // TODO Also disable native animations?
     await this._adb.apiLevel(adbName);
     await this._adb.unlockScreen(adbName);
-    await this._attachedAndroidLauncher.notifyLaunchCompleted(adbName);
   }
 
   /**
-   * @param cookie { AttachedAndroidDeviceCookie }
+   * @param cookie { AndroidDeviceCookie }
    * @return {Promise<void>}
    */
   async free(cookie) {
     const { adbName } = cookie;
-    await this._deviceRegistry.disposeDevice(adbName);
+    await this._deviceRegistry.unregisterDevice(adbName);
   }
 }
 

package/src/devices/allocation/drivers/android/emulator/EmulatorAllocDriver.js

@@ -1,32 +1,58 @@
-// @ts-nocheck
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ */
+
 const _ = require('lodash');
 
-const AndroidEmulatorCookie = require('../../../../cookies/AndroidEmulatorCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
+const Deferred = require('../../../../../utils/Deferred');
+const log = require('../../../../../utils/logger').child({ cat: 'device,device-allocation' });
 
 const { patchAvdSkinConfig } = require('./patchAvdSkinConfig');
 
-class EmulatorAllocDriver extends AllocationDriverBase {
+/**
+ * @implements {AllocationDriverBase}
+ */
+class EmulatorAllocDriver {
   /**
-   * @param adb { ADB }
-   * @param avdValidator { AVDValidator }
-   * @param emulatorVersionResolver { EmulatorVersionResolver }
-   * @param emulatorLauncher { EmulatorLauncher }
-   * @param allocationHelper { EmulatorAllocationHelper }
+   * @param {object} options
+   * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
+   * @param {import('./AVDValidator')} options.avdValidator
+   * @param {DetoxInternals.RuntimeConfig} options.detoxConfig
+   * @param {import('../../../DeviceRegistry')} options.deviceRegistry
+   * @param {import('./FreeEmulatorFinder')} options.freeDeviceFinder
+   * @param {import('./FreePortFinder')} options.freePortFinder
+   * @param {import('./EmulatorLauncher')} options.emulatorLauncher
+   * @param {import('./EmulatorVersionResolver')} options.emulatorVersionResolver
    */
-  constructor({ adb, avdValidator, emulatorVersionResolver, emulatorLauncher, allocationHelper }) {
-    super();
+  constructor({
+    adb,
+    avdValidator,
+    detoxConfig,
+    deviceRegistry,
+    freeDeviceFinder,
+    freePortFinder,
+    emulatorVersionResolver,
+    emulatorLauncher
+  }) {
     this._adb = adb;
     this._avdValidator = avdValidator;
+    this._deviceRegistry = deviceRegistry;
     this._emulatorVersionResolver = emulatorVersionResolver;
     this._emulatorLauncher = emulatorLauncher;
-    this._allocationHelper = allocationHelper;
-    this._launchInfo = {};
+    this._freeDeviceFinder = freeDeviceFinder;
+    this._freePortFinder = freePortFinder;
+    this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
+    this._fixAvdConfigIniSkinNameIfNeeded = _.memoize(this._fixAvdConfigIniSkinNameIfNeeded.bind(this));
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
    * @param deviceConfig
-   * @returns {Promise<AndroidEmulatorCookie>}
+   * @returns {Promise<AndroidDeviceCookie>}
    */
   async allocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
@@ -34,50 +60,83 @@ class EmulatorAllocDriver extends AllocationDriverBase {
     await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
-    const allocResult = await this._allocationHelper.allocateDevice(avdName);
-    const { adbName } = allocResult;
-
-    this._launchInfo[adbName] = {
-      avdName,
-      isRunning: allocResult.isRunning,
-      launchOptions: {
-        bootArgs: deviceConfig.bootArgs,
-        gpuMode: deviceConfig.gpuMode,
-        headless: deviceConfig.headless,
-        readonly: deviceConfig.readonly,
-        port: allocResult.placeholderPort,
-      },
-    };
+    const adbName = await this._deviceRegistry.registerDevice(async () => {
+      let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
+      if (!adbName) {
+        const port = await this._freePortFinder.findFreePort();
+        adbName = `emulator-${port}`;
+
+        await this._emulatorLauncher.launch({
+          bootArgs: deviceConfig.bootArgs,
+          gpuMode: deviceConfig.gpuMode,
+          headless: deviceConfig.headless,
+          readonly: deviceConfig.readonly,
+          avdName,
+          adbName,
+          port,
+        });
+      }
 
-    return new AndroidEmulatorCookie(adbName);
+      return adbName;
+    });
+
+    return {
+      id: adbName,
+      adbName,
+      name: `${adbName} (${avdName})`,
+    };
   }
 
   /**
-   * @param {AndroidEmulatorCookie} deviceCookie
-   * @returns {Promise<void>}
+   * @param {AndroidDeviceCookie} deviceCookie
    */
   async postAllocate(deviceCookie) {
     const { adbName } = deviceCookie;
-    const { avdName, isRunning, launchOptions } = this._launchInfo[adbName];
 
-    await this._emulatorLauncher.launch(avdName, adbName, isRunning, launchOptions);
+    await this._emulatorLauncher.awaitEmulatorBoot(adbName);
     await this._adb.apiLevel(adbName);
     await this._adb.disableAndroidAnimations(adbName);
     await this._adb.unlockScreen(adbName);
   }
 
   /**
-   * @param cookie { AndroidEmulatorCookie }
-   * @param options { DeallocOptions }
-   * @return { Promise<void> }
+   * @param cookie {AndroidDeviceCookie}
+   * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
+   * @return {Promise<void>}
    */
   async free(cookie, options = {}) {
     const { adbName } = cookie;
 
-    await this._allocationHelper.deallocateDevice(adbName);
-
     if (options.shutdown) {
+      await this._doShutdown(adbName);
+      await this._deviceRegistry.unregisterDevice(adbName);
+    } else {
+      await this._deviceRegistry.releaseDevice(adbName);
+    }
+  }
+
+  async cleanup() {
+    if (this._shouldShutdown) {
+      const { devices } = await this._adb.devices();
+      const actualEmulators = devices.map((device) => device.adbName);
+      const sessionDevices = await this._deviceRegistry.readSessionDevices();
+      const emulatorsToShutdown = _.intersection(sessionDevices.getIds(), actualEmulators);
+      const shutdownPromises = emulatorsToShutdown.map((adbName) => this._doShutdown(adbName));
+      await Promise.all(shutdownPromises);
+    }
+
+    await this._deviceRegistry.unregisterSessionDevices();
+  }
+
+  /**
+   * @param {string} adbName
+   * @return {Promise<void>}
+   */
+  async _doShutdown(adbName) {
+    try {
       await this._emulatorLauncher.shutdown(adbName);
+    } catch (err) {
+      log.warn({ err }, `Failed to shutdown emulator ${adbName}`);
     }
   }