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

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

@@ -1,49 +1,53 @@
 // @ts-nocheck
 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 extends DeviceLauncher {
-  constructor({ adb, emulatorExec, eventEmitter }) {
-    super(eventEmitter);
+class EmulatorLauncher {
+  constructor({ adb, emulatorExec }) {
     this._adb = adb;
     this._emulatorExec = emulatorExec;
-    traceMethods(log, this, ['_awaitEmulatorBoot']);
   }
 
   /**
-   * @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 }
+   * @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
    */
-  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 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 shutdown(adbName) {
-    await this._notifyPreShutdown(adbName);
     await this._adb.emuKill(adbName);
     await retry({
       retries: 5,
@@ -57,23 +61,6 @@ class EmulatorLauncher extends DeviceLauncher {
         });
       }
     });
-    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('../../../../common/drivers/android/tools/FreeDeviceFinder');
+const FreeDeviceFinder = require('../FreeDeviceFinder');
 
 class FreeEmulatorFinder extends FreeDeviceFinder {
   /**

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

@@ -0,0 +1,37 @@
+const net = require('net');
+
+class FreePortFinder {
+  constructor({ min = 10000, max = 20000 } = {}) {
+    this._min = min;
+    this._max = max;
+  }
+
+  async findFreePort() {
+    let port;
+
+    do {
+      const min = this._min;
+      const max = this._max;
+      port = Math.random() * (max - min) + min;
+      port = port & 0xFFFFFFFE; // Should always be even
+    } while (await this.isPortTaken(port));
+
+    return port;
+  }
+
+  async isPortTaken(port) {
+    return new Promise((resolve, reject) => {
+      const tester = net.createServer()
+        .once('error', /** @param {*} err */ (err) => {
+          /* istanbul ignore next */
+          return err && err.code === 'EADDRINUSE' ? resolve(true) : reject(err);
+        })
+        .once('listening', () => {
+          tester.once('close', () => resolve(false)).close();
+        })
+        .listen(port);
+    });
+  }
+}
+
+module.exports = FreePortFinder;

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(emulatorName, emulatorExec, emulatorLaunchCommand, adb, adbName) {
+function launchEmulatorProcess(emulatorExec, adb, emulatorLaunchCommand) {
   let childProcessOutput;
   const portName = emulatorLaunchCommand.port ? `-${emulatorLaunchCommand.port}` : '';
-  const tempLog = `./${emulatorName}${portName}.log`;
+  const tempLog = `./${emulatorLaunchCommand.avdName}${portName}.log`;
   const stdout = fs.openSync(tempLog, 'a');
   const stderr = fs.openSync(tempLog, 'a');
 
@@ -31,7 +31,7 @@ function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand
 
   log = log.child({ child_pid: childProcessPromise.childProcess.pid });
 
-  adb.waitForDevice(adbName).then(() => childProcessPromise._cpResolve());
+  adb.waitForDevice(emulatorLaunchCommand.adbName).then(() => childProcessPromise._cpResolve());
 
   return childProcessPromise.then(() => true).catch((err) => {
     detach();

package/src/devices/allocation/drivers/android/genycloud/GenyAllocDriver.js

@@ -1,25 +1,43 @@
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').GenycloudEmulatorCookie} GenycloudEmulatorCookie
+ */
+
 const { DetoxRuntimeError } = require('../../../../../errors');
 const Timer = require('../../../../../utils/Timer');
-const GenycloudEmulatorCookie = require('../../../../cookies/GenycloudEmulatorCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
+
+const GenyRegistry = require('./GenyRegistry');
 
-class GenyAllocDriver extends AllocationDriverBase {
+const events = {
+  GENYCLOUD_TEARDOWN: { event: 'GENYCLOUD_TEARDOWN' },
+};
 
+/**
+ * @implements {AllocationDriverBase}
+ */
+class GenyAllocDriver {
   /**
    * @param {object} options
    * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
-   * @param {import('./GenyRecipeQuerying')} options.recipeQuerying
-   * @param {import('./GenyInstanceAllocationHelper')} options.allocationHelper
+   * @param {DetoxInternals.SessionState} options.detoxSession
+   * @param {import('./GenyRegistry')} options.genyRegistry
    * @param {import('./GenyInstanceLauncher')} options.instanceLauncher
+   * @param {import('./GenyRecipeQuerying')} options.recipeQuerying
    */
-  constructor({ adb, recipeQuerying, allocationHelper, instanceLauncher }) {
-    super();
-
+  constructor({
+    adb,
+    detoxSession,
+    genyRegistry = new GenyRegistry(),
+    instanceLauncher,
+    recipeQuerying,
+  }) {
     this._adb = adb;
-    this._recipeQuerying = recipeQuerying;
+    this._detoxSessionId = detoxSession.id;
+    this._genyRegistry = genyRegistry;
     this._instanceLauncher = instanceLauncher;
-    this._instanceAllocationHelper = allocationHelper;
-    this._launchInfo = {};
+    this._recipeQuerying = recipeQuerying;
+    this._instanceCounter = 0;
   }
 
   /**
@@ -27,47 +45,83 @@ class GenyAllocDriver extends AllocationDriverBase {
    * @return {Promise<GenycloudEmulatorCookie>}
    */
   async allocate(deviceConfig) {
+    await new Promise((resolve) => setTimeout(resolve, 10000));
     const deviceQuery = deviceConfig.device;
     const recipe = await this._recipeQuerying.getRecipeFromQuery(deviceQuery);
     this._assertRecipe(deviceQuery, recipe);
 
-    const { instance, isNew } = await this._instanceAllocationHelper.allocateDevice(recipe);
-    this._launchInfo[instance.uuid] = { isNew };
-    return new GenycloudEmulatorCookie(instance);
+    let instance = this._genyRegistry.findFreeInstance(recipe);
+    if (!instance) {
+      const instanceName = `Detox.${this._detoxSessionId}.${this._instanceCounter++}`;
+      instance = await this._instanceLauncher.launch(recipe, instanceName);
+      this._genyRegistry.addInstance(instance, recipe);
+    }
+
+    return {
+      id: instance.uuid,
+      adbName: instance.adbName,
+      name: instance.name,
+      instance,
+    };
   }
 
   /**
    * @param {GenycloudEmulatorCookie} cookie
-   * @returns {Promise<void>}
    */
   async postAllocate(cookie) {
-    const { instance } = cookie;
-    const { isNew } = this._launchInfo[instance.uuid];
-    const readyInstance = cookie.instance = await this._instanceLauncher.launch(instance, isNew);
-
-    const { adbName } = readyInstance;
-    await Timer.run(20000, 'waiting for device to respond', async () => {
-      await this._adb.disableAndroidAnimations(adbName);
-      await this._adb.setWiFiToggle(adbName, true);
-      await this._adb.apiLevel(adbName);
-    });
+    const instance = await this._instanceLauncher.connect(cookie.instance);
+    this._genyRegistry.updateInstance(instance);
+
+    if (this._genyRegistry.pollNewInstance(instance.uuid)) {
+      const { adbName } = instance;
+
+      await Timer.run(20000, 'waiting for device to respond', async () => {
+        await this._adb.disableAndroidAnimations(adbName);
+        await this._adb.setWiFiToggle(adbName, true);
+        await this._adb.apiLevel(adbName);
+      });
+    }
+
+    return {
+      ...cookie,
+      adbName: instance.adbName,
+    };
   }
 
   /**
-   * @param cookie { GenycloudEmulatorCookie }
-   * @param options { DeallocOptions }
+   * @param cookie {Omit<GenycloudEmulatorCookie, 'instance'>}
+   * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
    * @return {Promise<void>}
    */
   async free(cookie, options = {}) {
-    const { instance } = cookie;
-
-    await this._instanceAllocationHelper.deallocateDevice(instance.uuid);
-
+    // Known issue: cookie won't have a proper 'instance' field due to (de)serialization
     if (options.shutdown) {
-      await this._instanceLauncher.shutdown(instance);
+      this._genyRegistry.removeInstance(cookie.id);
+      await this._instanceLauncher.shutdown(cookie.id);
+    } else {
+      this._genyRegistry.markAsFree(cookie.id);
     }
   }
 
+  async cleanup() {
+    log.info(events.GENYCLOUD_TEARDOWN, 'Initiating Genymotion SaaS instances teardown...');
+
+    const killPromises = this._genyRegistry.getInstances().map((instance) => {
+      this._genyRegistry.markAsBusy(instance.uuid);
+      const onSuccess = () => this._genyRegistry.removeInstance(instance.uuid);
+      const onError = (error) => ({ ...instance, error });
+      return this._instanceLauncher.shutdown(instance.uuid).then(onSuccess, onError);
+    });
+
+    const deletionLeaks = (await Promise.all(killPromises)).filter(Boolean);
+    this._reportGlobalCleanupSummary(deletionLeaks);
+  }
+
+  emergencyCleanup() {
+    const instances = this._genyRegistry.getInstances();
+    this._reportGlobalCleanupSummary(instances);
+  }
+
   _assertRecipe(deviceQuery, recipe) {
     if (!recipe) {
       throw new DetoxRuntimeError({
@@ -76,6 +130,24 @@ class GenyAllocDriver extends AllocationDriverBase {
       });
     }
   }
+
+  _reportGlobalCleanupSummary(deletionLeaks) {
+    if (deletionLeaks.length) {
+      log.warn(events.GENYCLOUD_TEARDOWN, 'WARNING! Detected a Genymotion SaaS instance leakage, for the following instances:');
+
+      deletionLeaks.forEach(({ uuid, name, error }) => {
+        log.warn(events.GENYCLOUD_TEARDOWN, [
+          `Instance ${name} (${uuid})${error ? `: ${error}` : ''}`,
+          `    Kill it by visiting https://cloud.geny.io/instance/${uuid}, or by running:`,
+          `    gmsaas instances stop ${uuid}`,
+        ].join('\n'));
+      });
+
+      log.info(events.GENYCLOUD_TEARDOWN, 'Instances teardown completed with warnings');
+    } else {
+      log.info(events.GENYCLOUD_TEARDOWN, 'Instances teardown completed successfully');
+    }
+  }
 }
 
 module.exports = GenyAllocDriver;

package/src/devices/allocation/drivers/android/genycloud/GenyInstanceLauncher.js

@@ -1,44 +1,49 @@
-// @ts-nocheck
 const DetoxRuntimeError = require('../../../../../errors/DetoxRuntimeError');
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
 const retry = require('../../../../../utils/retry');
-const DeviceLauncher = require('../../../../common/drivers/DeviceLauncher');
 
-class GenyInstanceLauncher extends DeviceLauncher {
-  constructor({ instanceLifecycleService, instanceLookupService, deviceCleanupRegistry, eventEmitter }) {
-    super(eventEmitter);
+const GenyInstance = require('./services/dto/GenyInstance');
 
+const events = {
+  CREATE_DEVICE: { event: 'CREATE_DEVICE' },
+};
+
+class GenyInstanceLauncher {
+  constructor({ genyCloudExec, instanceLifecycleService }) {
+    this._genyCloudExec = genyCloudExec;
     this._instanceLifecycleService = instanceLifecycleService;
-    this._instanceLookupService = instanceLookupService;
-    this._deviceCleanupRegistry = deviceCleanupRegistry;
   }
 
   /**
-   * Note:
-   * In the context of Genymotion-cloud (as opposed to local emulators), emulators are
-   * not launched per-se, as with local emulators. Rather, we just need to sync-up with
-   * them and connect, if needed.
-   *
-   * @param instance {GenyInstance} The freshly allocated cloud-instance.
-   * @param isNew { boolean }
+   * @param {import('./services/dto/GenyRecipe')} recipe
+   * @param {string} instanceName
    * @returns {Promise<GenyInstance>}
    */
-  async launch(instance, isNew = true) {
-    if (isNew) {
-      await this._deviceCleanupRegistry.allocateDevice(instance.uuid, { name: instance.name });
-    }
-    instance = await this._waitForInstanceBoot(instance);
-    instance = await this._adbConnectIfNeeded(instance);
-    await this._notifyBootEvent(instance.adbName, instance.recipeName, isNew);
+  async launch(recipe, instanceName) {
+    logger.debug(events.CREATE_DEVICE, `Trying to create a device based on "${recipe}"`);
+    const instance = await this._instanceLifecycleService.createInstance(recipe.uuid, instanceName);
+    const { name, uuid } = instance;
+    logger.info(events.CREATE_DEVICE, `Allocating Genymotion Cloud instance ${name} for testing. To access it via a browser, go to: https://cloud.geny.io/instance/${uuid}`);
+
     return instance;
   }
 
-  async shutdown(instance) {
-    const { uuid } = instance;
+  /**
+   * @param {GenyInstance} instance The freshly allocated cloud-instance.
+   * @returns {Promise<GenyInstance>}
+   */
+  async connect(instance) {
+    const bootedInstance = await this._waitForInstanceBoot(instance);
+    const connectedInstance = await this._adbConnectIfNeeded(bootedInstance);
+
+    return connectedInstance;
+  }
 
-    await this._notifyPreShutdown(uuid);
-    await this._instanceLifecycleService.deleteInstance(uuid);
-    await this._deviceCleanupRegistry.disposeDevice(uuid);
-    await this._notifyShutdownCompleted(uuid);
+  /**
+   * @param {string} instanceId
+   */
+  async shutdown(instanceId) {
+    await this._instanceLifecycleService.deleteInstance(instanceId);
   }
 
   async _waitForInstanceBoot(instance) {
@@ -48,17 +53,21 @@ class GenyInstanceLauncher extends DeviceLauncher {
 
     const options = {
       backoff: 'none',
-      retries: 25,
+      retries: 20,
       interval: 5000,
       initialSleep: 45000,
+      shouldUnref: true,
     };
 
     return await retry(options, async () => {
-      const _instance = await this._instanceLookupService.getInstance(instance.uuid);
-      if (!_instance.isOnline()) {
+      const { instance: _instance } = await this._genyCloudExec.getInstance(instance.uuid);
+      const anInstance = new GenyInstance(_instance);
+
+      if (!anInstance.isOnline()) {
         throw new DetoxRuntimeError(`Timeout waiting for instance ${instance.uuid} to be ready`);
       }
-      return _instance;
+
+      return anInstance;
     });
   }
 

package/src/devices/allocation/drivers/android/genycloud/GenyRegistry.js

@@ -0,0 +1,121 @@
+const { DetoxInternalError } = require('../../../../../errors');
+
+class GenyRegistry {
+  constructor() {
+    /** @type {Map<string, import('./services/dto/GenyRecipe')>} */
+    this._recipes = new Map();
+    /** @type {Map<string, import('./services/dto/GenyInstance')>} */
+    this._freeInstances = new Map();
+    /** @type {Map<string, import('./services/dto/GenyInstance')>} */
+    this._busyInstances = new Map();
+    /** @type {Set<string>} */
+    this._newInstances = new Set();
+  }
+
+  /**
+   * @returns {import('./services/dto/GenyInstance')[]}
+   */
+  getInstances() {
+    return [
+      ...this._freeInstances.values(),
+      ...this._busyInstances.values(),
+    ];
+  }
+
+  /**
+   * @param {import('./services/dto/GenyInstance')} instance
+   * @param {import('./services/dto/GenyRecipe')} recipe
+   */
+  addInstance(instance, recipe) {
+    this._recipes.set(instance.uuid, recipe);
+    this._busyInstances.set(instance.uuid, instance);
+    this._newInstances.add(instance.uuid);
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {boolean}
+   */
+  pollNewInstance(instanceId) {
+    const result = this._newInstances.has(instanceId);
+    this._newInstances.delete(instanceId);
+    return result;
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  updateInstance(instance) {
+    let found = false;
+
+    if (this._freeInstances.has(instance.uuid)) {
+      this._freeInstances.set(instance.uuid, instance);
+      found = true;
+    }
+
+    if (this._busyInstances.has(instance.uuid)) {
+       this._busyInstances.set(instance.uuid, instance);
+       found = true;
+    }
+
+    if (!found) {
+      throw new DetoxInternalError(`Cannot update an unknown instance ${instance.uuid}`);
+    }
+  }
+
+  /** @param {string} instanceId */
+  removeInstance(instanceId) {
+    this._freeInstances.delete(instanceId);
+    this._busyInstances.delete(instanceId);
+    this._newInstances.delete(instanceId);
+    this._recipes.delete(instanceId);
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {import('./services/dto/GenyInstance')}
+   */
+  markAsBusy(instanceId) {
+    if (this._busyInstances.has(instanceId)) {
+      return this._busyInstances.get(instanceId);
+    }
+
+    const instance = this._freeInstances.get(instanceId);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${instanceId} as busy`);
+    }
+
+    this._busyInstances.set(instanceId, instance);
+    this._freeInstances.delete(instanceId);
+    return instance;
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {import('./services/dto/GenyInstance')}
+   */
+  markAsFree(instanceId) {
+    if (this._freeInstances.has(instanceId)) {
+      return this._freeInstances.get(instanceId);
+    }
+
+    const instance = this._busyInstances.get(instanceId);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${instanceId} as free`);
+    }
+
+    this._busyInstances.delete(instanceId);
+    this._freeInstances.set(instanceId, instance);
+    return instance;
+  }
+
+  /** @returns {import('./services/dto/GenyInstance') | undefined} */
+  findFreeInstance(recipe) {
+    for (const instance of this._freeInstances.values()) {
+      const aRecipe = this._recipes.get(instance.uuid);
+      if (recipe.uuid === aRecipe.uuid) {
+        return this.markAsBusy(instance.uuid);
+      }
+    }
+  }
+}
+
+module.exports = GenyRegistry;

package/src/devices/allocation/drivers/android/genycloud/services/GenyInstanceLifecycleService.js

@@ -0,0 +1,24 @@
+const Instance = require('./dto/GenyInstance');
+
+class GenyInstanceLifecycleService {
+  constructor(genyCloudExec) {
+    this._genyCloudExec = genyCloudExec;
+  }
+
+  async createInstance(recipeUUID, instanceName) {
+    const result = await this._genyCloudExec.startInstance(recipeUUID, instanceName);
+    return new Instance(result.instance);
+  }
+
+  async adbConnectInstance(instanceUUID) {
+    const result = (await this._genyCloudExec.adbConnect(instanceUUID));
+    return new Instance(result.instance);
+  }
+
+  async deleteInstance(instanceUUID) {
+    const result = await this._genyCloudExec.stopInstance(instanceUUID);
+    return new Instance(result.instance);
+  }
+}
+
+module.exports = GenyInstanceLifecycleService;

package/src/devices/{common → allocation}/drivers/android/genycloud/services/GenyRecipesService.js

@@ -1,6 +1,6 @@
 const logger = require('../../../../../../utils/logger').child({ cat: 'device' });
 
-  const Recipe = require('./dto/GenyRecipe');
+const Recipe = require('./dto/GenyRecipe');
 
 class GenyRecipesService {
   constructor(genyCloudExec) {