detox 20.11.4 → 20.12.0-smoke.0

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

@@ -7,14 +7,16 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    * @param adb { ADB }
    * @param deviceRegistry { DeviceRegistry }
    * @param freeDeviceFinder { FreeDeviceFinder }
-   * @param attachedAndroidLauncher { AttachedAndroidLauncher }
    */
-  constructor({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher }) {
+  constructor({ adb, deviceRegistry, freeDeviceFinder }) {
     super();
     this._adb = adb;
     this._deviceRegistry = deviceRegistry;
     this._freeDeviceFinder = freeDeviceFinder;
-    this._attachedAndroidLauncher = attachedAndroidLauncher;
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -23,7 +25,7 @@ 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);
   }
@@ -38,7 +40,6 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     // TODO Also disable native animations?
     await this._adb.apiLevel(adbName);
     await this._adb.unlockScreen(adbName);
-    await this._attachedAndroidLauncher.notifyLaunchCompleted(adbName);
   }
 
   /**
@@ -47,7 +48,7 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    */
   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,6 +1,7 @@
-// @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');
 
@@ -8,20 +9,45 @@ const { patchAvdSkinConfig } = require('./patchAvdSkinConfig');
 
 class EmulatorAllocDriver extends AllocationDriverBase {
   /**
-   * @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 }) {
+  constructor({
+    adb,
+    avdValidator,
+    detoxConfig,
+    deviceRegistry,
+    freeDeviceFinder,
+    freePortFinder,
+    emulatorVersionResolver,
+    emulatorLauncher
+  }) {
     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._allocationHelper = allocationHelper;
-    this._launchInfo = {};
+    this._freeDeviceFinder = freeDeviceFinder;
+    this._freePortFinder = freePortFinder;
+    this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -29,55 +55,111 @@ 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);
 
-    const allocResult = await this._allocationHelper.allocateDevice(avdName);
-    const { adbName } = allocResult;
+    let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
+    if (!adbName) {
+      const port = await this._freePortFinder.findFreePort();
+      adbName = `emulator-${port}`;
 
-    this._launchInfo[adbName] = {
-      avdName,
-      isRunning: allocResult.isRunning,
-      launchOptions: {
+      await this._emulatorLauncher.launch({
         bootArgs: deviceConfig.bootArgs,
         gpuMode: deviceConfig.gpuMode,
         headless: deviceConfig.headless,
         readonly: deviceConfig.readonly,
-        port: allocResult.placeholderPort,
-      },
-    };
+        avdName,
+        adbName,
+        port,
+      });
+    }
 
     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 postAllocate(deviceCookie) {
+  async _doPostAllocate(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 {AndroidEmulatorCookie}
+   * @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}`);
     }
   }
 

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

@@ -3,47 +3,54 @@ 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']);
+    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 +64,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,16 @@
+class FreePortFinder {
+  constructor({ min = 10000, max = 20000 } = {}) {
+    this._min = min;
+    this._max = max;
+  }
+
+  async findFreePort() {
+    const min = this._min;
+    const max = this._max;
+    let port = Math.random() * (max - min) + min;
+    port = port & 0xFFFFFFFE; // Should always be even
+    return 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,39 @@
 const { DetoxRuntimeError } = require('../../../../../errors');
 const Timer = require('../../../../../utils/Timer');
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const GenycloudEmulatorCookie = require('../../../../cookies/GenycloudEmulatorCookie');
 const AllocationDriverBase = require('../../AllocationDriverBase');
 
-class GenyAllocDriver extends AllocationDriverBase {
+const GenyRegistry = require('./GenyRegistry');
+
+const events = {
+  GENYCLOUD_TEARDOWN: { event: 'GENYCLOUD_TEARDOWN' },
+};
 
+class GenyAllocDriver extends AllocationDriverBase {
   /**
    * @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 }) {
+  constructor({
+    adb,
+    detoxSession,
+    genyRegistry = new GenyRegistry(),
+    instanceLauncher,
+    recipeQuerying,
+  }) {
     super();
 
     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 +41,74 @@ 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 };
+    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 new GenycloudEmulatorCookie(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)) {
+      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 new GenycloudEmulatorCookie(instance);
   }
 
   /**
-   * @param cookie { GenycloudEmulatorCookie }
-   * @param options { DeallocOptions }
+   * @param cookie {GenycloudEmulatorCookie}
+   * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
    * @return {Promise<void>}
    */
   async free(cookie, options = {}) {
-    const { instance } = cookie;
-
-    await this._instanceAllocationHelper.deallocateDevice(instance.uuid);
-
     if (options.shutdown) {
-      await this._instanceLauncher.shutdown(instance);
+      this._genyRegistry.removeInstance(cookie.instance);
+      await this._instanceLauncher.shutdown(cookie.instance);
+    } else {
+      this._genyRegistry.markAsFree(cookie.instance);
     }
   }
 
+  async cleanup() {
+    log.info(events.GENYCLOUD_TEARDOWN, 'Initiating Genymotion SaaS instances teardown...');
+
+    const killPromises = this._genyRegistry.getInstances().map((instance) => {
+      this._genyRegistry.markAsBusy(instance);
+      const onSuccess = () => this._genyRegistry.removeInstance(instance);
+      const onError = (error) => ({ ...instance, error });
+      return this._instanceLauncher.shutdown(instance).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 +117,25 @@ 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,51 @@
-// @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;
   }
 
+  /**
+   * @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;
+  }
+
+  /**
+   * @param {import('./services/dto/GenyInstance')} instance The freshly allocated cloud-instance.
+   */
   async shutdown(instance) {
     const { uuid } = instance;
 
-    await this._notifyPreShutdown(uuid);
     await this._instanceLifecycleService.deleteInstance(uuid);
-    await this._deviceCleanupRegistry.disposeDevice(uuid);
-    await this._notifyShutdownCompleted(uuid);
   }
 
   async _waitForInstanceBoot(instance) {
@@ -48,17 +55,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;
     });
   }