@xenon-device-management/xenon 2.13.2 → 2.14.0

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

@@ -0,0 +1,184 @@
+"use strict";
+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 __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.PhoneNetworkLedger = void 0;
+const typedi_1 = require("typedi");
+const async_lock_1 = __importDefault(require("async-lock"));
+const prisma_1 = require("../../prisma");
+const logger_1 = __importDefault(require("../../logger"));
+const PREFIX = 'phone-network:';
+/**
+ * Xenon's record of the network changes it made to its phones, kept until
+ * each is put back. In memory a session's changes are undone when it ends; a
+ * crash or a kill -9 forgets them, and the phone stays offline or pointed at
+ * a proxy nobody serves. At its next start the server reads this record and
+ * puts those phones back (PhoneNetworkRestore).
+ *
+ * Kept in this server's own database, which is what makes it this server's:
+ * a hub and a node on one machine see the same Android phones, but each has
+ * its own database. It has no table of its own: WebConfig is the database's
+ * key-value table (MetricsService keeps its counters there), and a new table
+ * would mean a migration and a regenerated client for a handful of rows. One
+ * row per session, `phone-network:<sessionId>`, holding the JSON above.
+ *
+ * A failed write is logged and never fails a session: the change is still
+ * made, and undone when the session ends; only a crash before then would
+ * leave it.
+ */
+let PhoneNetworkLedger = class PhoneNetworkLedger {
+    constructor() {
+        this.logger = logger_1.default.scope('PhoneNetwork');
+        this.lock = new async_lock_1.default();
+    }
+    /** Adds `part` to the session's record, creating the record if needed. */
+    note(sessionId, udid, part) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`record a network change for ${udid} (session ${sessionId})`, () => this.lock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.read(sessionId);
+                const next = Object.assign(Object.assign({}, (current !== null && current !== void 0 ? current : { sessionId, udid, at: Date.now() })), part);
+                yield this.write(next);
+            })));
+        });
+    }
+    /** The part was put back: drops it, and the record once nothing is left. */
+    settle(sessionId, part) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`settle the ${part} change of session ${sessionId}`, () => this.lock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.read(sessionId);
+                if (!current)
+                    return;
+                const next = Object.assign({}, current);
+                delete next[part];
+                if (next.offline || next.proxy)
+                    yield this.write(next);
+                else
+                    yield this.remove(sessionId);
+            })));
+        });
+    }
+    /** Drops the session's record, whatever it holds. */
+    forget(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`forget the network changes of session ${sessionId}`, () => this.lock.acquire(sessionId, () => this.remove(sessionId)));
+        });
+    }
+    /** The session's record, or null. */
+    get(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                return yield this.read(sessionId);
+            }
+            catch (err) {
+                this.logger.warn(`Could not read the phone network record: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                return null;
+            }
+        });
+    }
+    /** Every record, oldest first. A row that isn't a record is dropped. */
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let rows = [];
+            try {
+                rows = yield prisma_1.prisma.webConfig.findMany({
+                    where: { name: { startsWith: PREFIX } },
+                    select: { name: true, value: true },
+                });
+            }
+            catch (err) {
+                this.logger.warn(`Could not read the phone network record: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                return [];
+            }
+            const out = [];
+            for (const row of rows) {
+                const change = parseChange(row.value);
+                if (change)
+                    out.push(change);
+                else
+                    yield this.remove(row.name.slice(PREFIX.length)).catch(() => undefined);
+            }
+            return out.sort((a, b) => a.at - b.at);
+        });
+    }
+    read(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const row = yield prisma_1.prisma.webConfig.findUnique({ where: { name: PREFIX + sessionId } });
+            return row ? parseChange(row.value) : null;
+        });
+    }
+    write(change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = PREFIX + change.sessionId;
+            const value = JSON.stringify(change);
+            yield prisma_1.prisma.webConfig.upsert({
+                where: { name },
+                update: { value },
+                create: { id: name, name, value },
+            });
+        });
+    }
+    remove(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.webConfig.deleteMany({ where: { name: PREFIX + sessionId } });
+        });
+    }
+    guard(what, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield fn();
+            }
+            catch (err) {
+                this.logger.warn(`Could not ${what}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        });
+    }
+};
+exports.PhoneNetworkLedger = PhoneNetworkLedger;
+exports.PhoneNetworkLedger = PhoneNetworkLedger = __decorate([
+    (0, typedi_1.Service)()
+], PhoneNetworkLedger);
+function parseChange(value) {
+    try {
+        const v = JSON.parse(value);
+        if (!v || typeof v.sessionId !== 'string' || typeof v.udid !== 'string')
+            return null;
+        if (typeof v.at !== 'number')
+            return null;
+        const change = { sessionId: v.sessionId, udid: v.udid, at: v.at };
+        if (v.offline && typeof v.offline === 'object') {
+            change.offline = {
+                wifiOn: boolOrNull(v.offline.wifiOn),
+                dataOn: boolOrNull(v.offline.dataOn),
+            };
+        }
+        if (v.proxy && typeof v.proxy.set === 'string') {
+            change.proxy = Object.assign({ set: v.proxy.set, previous: typeof v.proxy.previous === 'string' ? v.proxy.previous : null }, (typeof v.proxy.reversePort === 'number' ? { reversePort: v.proxy.reversePort } : {}));
+        }
+        return change.offline || change.proxy ? change : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function boolOrNull(v) {
+    return typeof v === 'boolean' ? v : null;
+}

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);
+}