@xenon-device-management/xenon 2.0.0 → 2.1.0

package/lib/test/unit/health-monitor-stream-lookup.spec.js

@@ -22,6 +22,7 @@ const device_store_1 = require("../../src/data-service/device-store");
 const SessionManager_1 = require("../../src/sessions/SessionManager");
 const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
 const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const PluginContext_1 = require("../../src/PluginContext");
 // Named like the real managers: the monitor picks one by constructor.name.
 class AndroidDeviceManager {
     constructor() {
@@ -33,12 +34,15 @@ class IOSDeviceManager {
         this.checkHealth = () => __awaiter(this, void 0, void 0, function* () { return ({ healthStatus: 'Healthy' }); });
     }
 }
+const THIS_SERVER = 'this-server-node-id';
 // A device busy with an Appium session this process no longer knows about,
 // which is the case the monitor reclaims, unless a stream is still running.
 function lostSessionDevice(platform) {
     return {
         udid: `${platform}-1`,
         host: 'http://127.0.0.1:4723',
+        // This server's own phone: the monitor checks no other server's.
+        nodeId: THIS_SERVER,
         platform,
         busy: true,
         session_id: 'appium-session-not-in-memory',
@@ -51,7 +55,10 @@ describe('HealthMonitorService — stream lookups', () => {
     let androidStatus;
     let iosStatus;
     const reclaimed = () => updateDevice.getCalls().some((c) => { var _a, _b; return ((_a = c.args[2]) === null || _a === void 0 ? void 0 : _a.busy) === false && !((_b = c.args[2]) === null || _b === void 0 ? void 0 : _b.session_id); });
+    let nodeIdBefore;
     beforeEach(() => {
+        nodeIdBefore = typedi_1.Container.get(PluginContext_1.PluginContext).nodeId;
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeId = THIS_SERVER;
         sinon_1.default.stub(process, 'kill');
         updateDevice = sinon_1.default.spy(() => __awaiter(void 0, void 0, void 0, function* () { return undefined; }));
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
@@ -78,7 +85,10 @@ describe('HealthMonitorService — stream lookups', () => {
             return real(token);
         });
     });
-    afterEach(() => sinon_1.default.restore());
+    afterEach(() => {
+        sinon_1.default.restore();
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeId = nodeIdBefore;
+    });
     const run = () => new HealthMonitorService_1.HealthMonitorService({}).checkAllDevices();
     it('leaves an Android device with a running stream alone', () => __awaiter(void 0, void 0, void 0, function* () {
         device = lostSessionDevice('android');

package/lib/test/unit/helpers.spec.js

@@ -46,6 +46,33 @@ describe('redactSecrets', () => {
         const redacted = (0, helpers_1.redactSecrets)(arr);
         (0, chai_1.expect)(redacted[0]).to.equal('[Circular]');
     });
+    // Half of an xe:options credential pair: without its token it proves
+    // nothing, but it names the key a leaked token would complete.
+    it('should redact access keys in every spelling', () => {
+        const KEY = 'xen_AbC123dEf456';
+        const obj = {
+            accessKey: KEY,
+            access_key: KEY,
+            ACCESS_KEY: KEY,
+            'x-xenon-access-key': KEY,
+            'xe:options': { accessKey: KEY, leaseId: 'lse_1' },
+        };
+        const redacted = (0, helpers_1.redactSecrets)(obj);
+        (0, chai_1.expect)(redacted).to.deep.equal({
+            accessKey: '***REDACTED***',
+            access_key: '***REDACTED***',
+            ACCESS_KEY: '***REDACTED***',
+            'x-xenon-access-key': '***REDACTED***',
+            'xe:options': { accessKey: '***REDACTED***', leaseId: 'lse_1' },
+        });
+    });
+    // GET /xenon/api/profile/access-key and /auth/me hand the caller their own
+    // key. Logging the same object must not take it out of the response.
+    it('should leave the object it was given untouched', () => {
+        const body = { accessKey: 'xen_AbC123dEf456', nested: { token: 't' } };
+        (0, helpers_1.redactSecrets)(body);
+        (0, chai_1.expect)(body).to.deep.equal({ accessKey: 'xen_AbC123dEf456', nested: { token: 't' } });
+    });
     it('should redact falsy sensitive values', () => {
         const obj = {
             password: '',

package/lib/test/unit/hub-boot-sweep-recovery.spec.js

@@ -0,0 +1,192 @@
+"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 os_1 = __importDefault(require("os"));
+const sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const OrphanSweeper_1 = require("../../src/services/OrphanSweeper");
+const SessionHeartbeatService_1 = require("../../src/services/SessionHeartbeatService");
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const nodeSessionStatus_1 = require("../../src/gateway/nodeSessionStatus");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * A hub restart must not undo the recovery of its nodes' sessions.
+ *
+ * At boot a hub rebuilds the sessions its nodes still run from their rows
+ * (recoverActiveSessions), then sweeps orphans: rows whose last heartbeat is
+ * older than 3 heartbeat intervals and was written by another process on
+ * this host (OrphanSweeper, at boot and on every interval). A recovered row
+ * still carries the old process's heartbeat, so a restart longer than ~90 s
+ * failed every node session recovery had just rebuilt and freed its phone,
+ * while the node kept the session.
+ *
+ * A recovered session is this process's from then on, so recovery stamps its
+ * heartbeat. A session the node no longer has still ends: the heartbeat asks
+ * the node and ends it.
+ */
+describe('a hub restart: the orphan sweep and the sessions recovery rebuilt', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const INTERVAL_MS = 30000;
+    const OLD_PID = 999999;
+    const TEN_MINUTES_AGO = () => new Date(Date.now() - 10 * 60000);
+    let context;
+    let saved;
+    let restore;
+    let nodeOrigin;
+    let nodeHas;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        nodeHas = new Set();
+        const node = (0, express_1.default)();
+        node.get('/xenon/api/webdriver', (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => ''));
+        node.get('/xenon/api/node/sessions/:sessionId', (req, res) => {
+            res.setHeader(nodeSessionStatus_1.NODE_SESSION_STATUS_HEADER, '1');
+            const { sessionId } = req.params;
+            res.json({ value: { sessionId, exists: nodeHas.has(sessionId) } });
+        });
+        const server = yield loopback.serve(node);
+        nodeOrigin = `http://127.0.0.1:${server.address().port}`;
+        restore = (0, container_registration_1.saveRegistrations)(nodeWebDriverUrl_1.NodeBasePathResolver, nodeSessionStatus_1.NodeSessionProbeSupport, hubSessionToken_1.HubSessionTokenIssuer, SocketServer_1.SocketServer, NotificationService_1.NotificationService);
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        typedi_1.Container.set(nodeSessionStatus_1.NodeSessionProbeSupport, new nodeSessionStatus_1.NodeSessionProbeSupport());
+        const issuer = new hubSessionToken_1.HubSessionTokenIssuer();
+        issuer.useSigner({ sign: () => __awaiter(void 0, void 0, void 0, function* () { return 'hub-token'; }) });
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, issuer);
+        typedi_1.Container.set({
+            id: SocketServer_1.SocketServer,
+            value: {
+                emitToDashboard: () => undefined,
+                emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+                hasScopedDashboard: () => false,
+            },
+        });
+        typedi_1.Container.set({ id: NotificationService_1.NotificationService, value: { dispatchEvent: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }) } });
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = { context: Object.assign({}, context), store: device_store_1.DeviceStoreFactory._deviceStore };
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        context.setContext(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), 4799, 'hub-after-restart', '');
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        Object.assign(context, saved.context);
+        device_store_1.DeviceStoreFactory._deviceStore = saved.store;
+        sinon_1.default.restore();
+        restore();
+        yield loopback.closeAll();
+    }));
+    /** A node session the hub ran before it went down, last heartbeat 10 minutes ago. */
+    function nodeSessionFromBeforeTheRestart(sessionId, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({
+                data: {
+                    udid,
+                    host: nodeOrigin,
+                    nodeId: 'node-peer',
+                    platform: 'android',
+                    name: udid,
+                    busy: true,
+                    session_id: sessionId,
+                    claimSessionId: sessionId,
+                    claimedAt: Date.now() - 11 * 60000,
+                },
+            });
+            yield staleRow(sessionId, udid, 'node-peer');
+        });
+    }
+    function staleRow(sessionId, udid, nodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.session.create({
+                data: {
+                    id: sessionId,
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: nodeId,
+                    has_live_video: false,
+                    device_udid: udid,
+                    device_platform: 'android',
+                    device_version: '14',
+                    status: 'running',
+                    user_id: 'alice',
+                    heartbeat_host: os_1.default.hostname(),
+                    heartbeat_pid: OLD_PID,
+                    last_heartbeat_at: TEN_MINUTES_AGO(),
+                    updatedAt: TEN_MINUTES_AGO(),
+                },
+            });
+        });
+    }
+    const status = (id) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = (yield scratch.db.session.findUnique({ where: { id } }))) === null || _a === void 0 ? void 0 : _a.status; });
+    const phone = (udid) => scratch.db.device.findFirst({ where: { udid } });
+    const bootSweep = () => typedi_1.Container.get(OrphanSweeper_1.OrphanSweeper).sweep({
+        heartbeatIntervalMs: INTERVAL_MS,
+        hostScope: { host: os_1.default.hostname(), excludePid: process.pid },
+    });
+    const periodicSweep = () => typedi_1.Container.get(OrphanSweeper_1.OrphanSweeper).sweep({ heartbeatIntervalMs: INTERVAL_MS });
+    it('a recovered session with a 10-minute-old heartbeat survives the boot sweep', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield nodeSessionFromBeforeTheRestart('node-session', 'node-phone');
+        nodeHas.add('node-session');
+        (0, chai_1.expect)(yield SessionManager_1.SESSION_MANAGER.recoverActiveSessions('hub-after-restart', '')).to.equal(1);
+        yield bootSweep();
+        (0, chai_1.expect)(yield status('node-session')).to.equal('running');
+        (0, chai_1.expect)(SessionManager_1.SESSION_MANAGER.getSession('node-session'), 'still routed').to.not.equal(undefined);
+        (0, chai_1.expect)(yield phone('node-phone')).to.include({ busy: true, claimSessionId: 'node-session' });
+    }));
+    it('and the periodic sweep that follows', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield nodeSessionFromBeforeTheRestart('node-session', 'node-phone');
+        nodeHas.add('node-session');
+        yield SessionManager_1.SESSION_MANAGER.recoverActiveSessions('hub-after-restart', '');
+        yield bootSweep();
+        yield periodicSweep();
+        (0, chai_1.expect)(yield status('node-session')).to.equal('running');
+    }));
+    it('a stale session on this host that recovery did not rebuild is still swept', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield nodeSessionFromBeforeTheRestart('node-session', 'node-phone');
+        nodeHas.add('node-session');
+        yield SessionManager_1.SESSION_MANAGER.recoverActiveSessions('hub-after-restart', '');
+        // Not in the table recovery read: nothing rebuilt it, nothing heartbeats it.
+        yield staleRow('orphan-session', 'gone-phone', 'node-peer');
+        yield bootSweep();
+        (0, chai_1.expect)(yield status('orphan-session')).to.equal('failed');
+        (0, chai_1.expect)(yield status('node-session')).to.equal('running');
+    }));
+    it('a recovered session the node no longer has is ended by the heartbeat', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield nodeSessionFromBeforeTheRestart('node-session', 'node-phone');
+        yield SessionManager_1.SESSION_MANAGER.recoverActiveSessions('hub-after-restart', '');
+        yield bootSweep();
+        (0, chai_1.expect)(yield status('node-session')).to.equal('running');
+        // The node says it has no such session (nodeHas is empty).
+        const heartbeat = new SessionHeartbeatService_1.SessionHeartbeatService();
+        for (let i = 0; i < 6; i++)
+            yield heartbeat.checkAllSessions();
+        (0, chai_1.expect)(yield status('node-session')).to.equal('failed');
+        (0, chai_1.expect)(SessionManager_1.SESSION_MANAGER.getSession('node-session')).to.equal(undefined);
+        (0, chai_1.expect)(yield phone('node-phone')).to.include({ busy: false, claimSessionId: null });
+    }));
+});

package/lib/test/unit/hub-create-once.spec.js

@@ -0,0 +1,190 @@
+"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());
+    });
+};
+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 fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const jose = __importStar(require("jose"));
+const typedi_1 = require("typedi");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * A create the hub forwards to a node runs once.
+ *
+ * InternalHttpClient retries a request on a 5xx or on its 30 s timeout. A
+ * create is not safe to repeat: a first UiAutomator2 install easily outlasts
+ * 30 s, and every retry started another session on the node, holding the phone
+ * with nobody to end it. So the hub sends a create once, with a timeout sized
+ * for a create, and the node takes the hub's create token only once.
+ */
+describe('a create the hub forwards runs once', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let context;
+    let saved;
+    let restore;
+    let timeoutBefore;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(nodeWebDriverUrl_1.NodeBasePathResolver);
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        // A client of its own, built now: one that reads XENON_HTTP_TIMEOUT_MS below.
+        context.pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { tlsRejectUnauthorized: true });
+        context.nodeId = 'hub-node-id';
+        context.nodeBasePath = '';
+        timeoutBefore = process.env.XENON_HTTP_TIMEOUT_MS;
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        if (timeoutBefore === undefined)
+            delete process.env.XENON_HTTP_TIMEOUT_MS;
+        else
+            process.env.XENON_HTTP_TIMEOUT_MS = timeoutBefore;
+        sinon_1.default.restore();
+        restore();
+        yield loopback.closeAll();
+    }));
+    /** A node whose create answers with `answer` for each POST, in order. */
+    function node(answers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const creates = [];
+            const app = (0, express_1.default)();
+            app.use(express_1.default.json());
+            app.get('/xenon/api/webdriver', (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => ''));
+            app.post('/session', (_req, res) => {
+                var _a;
+                const n = creates.length;
+                creates.push(Date.now());
+                const answer = answers[Math.min(n, answers.length - 1)];
+                setTimeout(() => {
+                    if (answer.status === 200) {
+                        res.json({ value: { sessionId: `s-${n + 1}`, capabilities: {} } });
+                    }
+                    else {
+                        res.status(answer.status).json({
+                            value: { error: 'unknown error', message: 'driver install failed', stacktrace: '' },
+                        });
+                    }
+                }, (_a = answer.delayMs) !== null && _a !== void 0 ? _a : 0);
+            });
+            const server = yield loopback.serve(app);
+            const origin = `http://127.0.0.1:${server.address().port}`;
+            const device = { udid: 'u1', host: origin, nodeId: 'node-peer', platform: 'android' };
+            return { creates, device };
+        });
+    }
+    const caps = { alwaysMatch: { platformName: 'Android' }, firstMatch: [{}] };
+    it('is not sent again when the node answers a 5xx', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { creates, device } = yield node([{ status: 500 }, { status: 200 }]);
+        const answer = yield new SessionLifecycleService_1.SessionLifecycleService().forwardSessionRequest(device, caps);
+        (0, chai_1.expect)(creates.length, 'creates the node received').to.equal(1);
+        (0, chai_1.expect)(answer).to.be.instanceOf(Error);
+    }));
+    it('waits for a create that outlasts the ordinary request timeout, and sends it once', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        process.env.XENON_HTTP_TIMEOUT_MS = '150';
+        const { creates, device } = yield node([{ status: 200, delayMs: 600 }]);
+        const answer = yield new SessionLifecycleService_1.SessionLifecycleService().forwardSessionRequest(device, caps);
+        (0, chai_1.expect)(creates.length, 'creates the node received').to.equal(1);
+        (0, chai_1.expect)((_a = answer.value) === null || _a === void 0 ? void 0 : _a[0], JSON.stringify((_b = answer === null || answer === void 0 ? void 0 : answer.message) !== null && _b !== void 0 ? _b : answer)).to.equal('s-1');
+    }));
+});
+describe('the hub’s create token is taken once', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let dirs;
+    let restore;
+    let hubKeys;
+    let hubUrl;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        dirs = [fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-create-once-'))];
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer);
+        hubKeys = new JwtKeyService_1.JwtKeyService();
+        yield hubKeys.init(dirs[0]);
+        typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
+        const hub = (0, express_1.default)();
+        hub.get('/xenon/api/auth/jwks.json', (_req, res) => res.json(hubKeys.jwks()));
+        const server = yield loopback.serve(hub);
+        hubUrl = `http://127.0.0.1:${server.address().port}`;
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        restore();
+        yield loopback.closeAll();
+        for (const dir of dirs)
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+    }));
+    const grant = { userId: 'alice', udid: 'phone-1', host: 'http://10.0.0.5:4725' };
+    it('each create’s token has an id of its own', () => __awaiter(void 0, void 0, void 0, function* () {
+        const issuer = typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer);
+        const a = jose.decodeJwt((yield issuer.createTokenFor(grant)));
+        const b = jose.decodeJwt((yield issuer.createTokenFor(grant)));
+        (0, chai_1.expect)(a.jti).to.be.a('string').and.not.equal('');
+        (0, chai_1.expect)(b.jti).to.be.a('string').and.not.equal(a.jti);
+    }));
+    it('the node accepts it once and refuses it after that', () => __awaiter(void 0, void 0, void 0, function* () {
+        const token = (yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).createTokenFor(grant));
+        const node = new hubSessionToken_1.HubSessionTokenVerifier(hubUrl);
+        (0, chai_1.expect)(yield node.verifyCreate(token)).to.deep.equal(grant);
+        (0, chai_1.expect)(yield node.verifyCreate(token), 'the same token again').to.equal(null);
+    }));
+    it('a token from a hub that sets no id (an older hub) is still accepted', () => __awaiter(void 0, void 0, void 0, function* () {
+        const token = yield hubKeys.sign({ sub: 'alice', udid: 'phone-1', host: 'http://10.0.0.5:4725' }, { audience: hubSessionToken_1.HUB_CREATE_AUDIENCE, ttlSeconds: 120 });
+        const node = new hubSessionToken_1.HubSessionTokenVerifier(hubUrl);
+        (0, chai_1.expect)(yield node.verifyCreate(token)).to.deep.equal(grant);
+    }));
+});

package/lib/test/unit/hub-create-session-umbrella.spec.js

@@ -0,0 +1,160 @@
+"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 http_1 = __importDefault(require("http"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const logger_1 = __importDefault(require("../../src/logger"));
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * createSession on a node's phone, against Appium's real umbrella driver
+ * (base-driver 10.2.0, the one installed here).
+ *
+ * The umbrella can't hold a session another server runs. If Xenon's plugin
+ * answers such a createSession itself, without calling next(), the umbrella
+ * never records the session, then promotes its sessionless plugins to that id
+ * and builds their log prefix from `this.sessions[id]`, which is undefined:
+ * `generateDriverLogPrefix(undefined)` throws and the client gets a 500 while
+ * the node keeps the session (Appium 2.15 up to base-driver 10.2.0). Later
+ * base-drivers don't throw, but still leave the promoted plugin behind.
+ *
+ * So the session gateway creates it, in front of Appium's route, and answers
+ * it there: the umbrella never sees it. The guard below keeps the old failure
+ * reproducible, so the gateway is shown to be what prevents it.
+ */
+describe('createSession on a node’s phone, in Appium’s real umbrella driver', function () {
+    this.timeout(60000);
+    const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+    let server;
+    let umbrella;
+    let appiumLogs;
+    before(() => {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+    });
+    after(() => appiumLogs.restore());
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        if (!server)
+            return;
+        const s = server;
+        server = undefined;
+        s.closeAllConnections();
+        yield new Promise((resolve) => http_1.default.Server.prototype.close.call(s, () => resolve()));
+    }));
+    function boot(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+            umbrella = (0, appium_umbrella_1.umbrellaWith)([[plugin_1.XenonPlugin, 'xenon']]);
+            server = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: '/wd/hub',
+                cliArgs: { basePath: '/wd/hub' },
+                serverUpdaters: opts.gateway
+                    ? [
+                        (app) => (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: '/wd/hub' }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => false, authDisabled: () => false, logger: quiet }), { create: { lifecycle: () => typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService) } }),
+                    ]
+                    : [],
+            });
+            return server;
+        });
+    }
+    const caps = {
+        capabilities: {
+            alwaysMatch: { platformName: 'Android', 'appium:automationName': appium_umbrella_1.FAKE_AUTOMATION },
+            firstMatch: [{}],
+        },
+    };
+    const remoteAllocation = { remote: true, device: { udid: 'node-phone' } };
+    const nodeSession = {
+        protocol: 'W3C',
+        value: ['node-session-1', { platformName: 'Android' }, 'W3C'],
+    };
+    it('through the gateway, never reaches Appium’s createSession and leaves no plugin behind', () => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'prepareSession').resolves(remoteAllocation);
+        sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'completeRemoteSession').resolves(nodeSession);
+        const app = yield boot({ gateway: true });
+        const umbrellaCommands = sinon_1.default.spy(umbrella, 'executeCommand');
+        const pluginCreate = sinon_1.default.spy(plugin_1.XenonPlugin.prototype, 'createSession');
+        const res = yield (0, loopbackRequest_1.default)(app).post('/wd/hub/session').send(caps);
+        (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+        (0, chai_1.expect)(res.body).to.deep.equal({
+            value: { capabilities: { platformName: 'Android' }, sessionId: 'node-session-1' },
+        });
+        (0, chai_1.expect)(umbrellaCommands.called, 'the umbrella').to.equal(false);
+        (0, chai_1.expect)(pluginCreate.called, 'the plugin').to.equal(false);
+        (0, chai_1.expect)(umbrella.sessions).to.deep.equal({});
+        (0, chai_1.expect)(umbrella.sessionlessPlugins).to.deep.equal([]);
+        (0, chai_1.expect)(umbrella.sessionPlugins).to.deep.equal({});
+    }));
+    it('guard: without the gateway, a plugin that answers it itself still gets Appium’s 500', () => __awaiter(this, void 0, void 0, function* () {
+        // What the plugin did before the gateway: create on the node, never call next().
+        sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'createSession').resolves(nodeSession);
+        const app = yield boot({ gateway: false });
+        const res = yield (0, loopbackRequest_1.default)(app).post('/wd/hub/session').send(caps);
+        (0, chai_1.expect)(res.status).to.equal(500);
+        (0, chai_1.expect)(res.body.value.message).to.include("Cannot read properties of undefined (reading 'constructor')");
+    }));
+    it('the plugin no longer drops its log-prefix hook (the stopgap is gone)', () => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'createSession').resolves(nodeSession);
+        const plugin = new plugin_1.XenonPlugin('xenon', {});
+        yield plugin.createSession(sinon_1.default.stub(), {}, {}, {}, caps.capabilities);
+        (0, chai_1.expect)(plugin.updateLogPrefix).to.be.a('function');
+    }));
+    describe('when a create reaches the plugin without the gateway', () => {
+        it('a node’s phone is refused and given back, never answered for Appium', () => __awaiter(this, void 0, void 0, function* () {
+            sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'prepareSession').resolves(remoteAllocation);
+            const forward = sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'completeRemoteSession');
+            const release = sinon_1.default.stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'releaseAllocation').resolves();
+            const app = yield boot({ gateway: false });
+            const res = yield (0, loopbackRequest_1.default)(app).post('/wd/hub/session').send(caps);
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body.value.error).to.equal('session not created');
+            (0, chai_1.expect)(res.body.value.message).to.include('session gateway');
+            (0, chai_1.expect)(forward.called, 'forwarded to the node').to.equal(false);
+            (0, chai_1.expect)(release.calledOnceWith(remoteAllocation)).to.equal(true);
+        }));
+        it('a local phone is still created, by the plugin, and says so', () => __awaiter(this, void 0, void 0, function* () {
+            sinon_1.default
+                .stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'prepareSession')
+                .resolves({ remote: false, device: { udid: 'hub-phone' } });
+            sinon_1.default
+                .stub(SessionLifecycleService_1.SessionLifecycleService.prototype, 'completeLocalSession')
+                .callsFake((_allocation, next) => __awaiter(this, void 0, void 0, function* () { return next(); }));
+            // The umbrella makes the plugin instance on this request, with this logger.
+            const warnings = [];
+            const scope = logger_1.default.scope.bind(logger_1.default);
+            sinon_1.default.stub(logger_1.default, 'scope').callsFake((name) => {
+                const scoped = scope(name);
+                if (name !== 'Plugin')
+                    return scoped;
+                return Object.assign(Object.create(scoped), {
+                    warn: (message) => warnings.push(message),
+                });
+            });
+            const app = yield boot({ gateway: false });
+            const res = yield (0, loopbackRequest_1.default)(app).post('/wd/hub/session').send(caps);
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            (0, chai_1.expect)(Object.keys(umbrella.sessions)).to.deep.equal([res.body.value.sessionId]);
+            (0, chai_1.expect)(warnings.join('\n')).to.include('session gateway');
+        }));
+    });
+});