detox 20.12.0-smoke.0 → 20.12.0

package/src/devices/allocation/DeviceAllocator.js

@@ -1,5 +1,5 @@
 // @ts-nocheck
-const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
+const log = require('../../utils/logger').child({ cat: 'device' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
@@ -8,71 +8,36 @@ class DeviceAllocator {
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async init() {
-    if (typeof this._driver.init === 'function') {
-      await this._driver.init();
-    }
+    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
   }
 
   /**
    * @param deviceConfig { Object }
-   * @returns {Promise<DeviceCookie>}
+   * @return {Promise<DeviceCookie>}
    */
-  async allocate(deviceConfig) {
-    return await log.trace.complete({ data: deviceConfig, id: Math.random() }, 'allocate', async () => {
-      const cookie = await this._driver.allocate(deviceConfig);
-      log.debug({ event: undefined }, `settled on ${cookie}`);
-      return cookie;
-    });
+  allocate(deviceConfig) {
+    return this._driver.allocate(deviceConfig);
   }
 
   /**
    * @param {DeviceCookie} deviceCookie
-   * @returns {Promise<DeviceCookie>}
+   * @return {Promise<unknown>}
    */
-  async postAllocate(deviceCookie) {
-    return await log.trace.complete({ data: deviceCookie, id: Math.random() }, `post-allocate: ${deviceCookie}`, async () => {
-      const updatedCookie = typeof this._driver.postAllocate === 'function'
-        ? await this._driver.postAllocate(deviceCookie)
-        : undefined;
+  postAllocate(deviceCookie) {
+    if (typeof this._driver.postAllocate !== 'function') {
+      return Promise.resolve();
+    }
 
-      return updatedCookie || deviceCookie;
-    });
+    return this._driver.postAllocate(deviceCookie);
   }
 
   /**
    * @param cookie { DeviceCookie }
-   * @param options { Partial<DeallocOptions> }
-   * @returns {Promise<void>}
-   */
-  async free(cookie, options = {}) {
-    await log.trace.complete({ data: options, id: Math.random() }, `free: ${cookie}`, async () => {
-      await this._driver.free(cookie, options);
-    });
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async cleanup() {
-    if (typeof this._driver.cleanup === 'function') {
-      await this._driver.cleanup();
-    }
-  }
-
-  /**
-   * @returns {void}
+   * @param options { DeallocOptions }
+   * @return {Promise<void>}
    */
-  emergencyCleanup() {
-    if (typeof this._driver.emergencyCleanup === 'function') {
-      this._driver.emergencyCleanup();
-    }
+  free(cookie, options) {
+    return this._driver.free(cookie, options);
   }
 }
 

package/src/devices/allocation/drivers/AllocationDriverBase.js

@@ -7,30 +7,24 @@
  */
 
 class AllocationDriverBase {
-  async init() {}
-
   /**
    * @param deviceConfig { Object }
-   * @return {Promise<import('../../cookies/DeviceCookie')>}
+   * @return {Promise<DeviceCookie>}
    */
   async allocate(deviceConfig) {}
 
   /**
-   * @param {import('../../cookies/DeviceCookie')} deviceCookie
-   * @return {Promise<import('../../cookies/DeviceCookie') | void>}
+   * @param {DeviceCookie} deviceCookie
+   * @return {Promise<void>}
    */
   async postAllocate(deviceCookie) {}
 
   /**
-   * @param cookie { import('../../cookies/DeviceCookie') }
+   * @param cookie { DeviceCookie }
    * @param options { DeallocOptions }
    * @return {Promise<void>}
    */
   async free(cookie, options) {}
-
-  async cleanup() {}
-
-  emergencyCleanup() {}
 }
 
 module.exports = AllocationDriverBase;

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

@@ -7,16 +7,14 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    * @param adb { ADB }
    * @param deviceRegistry { DeviceRegistry }
    * @param freeDeviceFinder { FreeDeviceFinder }
+   * @param attachedAndroidLauncher { AttachedAndroidLauncher }
    */
-  constructor({ adb, deviceRegistry, freeDeviceFinder }) {
+  constructor({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher }) {
     super();
     this._adb = adb;
     this._deviceRegistry = deviceRegistry;
     this._freeDeviceFinder = freeDeviceFinder;
-  }
-
-  async init() {
-    await this._deviceRegistry.unregisterZombieDevices();
+    this._attachedAndroidLauncher = attachedAndroidLauncher;
   }
 
   /**
@@ -25,7 +23,7 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    */
   async allocate(deviceConfig) {
     const adbNamePattern = deviceConfig.device.adbName;
-    const adbName = await this._deviceRegistry.registerDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
+    const adbName = await this._deviceRegistry.allocateDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
 
     return new AttachedAndroidDeviceCookie(adbName);
   }
@@ -40,6 +38,7 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     // TODO Also disable native animations?
     await this._adb.apiLevel(adbName);
     await this._adb.unlockScreen(adbName);
+    await this._attachedAndroidLauncher.notifyLaunchCompleted(adbName);
   }
 
   /**
@@ -48,7 +47,7 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    */
   async free(cookie) {
     const { adbName } = cookie;
-    await this._deviceRegistry.unregisterDevice(adbName);
+    await this._deviceRegistry.disposeDevice(adbName);
   }
 }
 

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

@@ -0,0 +1,13 @@
+const DeviceLauncher = require('../../../../common/drivers/DeviceLauncher');
+
+class AttachedAndroidLauncher extends DeviceLauncher {
+  constructor(eventEmitter) {
+    super(eventEmitter);
+  }
+
+  notifyLaunchCompleted(adbName) {
+    return super._notifyBootEvent(adbName, 'device', false);
+  }
+}
+
+module.exports = AttachedAndroidLauncher;

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

@@ -1,7 +1,6 @@
+// @ts-nocheck
 const _ = require('lodash');
 
-const Deferred = require('../../../../../utils/Deferred');
-const log = require('../../../../../utils/logger').child({ cat: 'device,device-allocation' });
 const AndroidEmulatorCookie = require('../../../../cookies/AndroidEmulatorCookie');
 const AllocationDriverBase = require('../../AllocationDriverBase');
 
@@ -9,45 +8,20 @@ const { patchAvdSkinConfig } = require('./patchAvdSkinConfig');
 
 class EmulatorAllocDriver extends AllocationDriverBase {
   /**
-   * @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
+   * @param adb { ADB }
+   * @param avdValidator { AVDValidator }
+   * @param emulatorVersionResolver { EmulatorVersionResolver }
+   * @param emulatorLauncher { EmulatorLauncher }
+   * @param allocationHelper { EmulatorAllocationHelper }
    */
-  constructor({
-    adb,
-    avdValidator,
-    detoxConfig,
-    deviceRegistry,
-    freeDeviceFinder,
-    freePortFinder,
-    emulatorVersionResolver,
-    emulatorLauncher
-  }) {
+  constructor({ adb, avdValidator, emulatorVersionResolver, emulatorLauncher, allocationHelper }) {
     super();
-
-    /** @type {Deferred} */
-    this._deferredAllocation = Deferred.resolved(null);
-    /** @type {Promise<unknown>} */
-    this._pendingAllocation = Promise.resolve();
-
     this._adb = adb;
     this._avdValidator = avdValidator;
-    this._deviceRegistry = deviceRegistry;
     this._emulatorVersionResolver = emulatorVersionResolver;
     this._emulatorLauncher = emulatorLauncher;
-    this._freeDeviceFinder = freeDeviceFinder;
-    this._freePortFinder = freePortFinder;
-    this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
-  }
-
-  async init() {
-    await this._deviceRegistry.unregisterZombieDevices();
+    this._allocationHelper = allocationHelper;
+    this._launchInfo = {};
   }
 
   /**
@@ -55,111 +29,55 @@ class EmulatorAllocDriver extends AllocationDriverBase {
    * @returns {Promise<AndroidEmulatorCookie>}
    */
   async allocate(deviceConfig) {
-    await this._pendingAllocation.catch(() => { /* ignore previous errors */ });
-    this._deferredAllocation = new Deferred();
-    this._pendingAllocation = this._deviceRegistry.registerDevice(() => this._deferredAllocation.promise);
-
-    try {
-      return await this._doAllocate(deviceConfig);
-    } catch (e) {
-      this._deferredAllocation.reject(e);
-      throw e;
-    }
-  }
-
-  /**
-   * @param deviceConfig
-   * @returns {Promise<AndroidEmulatorCookie>}
-   */
-  async _doAllocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
 
     await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
-    let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
-    if (!adbName) {
-      const port = await this._freePortFinder.findFreePort();
-      adbName = `emulator-${port}`;
+    const allocResult = await this._allocationHelper.allocateDevice(avdName);
+    const { adbName } = allocResult;
 
-      await this._emulatorLauncher.launch({
+    this._launchInfo[adbName] = {
+      avdName,
+      isRunning: allocResult.isRunning,
+      launchOptions: {
         bootArgs: deviceConfig.bootArgs,
         gpuMode: deviceConfig.gpuMode,
         headless: deviceConfig.headless,
         readonly: deviceConfig.readonly,
-        avdName,
-        adbName,
-        port,
-      });
-    }
+        port: allocResult.placeholderPort,
+      },
+    };
 
     return new AndroidEmulatorCookie(adbName);
   }
 
-  /**
-    * @param {AndroidEmulatorCookie} deviceCookie
-    */
-  async postAllocate(deviceCookie) {
-    try {
-      await this._doPostAllocate(deviceCookie);
-      this._deferredAllocation.resolve(deviceCookie.adbName);
-    } catch (e) {
-      this._deferredAllocation.reject(e);
-      throw e;
-    }
-  }
-
   /**
    * @param {AndroidEmulatorCookie} deviceCookie
    * @returns {Promise<void>}
    */
-  async _doPostAllocate(deviceCookie) {
+  async postAllocate(deviceCookie) {
     const { adbName } = deviceCookie;
+    const { avdName, isRunning, launchOptions } = this._launchInfo[adbName];
 
-    await this._emulatorLauncher.awaitEmulatorBoot(adbName);
+    await this._emulatorLauncher.launch(avdName, adbName, isRunning, launchOptions);
     await this._adb.apiLevel(adbName);
     await this._adb.disableAndroidAnimations(adbName);
     await this._adb.unlockScreen(adbName);
   }
 
   /**
-   * @param cookie {AndroidEmulatorCookie}
-   * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
-   * @return {Promise<void>}
+   * @param cookie { AndroidEmulatorCookie }
+   * @param options { DeallocOptions }
+   * @return { Promise<void> }
    */
   async free(cookie, options = {}) {
     const { adbName } = cookie;
 
-    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();
-  }
+    await this._allocationHelper.deallocateDevice(adbName);
 
-  /**
-   * @param {string} adbName
-   * @return {Promise<void>}
-   */
-  async _doShutdown(adbName) {
-    try {
+    if (options.shutdown) {
       await this._emulatorLauncher.shutdown(adbName);
-    } catch (err) {
-      log.warn({ err }, `Failed to shutdown emulator ${adbName}`);
     }
   }
 

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

@@ -0,0 +1,72 @@
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
+const DeviceAllocationHelper  = require('../../../../common/drivers/DeviceAllocationHelper');
+
+const DetoxEmulatorsPortRange = {
+  min: 10000,
+  max: 20000
+};
+
+class AllocationResult {
+  constructor(adbName, placeholderPort) {
+    this.adbName = adbName;
+    this.placeholderPort = placeholderPort;
+  }
+
+  get isRunning() {
+    return !this.placeholderPort;
+  }
+}
+
+class EmulatorAllocationHelper extends DeviceAllocationHelper {
+  constructor(deviceRegistry, freeDeviceFinder, rand = Math.random) {
+    super(deviceRegistry, logger);
+    this._freeDeviceFinder = freeDeviceFinder;
+    this._rand = rand;
+  }
+
+  /**
+   * @param avdName
+   * @returns {Promise<AllocationResult>}
+   */
+  async allocateDevice(avdName) {
+    this._logAllocationAttempt(avdName);
+
+    const result = await this._doSynchronizedAllocation(avdName);
+    this._logAllocationResult(avdName, result.adbName);
+
+    return result;
+  }
+
+  async deallocateDevice(adbName) {
+    await this._deviceRegistry.disposeDevice(adbName);
+  }
+
+  /**
+   * @returns {Promise<AllocationResult>}
+   * @private
+   */
+  async _doSynchronizedAllocation(avdName) {
+    let placeholderPort = null;
+    let adbName = null;
+
+    await this._deviceRegistry.allocateDevice(async () => {
+      adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
+      if (!adbName) {
+        placeholderPort = this._allocateEmulatorPlaceholderPort();
+        adbName = `emulator-${placeholderPort}`;
+      }
+      return adbName;
+    });
+
+    return new AllocationResult(adbName, placeholderPort);
+  }
+
+  _allocateEmulatorPlaceholderPort() {
+    const { min, max } = DetoxEmulatorsPortRange;
+    let port = this._rand() * (max - min) + min;
+    port = port & 0xFFFFFFFE; // Should always be even
+    return port;
+  }
+}
+
+module.exports = EmulatorAllocationHelper;

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

@@ -3,54 +3,47 @@ const { DetoxRuntimeError } = require('../../../../../errors');
 const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const retry = require('../../../../../utils/retry');
 const traceMethods = require('../../../../../utils/traceMethods');
+const DeviceLauncher = require('../../../../common/drivers/DeviceLauncher');
 const { LaunchCommand } = require('../../../../common/drivers/android/emulator/exec/EmulatorExec');
 
 const { launchEmulatorProcess } = require('./launchEmulatorProcess');
 
 const isUnknownEmulatorError = (err) => (err.message || '').includes('failed with code null');
 
-class EmulatorLauncher {
-  constructor({ adb, emulatorExec }) {
+class EmulatorLauncher extends DeviceLauncher {
+  constructor({ adb, emulatorExec, eventEmitter }) {
+    super(eventEmitter);
     this._adb = adb;
     this._emulatorExec = emulatorExec;
-    traceMethods(log, this, ['awaitEmulatorBoot']);
+    traceMethods(log, this, ['_awaitEmulatorBoot']);
   }
 
   /**
-   * @param {object} options
-   * @param {string} options.avdName
-   * @param {string} options.adbName
-   * @param {number} options.port
-   * @param {string | undefined} options.bootArgs
-   * @param {string | undefined} options.gpuMode
-   * @param {boolean} options.headless
-   * @param {boolean} options.readonly
+   * @param avdName { String }
+   * @param adbName { String }
+   * @param isRunning { Boolean }
+   * @param options { Object }
+   * @param options.port { Number | undefined }
+   * @param options.bootArgs { String | undefined }
+   * @param options.gpuMode { String | undefined }
+   * @param options.headless { Boolean }
+   * @param options.readonly { Boolean }
    */
-  async launch(options) {
-    const launchCommand = new LaunchCommand(options);
-    await retry({
-      retries: 2,
-      interval: 100,
-      conditionFn: isUnknownEmulatorError,
-    }, () => launchEmulatorProcess(this._emulatorExec, this._adb, launchCommand));
-  }
-
-  /**
-   * @param {string} adbName
-   */
-  async awaitEmulatorBoot(adbName) {
-    await retry({ retries: 240, interval: 2500, shouldUnref: true }, async () => {
-      const isBootComplete = await this._adb.isBootComplete(adbName);
-
-      if (!isBootComplete) {
-        throw new DetoxRuntimeError({
-          message: `Waited for ${adbName} to complete booting for too long!`,
-        });
-      }
-    });
+  async launch(avdName, adbName, isRunning, options = { port: undefined }) {
+    if (!isRunning) {
+      const launchCommand = new LaunchCommand(avdName, options);
+      await retry({
+        retries: 2,
+        interval: 100,
+        conditionFn: isUnknownEmulatorError,
+      }, () => this._launchEmulator(avdName, launchCommand, adbName));
+    }
+    await this._awaitEmulatorBoot(adbName);
+    await this._notifyBootEvent(adbName, avdName, !isRunning);
   }
 
   async shutdown(adbName) {
+    await this._notifyPreShutdown(adbName);
     await this._adb.emuKill(adbName);
     await retry({
       retries: 5,
@@ -64,6 +57,23 @@ class EmulatorLauncher {
         });
       }
     });
+    await this._notifyShutdownCompleted(adbName);
+  }
+
+  _launchEmulator(emulatorName, launchCommand, adbName) {
+    return launchEmulatorProcess(emulatorName, this._emulatorExec, launchCommand, this._adb, adbName);
+  }
+
+  async _awaitEmulatorBoot(adbName) {
+    await retry({ retries: 240, interval: 2500, shouldUnref: true }, async () => {
+      const isBootComplete = await this._adb.isBootComplete(adbName);
+
+      if (!isBootComplete) {
+        throw new DetoxRuntimeError({
+          message: `Waited for ${adbName} to complete booting for too long!`,
+        });
+      }
+    });
   }
 }
 

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

@@ -1,4 +1,4 @@
-const FreeDeviceFinder = require('../FreeDeviceFinder');
+const FreeDeviceFinder = require('../../../../common/drivers/android/tools/FreeDeviceFinder');
 
 class FreeEmulatorFinder extends FreeDeviceFinder {
   /**

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

@@ -4,10 +4,10 @@ const _ = require('lodash');
 
 const unitLogger = require('../../../../../utils/logger').child({ cat: 'device' });
 
-function launchEmulatorProcess(emulatorExec, adb, emulatorLaunchCommand) {
+function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand, adb, adbName) {
   let childProcessOutput;
   const portName = emulatorLaunchCommand.port ? `-${emulatorLaunchCommand.port}` : '';
-  const tempLog = `./${emulatorLaunchCommand.avdName}${portName}.log`;
+  const tempLog = `./${emulatorName}${portName}.log`;
   const stdout = fs.openSync(tempLog, 'a');
   const stderr = fs.openSync(tempLog, 'a');
 
@@ -31,7 +31,7 @@ function launchEmulatorProcess(emulatorExec, adb, emulatorLaunchCommand) {
 
   log = log.child({ child_pid: childProcessPromise.childProcess.pid });
 
-  adb.waitForDevice(emulatorLaunchCommand.adbName).then(() => childProcessPromise._cpResolve());
+  adb.waitForDevice(adbName).then(() => childProcessPromise._cpResolve());
 
   return childProcessPromise.then(() => true).catch((err) => {
     detach();