@xenon-device-management/xenon 2.9.0 → 2.9.1

package/lib/src/device-managers/ios/IOSStreamService.js

@@ -74,7 +74,6 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const tcp_port_used_1 = __importDefault(require("tcp-port-used"));
 const InternalHttpClient_1 = require("../../InternalHttpClient");
 const logger_1 = __importDefault(require("../../logger"));
-const helpers_1 = require("../../helpers");
 const singleFlight_1 = require("../../helpers/singleFlight");
 const PortAllocator_1 = require("../../services/PortAllocator");
 const device_store_1 = require("../../data-service/device-store");
@@ -82,6 +81,7 @@ const ownDeviceRow_1 = require("../ownDeviceRow");
 const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
 const tunnelProcess_1 = require("./tunnelProcess");
 const IOSTunnels_1 = require("./IOSTunnels");
+const goIosBinary_1 = require("./goIosBinary");
 const device_service_1 = require("../../data-service/device-service");
 const manualLock_1 = require("../../services/recording/manualLock");
 const recording_store_1 = require("../../services/recording/recording-store");
@@ -119,11 +119,7 @@ let IOSStreamService = class IOSStreamService {
         this.startFlight = new singleFlight_1.SingleFlight();
         this.recoveryCooldowns = new Map(); // Track last recovery attempt time
         this.RECOVERY_COOLDOWN_MS = 30000; // 30s cooldown between recovery attempts
-        // Port-lease TTL for an active stream. Longer than the watchdog interval (1h),
-        // which refreshes it each tick, so a long-lived stream's port never expires
-        // and gets reallocated to another device; stopStream() releases it explicitly.
-        this.STREAM_PORT_TTL_MS = 90 * 60 * 1000; // 1.5h
-        this.goIOSPath = this.getGoIOSPath();
+        this.goIOSPath = (0, goIosBinary_1.goIosBinaryPath)();
         this.startWatchdog();
     }
     /**
@@ -143,8 +139,8 @@ let IOSStreamService = class IOSStreamService {
                     // its ports to another device mid-stream (TTL > this 1h interval).
                     try {
                         const portAllocator = typedi_2.Container.get(PortAllocator_1.PortAllocator);
-                        yield portAllocator.touch(session.wdaPort, this.STREAM_PORT_TTL_MS);
-                        yield portAllocator.touch(session.mjpegPort, this.STREAM_PORT_TTL_MS);
+                        yield portAllocator.touch(session.wdaPort, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS);
+                        yield portAllocator.touch(session.mjpegPort, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS);
                         yield this.tunnels().touch(udid);
                     }
                     catch (_a) {
@@ -223,10 +219,6 @@ let IOSStreamService = class IOSStreamService {
             }
         });
     }
-    getGoIOSPath() {
-        const goIOSDir = (0, helpers_1.cachePath)('goIOS');
-        return path_1.default.join(goIOSDir, 'ios');
-    }
     /**
      * Check if go-ios binary exists
      */
@@ -594,7 +586,7 @@ let IOSStreamService = class IOSStreamService {
                     // guarantee a non-colliding port; the lease is refreshed by the watchdog
                     // and released in stopStream().
                     const portAllocator = typedi_2.Container.get(PortAllocator_1.PortAllocator);
-                    const ttl = { ttlMs: this.STREAM_PORT_TTL_MS };
+                    const ttl = { ttlMs: IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS };
                     // Principal Discovery: attach to the WDA an Appium session runs on this
                     // device instead of launching a second one over it. The one exception
                     // to the rule above: that session's forwarder listens on the Device
@@ -1101,7 +1093,9 @@ let IOSStreamService = class IOSStreamService {
      * server owns no legitimate tunnel — i.e. on fresh boot (orphans from a
      * previous run, or a hard-killed / crashed process whose graceful cleanup
      * never ran) or during full shutdown. This is the catch-all that stops the
-     * self-forking go-ios agent storm from surviving across restarts.
+     * self-forking go-ios agent storm from surviving across restarts. It kills
+     * this process's own go-ios calls too, so boot runs it before device
+     * detection starts (ServerManager.reapLeftoverGoIos).
      */
     reapOrphanTunnels() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/src/device-managers/ios/IOSTunnels.js

@@ -18,7 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IOSTunnels = exports.TUNNEL_BORROW_IDLE_MS = exports.TUNNEL_CHECK_MS = exports.TUNNEL_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
+exports.IOSTunnels = exports.TUNNEL_BORROW_IDLE_MS = exports.TUNNEL_CHECK_MS = exports.IOS_STREAM_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
 exports.iosVersionOf = iosVersionOf;
 exports.goIosReason = goIosReason;
 /**
@@ -48,25 +48,26 @@ exports.goIosReason = goIosReason;
 const typedi_1 = require("typedi");
 const child_process_1 = require("child_process");
 const http_1 = __importDefault(require("http"));
-const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const logger_1 = __importDefault(require("../../logger"));
-const helpers_1 = require("../../helpers");
 const PortAllocator_1 = require("../../services/PortAllocator");
 const ProcessRegistry_1 = require("../../services/ProcessRegistry");
 const ResourceIsolationService_1 = require("../../services/ResourceIsolationService");
 const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
+const goIosBinary_1 = require("./goIosBinary");
 const tunnelProcess_1 = require("./tunnelProcess");
 const execPromise = (0, util_1.promisify)(child_process_1.exec);
 /** How long a new tunnel has to answer for its phone before the start goes on without it. */
 exports.TUNNEL_READY_TIMEOUT_MS = 20000;
 exports.TUNNEL_READY_POLL_MS = 500;
 /**
- * A tunnel's port lease: the same as the stream's own ports
- * (IOSStreamService's STREAM_PORT_TTL_MS). The stream watchdog refreshes both
- * every hour, the tunnel's through {@link IOSTunnels.touch}.
+ * How long an iPhone stream's port leases last: its WDA and MJPEG ports
+ * (IOSStreamService) and its tunnel's pair. Longer than the stream watchdog's
+ * hourly tick, which refreshes them (the tunnel's through
+ * {@link IOSTunnels.touch}), so a long stream never loses its ports to another
+ * phone. Stopping the stream or the tunnel releases them.
  */
-exports.TUNNEL_LEASE_TTL_MS = 90 * 60 * 1000;
+exports.IOS_STREAM_LEASE_TTL_MS = 90 * 60 * 1000;
 /** How often running tunnels are checked for a phone that went away. */
 exports.TUNNEL_CHECK_MS = 5000;
 /**
@@ -126,7 +127,7 @@ let IOSTunnels = class IOSTunnels {
         this.tunnels = new Map();
         this.checking = false;
         this.versionCache = new Map();
-        this.goIOSPath = path_1.default.join((0, helpers_1.cachePath)('goIOS'), 'ios');
+        this.goIOSPath = (0, goIosBinary_1.goIosBinaryPath)();
     }
     /**
      * The phone's tunnel-info port for its stream, starting its tunnel if it
@@ -169,7 +170,7 @@ let IOSTunnels = class IOSTunnels {
             if (version === null || version < 17)
                 return null;
             const port = yield this.allocator().acquirePair('tunnel', udid, {
-                ttlMs: exports.TUNNEL_LEASE_TTL_MS,
+                ttlMs: exports.IOS_STREAM_LEASE_TTL_MS,
             });
             let proc;
             try {
@@ -209,7 +210,9 @@ let IOSTunnels = class IOSTunnels {
                 void this.releasePair(port, udid);
             };
             proc.once('exit', ended);
-            proc.once('error', (err) => {
+            // `on`, not `once`: a second 'error' with no listener left would be
+            // thrown, and take the server down. ended() only acts once.
+            proc.on('error', (err) => {
                 this.log.warn(`[${udid}] go-ios tunnel failed: ${err.message}`);
                 ended();
             });
@@ -230,10 +233,16 @@ let IOSTunnels = class IOSTunnels {
     waitUntilReady(udid, tunnel) {
         return __awaiter(this, void 0, void 0, function* () {
             const { port, process: proc } = tunnel;
-            const polls = exports.TUNNEL_READY_TIMEOUT_MS / exports.TUNNEL_READY_POLL_MS;
-            for (let poll = 0; poll <= polls; poll++) {
-                if (poll > 0)
-                    yield this.sleep(exports.TUNNEL_READY_POLL_MS);
+            // By the clock, not a count of checks: each check can take up to its own
+            // 1 s timeout, which stretched 41 checks to about a minute.
+            const deadline = this.now() + exports.TUNNEL_READY_TIMEOUT_MS;
+            for (let first = true;; first = false) {
+                if (!first) {
+                    const left = deadline - this.now();
+                    if (left <= 0)
+                        break;
+                    yield this.sleep(Math.min(exports.TUNNEL_READY_POLL_MS, left));
+                }
                 if (this.tunnels.get(udid) !== tunnel) {
                     throw new Error(`The go-ios tunnel for ${udid} exited before it was ready (exit code ${proc.exitCode})` +
                         (tunnel.reason ? `: ${tunnel.reason}` : ''));
@@ -376,8 +385,8 @@ let IOSTunnels = class IOSTunnels {
             if (!tunnel)
                 return;
             const allocator = this.allocator();
-            yield allocator.touch(tunnel.port, exports.TUNNEL_LEASE_TTL_MS);
-            yield allocator.touch(tunnel.port + 1, exports.TUNNEL_LEASE_TTL_MS);
+            yield allocator.touch(tunnel.port, exports.IOS_STREAM_LEASE_TTL_MS);
+            yield allocator.touch(tunnel.port + 1, exports.IOS_STREAM_LEASE_TTL_MS);
         });
     }
     releasePair(port, udid) {

package/lib/src/device-managers/ios/goIosBinary.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goIosBinaryPath = goIosBinaryPath;
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("../../helpers");
+/**
+ * The go-ios binary Xenon vendors, where src/scripts/install-go-ios.ts puts
+ * it. Every go-ios command Xenon runs uses this one path: the boot and
+ * shutdown reaps find go-ios processes by it.
+ */
+function goIosBinaryPath() {
+    return path_1.default.join((0, helpers_1.cachePath)('goIOS'), 'ios');
+}

package/lib/src/plugin.js

@@ -157,16 +157,8 @@ class XenonPlugin extends base_plugin_1.default {
             catch (err) {
                 logger_1.default.warn(`[plugin] RecordingOrchestrator.recoverOnBoot failed: ${err === null || err === void 0 ? void 0 : err.message}`);
             }
-            // Reap orphan go-ios tunnels left by a previous run or a hard-killed/crashed
-            // process. A fresh server owns no tunnels, so any surviving go-ios agents are
-            // orphans that would otherwise keep self-forking into a runaway process storm.
-            try {
-                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/ios/IOSStreamService')));
-                yield typedi_1.Container.get(IOSStreamService).reapOrphanTunnels();
-            }
-            catch (err) {
-                logger_1.default.warn(`[plugin] IOSStreamService.reapOrphanTunnels failed: ${err === null || err === void 0 ? void 0 : err.message}`);
-            }
+            // Leftover go-ios is reaped by ServerManager.updateServer, before device
+            // detection starts: here, the reap killed detection's own go-ios calls.
         });
     }
     createSession(next, driver, jwpDesCaps, jwpReqCaps, caps) {

package/lib/src/services/PortAllocator.js

@@ -291,9 +291,16 @@ let PortAllocator = class PortAllocator {
                 .catch(() => undefined);
         });
     }
+    /**
+     * Delete a phone's leases when a session on it ends. Not its go-ios
+     * tunnel's pair: the phone's stream, and so its tunnel, can outlive the
+     * session, and IOSTunnels gives the pair back when the tunnel stops.
+     */
     releaseForUdid(udid) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield prisma_1.prisma.portLease.deleteMany({ where: { leasedToUdid: udid } });
+            yield prisma_1.prisma.portLease.deleteMany({
+                where: { leasedToUdid: udid, purpose: { not: 'tunnel' } },
+            });
         });
     }
     purgeExpired() {

package/lib/src/services/ServerManager.js

@@ -130,6 +130,8 @@ let ServerManager = ServerManager_1 = class ServerManager {
             }
             yield this.syncDatabaseAndAIConfig(pluginArgs);
             yield this.initializeCoreSubsystems(pluginArgs, cliArgs.port);
+            // Before anything below starts go-ios: the reap would kill it too.
+            yield this.reapLeftoverGoIos();
             this.registerRoutes(expressApp, httpServer, cliArgs, pluginArgs);
             yield this.bootEmulators(pluginArgs);
             this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
@@ -364,6 +366,26 @@ let ServerManager = ServerManager_1 = class ServerManager {
             typedi_1.Container.set(ARTIFACT_STORE, new FsArtifactStore(config_1.config.recordingsAssetsPath));
         });
     }
+    /**
+     * Reap what a previous run (or a hard-killed one) left of go-ios: tunnels
+     * whose agents keep self-forking, WebDriverAgent runners and log streams.
+     * It kills every process running the go-ios binary, this process's own
+     * included, so it runs before anything here starts one. It used to run at
+     * the end of boot, after device detection had started, and killed the
+     * `ios info` call detection makes in the background for each plugged-in
+     * iPhone ("Failed to fetch IP via go-ios" at every boot).
+     */
+    reapLeftoverGoIos() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('../device-managers/ios/IOSStreamService')));
+                yield typedi_1.Container.get(IOSStreamService).reapOrphanTunnels();
+            }
+            catch (err) {
+                this.logger.warn(`Reaping go-ios left by a previous run failed: ${err === null || err === void 0 ? void 0 : err.message}`);
+            }
+        });
+    }
     registerRoutes(expressApp, httpServer, cliArgs, pluginArgs) {
         expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs));
         // The session gateway goes in front of Appium's routes: Xenon's own

package/lib/test/unit/PortAllocator.test.js

@@ -93,7 +93,7 @@ describe('PortAllocator', () => {
         (0, chai_1.expect)(deleteStub.calledWith({ where: { port: 9100 } })).to.be.true;
         (0, chai_1.expect)(createStub.called, 'should allocate a replacement lease').to.be.true;
     }));
-    it('releaseForUdid deletes all leases for that UDID', () => __awaiter(void 0, void 0, void 0, function* () {
+    it("releaseForUdid deletes that UDID's leases", () => __awaiter(void 0, void 0, void 0, function* () {
         deleteManyStub.resolves({ count: 2 });
         const allocator = makeAllocator({ wda: [8100, 8102] });
         yield allocator.releaseForUdid('udid-1');

package/lib/test/unit/boot-go-ios-reap.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const RecordingOrchestrator_1 = require("../../src/services/recording/RecordingOrchestrator");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * At boot Xenon reaps what a previous run left of go-ios (tunnels whose agents
+ * self-fork, WebDriverAgent runners, log streams). The reap kills every process
+ * running the vendored go-ios binary, so it also kills this process's own
+ * go-ios calls. It used to run last, after device detection had started:
+ * detection asks `ios info` about each plugged-in iPhone in the background,
+ * and those calls were killed ("Failed to fetch IP via go-ios" for every
+ * iPhone, at every boot). It now runs as soon as the database is ready,
+ * before this process starts go-ios at all.
+ */
+describe('reaping go-ios left by a previous run, at boot', () => {
+    let statics;
+    beforeEach(() => {
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    it('runs once the database is ready, before routes and device detection start', () => __awaiter(void 0, void 0, void 0, function* () {
+        const steps = [];
+        const step = (name) => () => {
+            steps.push(name);
+            return Promise.resolve();
+        };
+        const boot = ServerManager_1.ServerManager.prototype;
+        sinon_1.default.stub(boot, 'resolvePluginArgs').resolves({});
+        sinon_1.default.stub(logger_1.default, 'banner');
+        sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+        sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').callsFake(step('database config'));
+        sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(step('database and migrations'));
+        sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').callsFake(step('reap'));
+        // Everything that starts go-ios (device managers, detection, the hub's and
+        // node's discovery crons) comes after the routes; stop there.
+        sinon_1.default.stub(boot, 'registerRoutes').callsFake(() => {
+            steps.push('routes');
+            throw new Error('boot stopped by the test');
+        });
+        const booting = typedi_1.Container.get(ServerManager_1.ServerManager).updateServer({}, null, { port: 4723 });
+        yield booting.then(() => chai_1.expect.fail('the stubbed routes step should have stopped the boot'), (err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+        (0, chai_1.expect)(steps).to.deep.equal(['database config', 'database and migrations', 'reap', 'routes']);
+    }));
+    it('is not left to the plugin, which boots after detection has started', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(ServerManager_1.ServerManager.prototype, 'updateServer').resolves();
+        sinon_1.default.stub(RecordingOrchestrator_1.RecordingOrchestrator.prototype, 'recoverOnBoot').resolves();
+        const reap = sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').resolves();
+        yield plugin_1.XenonPlugin.updateServer({}, null, {});
+        (0, chai_1.expect)(reap.called).to.equal(false);
+    }));
+});

package/lib/test/unit/ios-stream-appium-tunnel.spec.js

@@ -105,7 +105,6 @@ function iosService() {
     svc.startFlight = new singleFlight_1.SingleFlight();
     svc.recoveryCooldowns = new Map();
     svc.RECOVERY_COOLDOWN_MS = 30000;
-    svc.STREAM_PORT_TTL_MS = 90 * 60 * 1000;
     svc.goIOSPath = '/nonexistent/go-ios';
     return svc;
 }

package/lib/test/unit/ios-stream-port-leases.spec.js

@@ -89,7 +89,6 @@ function iosService() {
     svc.startFlight = new singleFlight_1.SingleFlight();
     svc.recoveryCooldowns = new Map();
     svc.RECOVERY_COOLDOWN_MS = 30000;
-    svc.STREAM_PORT_TTL_MS = 90 * 60 * 1000;
     svc.goIOSPath = '/nonexistent/go-ios';
     return svc;
 }

package/lib/test/unit/ios-tunnels.spec.js

@@ -114,6 +114,7 @@ class TestTunnels extends IOSTunnels_1.IOSTunnels {
     sleep(ms) {
         return __awaiter(this, void 0, void 0, function* () {
             this.sleeps.push(ms);
+            this.clock += ms;
         });
     }
     killGroup(pid) {
@@ -150,7 +151,9 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
     it("leases a pair and starts the phone's own agent on it", () => __awaiter(void 0, void 0, void 0, function* () {
         const port = yield t.ensure(PHONE_A);
         (0, chai_1.expect)(port).to.equal(12100);
-        (0, chai_1.expect)(t.ports.acquirePair.calledOnceWithExactly('tunnel', PHONE_A, { ttlMs: IOSTunnels_1.TUNNEL_LEASE_TTL_MS })).to.equal(true);
+        (0, chai_1.expect)(t.ports.acquirePair.calledOnceWithExactly('tunnel', PHONE_A, {
+            ttlMs: IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS,
+        })).to.equal(true);
         (0, chai_1.expect)(t.spawned.map((s) => s.args)).to.deep.equal([
             ['tunnel', 'start', '--udid', PHONE_A, '--userspace', '--tunnel-info-port', '12100'],
         ]);
@@ -176,6 +179,25 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
         (0, chai_1.expect)(t.sleeps.reduce((a, b) => a + b, 0)).to.equal(IOSTunnels_1.TUNNEL_READY_TIMEOUT_MS);
         (0, chai_1.expect)(t.portFor(PHONE_A), 'still tracked').to.equal(12100);
     }));
+    it('goes on at the 20 s deadline when each check is slow to answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const started = t.clock;
+        t.answers = () => {
+            t.clock += 1000; // a check that runs into its 1 s timeout
+            return { state: 'unknown' };
+        };
+        (0, chai_1.expect)(yield t.ensure(PHONE_A)).to.equal(12100);
+        // At most the one check that was under way at the deadline.
+        (0, chai_1.expect)(t.clock - started).to.be.at.most(IOSTunnels_1.TUNNEL_READY_TIMEOUT_MS + 1000);
+    }));
+    it('outlives a second error from the tunnel process, and gives its ports back once', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield t.ensure(PHONE_A);
+        const proc = t.spawned[0].proc;
+        proc.emit('error', new Error('spawn EACCES'));
+        (0, chai_1.expect)(() => proc.emit('error', new Error('kill ESRCH'))).not.to.throw();
+        yield settle();
+        (0, chai_1.expect)(t.portFor(PHONE_A)).to.equal(undefined);
+        (0, chai_1.expect)(t.ports.release.callCount, 'P and P + 1, once each').to.equal(2);
+    }));
     it('fails the start when the tunnel exits before it is ready, and gives its ports back', () => __awaiter(void 0, void 0, void 0, function* () {
         t.answers = () => {
             t.spawned[0].proc.exit(1);
@@ -270,8 +292,8 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
         yield t.touch(PHONE_A);
         yield t.touch(PHONE_B); // no tunnel: nothing to touch
         (0, chai_1.expect)(t.ports.touch.args).to.deep.equal([
-            [12100, IOSTunnels_1.TUNNEL_LEASE_TTL_MS],
-            [12101, IOSTunnels_1.TUNNEL_LEASE_TTL_MS],
+            [12100, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS],
+            [12101, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS],
         ]);
     }));
 });

package/lib/test/unit/port-allocator-pairs.spec.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
 const net_1 = __importDefault(require("net"));
+const prisma_1 = require("../../src/prisma");
 const PortAllocator_1 = require("../../src/services/PortAllocator");
 const scratch_port_leases_1 = require("../helpers/scratch-port-leases");
 /**
@@ -73,6 +74,31 @@ describe('PortAllocator.acquirePair (go-ios tunnel ports)', () => {
         (0, chai_1.expect)(yield a.acquirePair('tunnel', 'phone-b')).to.equal(b + 2);
         (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([b + 2, b + 3]);
     }));
+    it('gives two phones asking at once different pairs', () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const a = allocator([b, b + 9]);
+        const [first, second] = yield Promise.all([
+            a.acquirePair('tunnel', 'phone-a'),
+            a.acquirePair('tunnel', 'phone-b'),
+        ]);
+        (0, chai_1.expect)(first).to.not.equal(second);
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([first, first + 1]);
+        (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([second, second + 1]);
+    }));
+    it('gives the first port back when the second is taken mid-pair, and moves on', () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const create = prisma_1.prisma.portLease.create;
+        create.callsFake((args) => __awaiter(void 0, void 0, void 0, function* () {
+            if (args.data.port === b + 1 && args.data.leasedToUdid === 'phone-a') {
+                // Another phone takes P + 1 after the free ports were read.
+                yield leaseTo('phone-b', b + 1, 'tunnel');
+            }
+            return scratch.db.portLease.create(args);
+        }));
+        (0, chai_1.expect)(yield allocator([b, b + 5]).acquirePair('tunnel', 'phone-a')).to.equal(b + 2);
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([b + 2, b + 3]);
+        (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([b + 1]);
+    }));
     it('skips a pair whose second port is leased, whatever for, and keeps none of it', () => __awaiter(void 0, void 0, void 0, function* () {
         const b = scratch.base;
         yield leaseTo('another-device', b + 1, 'wda');
@@ -99,6 +125,14 @@ describe('PortAllocator.acquirePair (go-ios tunnel ports)', () => {
         (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/tunnel/);
         (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([]);
     }));
+    it("releaseForUdid, when a session ends, leaves the phone's tunnel pair to its tunnel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const a = allocator([b, b + 5]);
+        yield a.acquirePair('tunnel', 'phone-a');
+        yield leaseTo('phone-a', b + 50, 'wda');
+        yield a.releaseForUdid('phone-a');
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([b, b + 1]);
+    }));
     it("releasePurpose deletes only that purpose's leases", () => __awaiter(void 0, void 0, void 0, function* () {
         const b = scratch.base;
         const a = allocator([b, b + 5]);