@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/src/services/network/PhoneNetworkRestore.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+exports.PhoneNetworkRestore = exports.LEFTOVER_MAX_AGE_MS = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const PortAllocator_1 = require("../PortAllocator");
+const AndroidProxyAdapter_1 = require("../interceptor/AndroidProxyAdapter");
+const adbForPhone_1 = require("./adbForPhone");
+const AndroidRadios_1 = require("./AndroidRadios");
+const PhoneNetworkLedger_1 = require("./PhoneNetworkLedger");
+const phoneNetworkLock_1 = require("./phoneNetworkLock");
+const xenonProxy_1 = require("./xenonProxy");
+/** A record that still can't be undone after this long is dropped: the phone is gone. */
+exports.LEFTOVER_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Puts a phone's network back after a session that changed it: a network
+ * profile (`Offline` turns Wi-Fi and mobile data off) or the network
+ * interceptor (the phone's global HTTP proxy). Both change the whole phone,
+ * not one app, so a phone left that way has no network for the next test.
+ *
+ * Every way a session ends on this server calls restoreSession, before the
+ * phone is released so the next session can't have its own changes undone:
+ * the test's delete (SessionLifecycleService.deleteSession), Appium's own end
+ * of a session (its new-command timeout, a crashed driver: the plugin's
+ * onUnexpectedShutdown), Xenon's idle release (releaseBlockedDevices), a
+ * stale heartbeat (OrphanSweeper) and a graceful shutdown. It is keyed by the
+ * session id alone, so it works for sessions Xenon keeps no other record of
+ * (SESSION_MANAGER holds a local session only with the dashboard or video on).
+ *
+ * Once per session: a second ending finds the first one's work in progress
+ * and waits for it, and a later one finds nothing to do.
+ *
+ * What a crash forgets, PhoneNetworkLedger remembers. restoreLeftovers undoes
+ * it at this server's next start (cleanUpAtBoot) and before the phone's next
+ * session here (a phone that was unplugged when its session ended).
+ */
+let PhoneNetworkRestore = class PhoneNetworkRestore {
+    constructor() {
+        this.logger = logger_1.default.scope('PhoneNetwork');
+        this.inflight = new Map();
+        this.radios = new AndroidRadios_1.AndroidRadios(adbForPhone_1.adbForPhone);
+        this.proxies = new AndroidProxyAdapter_1.AndroidProxyAdapter(adbForPhone_1.adbForPhone);
+    }
+    /** Undoes what the session changed on its phone's network, once. Never throws. */
+    restoreSession(sessionId, why) {
+        if (!sessionId)
+            return Promise.resolve();
+        const running = this.inflight.get(sessionId);
+        if (running)
+            return running;
+        const work = this.undoSession(sessionId, why).finally(() => this.inflight.delete(sessionId));
+        this.inflight.set(sessionId, work);
+        return work;
+    }
+    /** Every session this server still has network changes for (shutdown). Never throws. */
+    restoreAll(why) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { net, icp } = yield this.services();
+            const ids = new Set([...net.sessionIds(), ...icp.sessionIds(), ...this.inflight.keys()]);
+            yield Promise.all([...ids].map((id) => this.restoreSession(id, why)));
+        });
+    }
+    /**
+     * Undoes what the ledger says ended sessions left on their phones: one
+     * phone's (`udid`) or every phone's. Skips sessions this server still runs.
+     * A record that can't be undone now (the phone isn't connected) is kept for
+     * next time, for a week. Returns how many records were fully undone.
+     * Never throws.
+     */
+    restoreLeftovers() {
+        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            var _a;
+            let done = 0;
+            try {
+                const ledger = typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger);
+                const entries = (yield ledger.list()).filter((e) => !opts.udid || e.udid === opts.udid);
+                for (const entry of entries) {
+                    if (yield this.isLive(entry.sessionId))
+                        continue;
+                    if (yield this.undoLeftover(entry.sessionId, entry.udid))
+                        done++;
+                }
+            }
+            catch (err) {
+                this.logger.warn(`Could not put back what earlier sessions left: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            return done;
+        });
+    }
+    /**
+     * At this server's start: first what the ledger holds, then each of this
+     * server's Android phones (`udids`) whose proxy is a capture an earlier run
+     * left (this machine, one of this server's capture ports, nothing answering
+     * there; such a phone has no network). That second check also catches a
+     * crash from before the ledger existed. A proxy that points anywhere else,
+     * or at a capture that is running, is left alone. Never throws.
+     */
+    cleanUpAtBoot(udids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.restoreLeftovers({});
+            let range;
+            try {
+                range = typedi_1.Container.get(PortAllocator_1.PortAllocator).rangeOf('proxy');
+            }
+            catch (err) {
+                this.logger.warn(`Could not check the phones' proxies: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                return;
+            }
+            for (const udid of udids)
+                yield this.clearDeadCaptureProxy(udid, range);
+        });
+    }
+    undoSession(sessionId, why) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            let services;
+            try {
+                services = yield this.services();
+            }
+            catch (err) {
+                this.logger.warn(`Could not put back the network of session ${sessionId}: ${err === null || err === void 0 ? void 0 : err.message}`);
+                return;
+            }
+            const { net, icp } = services;
+            const profile = net.has(sessionId);
+            const capture = icp.isActive(sessionId);
+            if (!profile && !capture)
+                return;
+            this.logger.info(`Putting back the phone network of session ${sessionId} (${why})`);
+            if (profile) {
+                try {
+                    yield net.reset(sessionId);
+                }
+                catch (err) {
+                    this.logger.warn(`Network profile reset failed for ${sessionId}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                }
+            }
+            if (capture) {
+                try {
+                    yield icp.stop(sessionId);
+                }
+                catch (err) {
+                    this.logger.warn(`Interceptor stop failed for ${sessionId}: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                }
+            }
+        });
+    }
+    isLive(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.inflight.has(sessionId))
+                return true;
+            const { net, icp } = yield this.services();
+            return net.has(sessionId) || icp.isActive(sessionId);
+        });
+    }
+    /** One record, under the phone's lock, read again there: another clean-up may have done it. */
+    undoLeftover(sessionId, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ledger = typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger);
+            return yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                const change = yield ledger.get(sessionId);
+                if (!change)
+                    return false;
+                let undone = true;
+                if (change.offline && !(yield this.undoOffline(change, change.offline)))
+                    undone = false;
+                if (change.proxy && !(yield this.undoProxy(change, change.proxy)))
+                    undone = false;
+                if (!undone && Date.now() - change.at > exports.LEFTOVER_MAX_AGE_MS) {
+                    yield ledger.forget(sessionId);
+                    this.logger.warn(`Gave up putting back the network of ${udid} (session ${sessionId}): it has not ` +
+                        'been reachable for a week.');
+                }
+                return undone;
+            }));
+        });
+    }
+    undoOffline(change, prior) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { udid, sessionId } = change;
+            const which = AndroidRadios_1.AndroidRadios.toRestore(prior);
+            try {
+                yield this.radios.turnOn(udid, which);
+                yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).settle(sessionId, 'offline');
+                const what = [which.wifi && 'Wi-Fi', which.data && 'mobile data']
+                    .filter(Boolean)
+                    .join(' and ');
+                if (what) {
+                    this.logger.warn(`Turned ${what} back on on ${udid}: session ${sessionId} took the phone offline and ` +
+                        'ended without putting it back.');
+                }
+                return true;
+            }
+            catch (err) {
+                this.logger.warn(`Could not turn the network back on on ${udid} (session ${sessionId}): ` +
+                    `${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. Trying again at its next session and at the next start.`);
+                return false;
+            }
+        });
+    }
+    undoProxy(change, proxy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { udid, sessionId } = change;
+            try {
+                const now = (yield this.proxies.readProxy(udid)).trim();
+                if (now === proxy.set) {
+                    yield this.proxies.restoreProxy(udid, proxy.previous);
+                    if (proxy.reversePort)
+                        yield this.removeReverse(udid, proxy.reversePort);
+                    this.logger.warn(`Put back the proxy of ${udid} (${(_a = proxy.previous) !== null && _a !== void 0 ? _a : 'none'}): session ${sessionId} ` +
+                        `pointed it at ${proxy.set} and ended without putting it back.`);
+                }
+                else {
+                    this.logger.info(`Left the proxy of ${udid} as it is (${now || 'none'}): it changed after session ` +
+                        `${sessionId} set ${proxy.set}.`);
+                }
+                yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).settle(sessionId, 'proxy');
+                return true;
+            }
+            catch (err) {
+                this.logger.warn(`Could not put back the proxy of ${udid} (session ${sessionId}): ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}. ` +
+                    'Trying again at its next session and at the next start.');
+                return false;
+            }
+        });
+    }
+    clearDeadCaptureProxy(udid, range) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                    const now = yield this.proxies.readProxy(udid);
+                    const proxy = (0, xenonProxy_1.parseProxySetting)(now);
+                    if (!proxy || !(yield (0, xenonProxy_1.isDeadCaptureProxy)(now, range)))
+                        return;
+                    yield this.proxies.clearProxy(udid);
+                    if (proxy.host === '127.0.0.1' || proxy.host.toLowerCase() === 'localhost') {
+                        yield this.removeReverse(udid, proxy.port);
+                    }
+                    this.logger.warn(`Cleared the proxy of ${udid} (${now.trim()}): it pointed at this machine's network ` +
+                        `capture port ${proxy.port}, where nothing answers, so the phone had no network.`);
+                }));
+            }
+            catch (err) {
+                this.logger.debug(`Could not check the proxy of ${udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        });
+    }
+    removeReverse(udid, port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.proxies.removeReverse(udid, port);
+            }
+            catch (_a) {
+                // Gone with the adb server or the connection: nothing to remove.
+            }
+        });
+    }
+    /** Imported lazily: InterceptorService pulls in the socket server. */
+    services() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ NetworkConditioningService }, { InterceptorService }] = yield Promise.all([
+                Promise.resolve().then(() => __importStar(require('../NetworkConditioningService'))),
+                Promise.resolve().then(() => __importStar(require('../InterceptorService'))),
+            ]);
+            return {
+                net: typedi_1.Container.get(NetworkConditioningService),
+                icp: typedi_1.Container.get(InterceptorService),
+            };
+        });
+    }
+};
+exports.PhoneNetworkRestore = PhoneNetworkRestore;
+exports.PhoneNetworkRestore = PhoneNetworkRestore = __decorate([
+    (0, typedi_1.Service)()
+], PhoneNetworkRestore);

package/lib/src/services/network/adbForPhone.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adbForPhone = void 0;
+const typedi_1 = require("typedi");
+/**
+ * A phone's adb as the rest of Xenon reaches it: appium-adb's, which finds the
+ * binary through ANDROID_HOME / ANDROID_SDK_ROOT and runs it without a shell,
+ * and which talks to a remote adb server for a phone that has one. Never a
+ * bare `adb`: a server started without the SDK on its PATH (Xenon Control, a
+ * service) has none.
+ *
+ * Imported lazily: AndroidDeviceManager pulls in most of the device layer.
+ */
+const adbForPhone = (udid) => __awaiter(void 0, void 0, void 0, function* () {
+    const { default: AndroidDeviceManager } = yield Promise.resolve().then(() => __importStar(require('../../device-managers/AndroidDeviceManager')));
+    return yield typedi_1.Container.get(AndroidDeviceManager).getAdbForDevice(udid);
+});
+exports.adbForPhone = adbForPhone;

package/lib/src/services/network/phoneNetworkLock.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPhoneNetworkLock = withPhoneNetworkLock;
+const async_lock_1 = __importDefault(require("async-lock"));
+const lock = new async_lock_1.default({ maxPending: 10000 });
+/**
+ * One change at a time to a phone's network settings (Wi-Fi, mobile data, the
+ * global proxy): a session's start reading and changing them, its end putting
+ * them back, and a clean-up of what an earlier run left. Without it, a
+ * clean-up that read a dead proxy could clear the one a new session had just
+ * set, or a session could read another's half-undone state as the phone's own.
+ *
+ * Not reentrant: never call it from inside itself for the same phone.
+ */
+function withPhoneNetworkLock(udid, fn) {
+    return lock.acquire(`phone-network:${udid}`, fn);
+}

package/lib/src/services/network/xenonProxy.js

@@ -0,0 +1,107 @@
+"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 });
+exports.isUnsetProxy = isUnsetProxy;
+exports.parseProxySetting = parseProxySetting;
+exports.localIPv4Addresses = localIPv4Addresses;
+exports.pointsAtThisMachine = pointsAtThisMachine;
+exports.isPortListening = isPortListening;
+exports.isDeadCaptureProxy = isDeadCaptureProxy;
+const net_1 = __importDefault(require("net"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Reading a phone's global HTTP proxy (`settings get global http_proxy`), and
+ * telling one Xenon's network capture left behind from one somebody set on
+ * purpose.
+ */
+/** Android's ways of saying "no proxy": unset (`null`), empty, or `:0`. */
+function isUnsetProxy(value) {
+    const v = (value !== null && value !== void 0 ? value : '').trim();
+    return v === '' || v === 'null' || v === ':0';
+}
+/** `host:port`, or null for no proxy or anything else. */
+function parseProxySetting(value) {
+    if (isUnsetProxy(value))
+        return null;
+    const v = value.trim();
+    const colon = v.lastIndexOf(':');
+    if (colon <= 0)
+        return null;
+    const host = v.slice(0, colon);
+    const portText = v.slice(colon + 1);
+    if (!/^\d+$/.test(portText))
+        return null;
+    const port = Number(portText);
+    if (port < 1 || port > 65535)
+        return null;
+    return { host, port };
+}
+/** This machine's own IPv4 addresses, as a phone on its network reaches it. */
+function localIPv4Addresses() {
+    const out = [];
+    for (const infos of Object.values(os_1.default.networkInterfaces())) {
+        for (const info of infos !== null && infos !== void 0 ? infos : []) {
+            if (info.family === 'IPv4' && !info.internal)
+                out.push(info.address);
+        }
+    }
+    return out;
+}
+/**
+ * Whether a phone that uses `host` as its proxy reaches this machine: through
+ * `adb reverse` (127.0.0.1, the phone itself), an emulator's alias for its
+ * host (10.0.2.2), or this machine's own address (the interceptor's LAN
+ * fallback). These are the only hosts the interceptor ever sets.
+ */
+function pointsAtThisMachine(host, ownAddresses) {
+    const h = host.trim().toLowerCase();
+    return h === '127.0.0.1' || h === 'localhost' || h === '10.0.2.2' || ownAddresses.includes(h);
+}
+/**
+ * Whether something on this machine accepts a TCP connection on `port`.
+ * Anything but a refusal counts as yes (a timeout too): only a port known to be
+ * dead may have a proxy that points at it cleared.
+ */
+function isPortListening(port, timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        const socket = net_1.default.connect({ host: '127.0.0.1', port });
+        const done = (answer) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(answer);
+        };
+        socket.setTimeout(timeoutMs, () => done(true));
+        socket.once('connect', () => done(true));
+        socket.once('error', (err) => done(err.code !== 'ECONNREFUSED'));
+    });
+}
+/**
+ * Whether `value` is a proxy Xenon's network capture set and nobody serves any
+ * more: it points at this machine, on one of this server's capture ports, and
+ * nothing answers there. A phone with such a proxy has no network at all. A
+ * proxy that points anywhere else, or at a port that answers (a capture that
+ * is running, maybe another Xenon's on this machine), is never one.
+ */
+function isDeadCaptureProxy(value_1, captureRange_1) {
+    return __awaiter(this, arguments, void 0, function* (value, captureRange, probe = isPortListening) {
+        const proxy = parseProxySetting(value);
+        if (!proxy)
+            return false;
+        if (!pointsAtThisMachine(proxy.host, localIPv4Addresses()))
+            return false;
+        if (proxy.port < captureRange[0] || proxy.port > captureRange[1])
+            return false;
+        return !(yield probe(proxy.port));
+    });
+}