detox 20.11.5-smoke.0 → 20.12.0-smoke.1

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) {

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

@@ -59,7 +59,12 @@ class GenyInstance {
   }
 
   toString() {
-    return `GenyCloud:${this.name} (${this.uuid} ${this.adbName})`;
+    const description = [
+      this.uuid,
+      this.adbName
+    ].filter(Boolean).join('/');
+
+    return `${this.name} (${description})`;
   }
 }