@xenon-device-management/xenon 2.3.0 → 2.4.0

package/lib/src/app/routers/nodePhoneControl.js

@@ -57,6 +57,7 @@ const forwardToNode_1 = require("../../gateway/forwardToNode");
 const manualLock_1 = require("../../services/recording/manualLock");
 const SessionOwnerResolver_1 = require("../../services/device-access/SessionOwnerResolver");
 const device_store_1 = require("../../data-service/device-store");
+const recording_store_1 = require("../../services/recording/recording-store");
 const deviceAccessPolicy_1 = require("../../services/device-access/deviceAccessPolicy");
 const controlDevice_1 = require("../../middleware/controlDevice");
 /**
@@ -217,14 +218,15 @@ function refuse(res, error, message) {
     return res.status(501).json({ success: false, error, message });
 }
 function nodePhoneControl(deps = {}) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
+    const activeRecordingFor = (_b = deps.activeRecordingFor) !== null && _b !== void 0 ? _b : ((udid) => typedi_1.Container.get(recording_store_1.RecordingStore).activeRecordingFor(udid));
     const forwardDeps = {
-        timeoutMs: (_b = deps.timeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_CONTROL_TIMEOUT_MS,
-        installTimeoutMs: (_c = deps.installTimeoutMs) !== null && _c !== void 0 ? _c : exports.NODE_INSTALL_TIMEOUT_MS,
-        markNodeBusy: (_d = deps.markNodeBusy) !== null && _d !== void 0 ? _d : ((udid, host, hold) => device_store_1.DeviceStoreFactory.getStore().markNodeBusy(udid, host, hold)),
-        describeHolder: (_e = deps.describeHolder) !== null && _e !== void 0 ? _e : ((id) => typedi_1.Container.get(SessionOwnerResolver_1.SessionOwnerResolver).displayName(id)),
-        controlToken: (_f = deps.controlToken) !== null && _f !== void 0 ? _f : defaultControlToken,
+        timeoutMs: (_c = deps.timeoutMs) !== null && _c !== void 0 ? _c : exports.NODE_CONTROL_TIMEOUT_MS,
+        installTimeoutMs: (_d = deps.installTimeoutMs) !== null && _d !== void 0 ? _d : exports.NODE_INSTALL_TIMEOUT_MS,
+        markNodeBusy: (_e = deps.markNodeBusy) !== null && _e !== void 0 ? _e : ((udid, host, hold) => device_store_1.DeviceStoreFactory.getStore().markNodeBusy(udid, host, hold)),
+        describeHolder: (_f = deps.describeHolder) !== null && _f !== void 0 ? _f : ((id) => typedi_1.Container.get(SessionOwnerResolver_1.SessionOwnerResolver).displayName(id)),
+        controlToken: (_g = deps.controlToken) !== null && _g !== void 0 ? _g : defaultControlToken,
     };
     return function (req, res, next) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -263,6 +265,27 @@ function nodePhoneControl(deps = {}) {
             if (!exports.NODE_FORWARDED_CONTROL.includes(key)) {
                 return refuse(res, 'not_available_through_hub', `This phone is on node ${node}, and the hub doesn't pass ${action} on to nodes yet.`);
             }
+            if (key === 'POST stream/stop') {
+                // This server may be recording the phone from the node's stream
+                // (nodeRecordingSource.ts). The node doesn't know, and stopping its
+                // stream would cut the recording short: refused as /control refuses a
+                // stop for its own phones being recorded.
+                const recording = yield activeRecordingFor(udid).catch((e) => {
+                    var _a;
+                    logger_1.default.error(`nodePhoneControl: recording lookup failed for ${udid}: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+                    return undefined;
+                });
+                if (recording === undefined)
+                    return res.status(503).json((0, deviceAccessPolicy_1.ownershipUnavailableBody)());
+                if (recording) {
+                    return res.status(409).json({
+                        success: false,
+                        error: 'device_recording',
+                        message: 'This device is being recorded. Stop the recording first.',
+                        groupId: recording.groupId,
+                    });
+                }
+            }
             return forward(req, res, { udid, device, node }, forwardDeps);
         });
     };

package/lib/src/services/recording/RecordingOrchestrator.js

@@ -70,6 +70,7 @@ const concurrency_gate_1 = require("./concurrency-gate");
 const device_service_1 = require("../../data-service/device-service");
 const device_store_1 = require("../../data-service/device-store");
 const manualLock_1 = require("./manualLock");
+const nodeRecordingSource_1 = require("./nodeRecordingSource");
 const ensureMjpegForRecording_1 = require("./ensureMjpegForRecording");
 const probeDuration_1 = require("./probeDuration");
 const annotationImage_1 = require("./annotationImage");
@@ -136,13 +137,15 @@ class RecordingError extends Error {
 exports.RecordingError = RecordingError;
 let RecordingOrchestrator = class RecordingOrchestrator {
     constructor(deps = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         /**
          * Recording ids currently being closed out. Both the user-initiated stop and
          * an ffmpeg self-exit finalize rows, and they can land at the same instant —
          * this keeps exactly one of them doing it.
          */
         this.finalizing = new Set();
+        /** The relays node phones' recordings read, by recording id, until finalized. */
+        this.nodeSources = new Map();
         this._deps = {
             busyPrecheck: (_a = deps.busyPrecheck) !== null && _a !== void 0 ? _a : typedi_1.Container.get(busy_precheck_1.BusyPrecheck),
             store: (_b = deps.store) !== null && _b !== void 0 ? _b : typedi_1.Container.get(recording_store_1.RecordingStore),
@@ -153,8 +156,9 @@ let RecordingOrchestrator = class RecordingOrchestrator {
         this.blockDeviceFn = (_f = deps.blockDeviceFn) !== null && _f !== void 0 ? _f : device_service_1.blockDevice;
         this.unblockDeviceFn = (_g = deps.unblockDeviceFn) !== null && _g !== void 0 ? _g : device_service_1.unblockDevice;
         this.ensureMjpegPortFn = (_h = deps.ensureMjpegPortFn) !== null && _h !== void 0 ? _h : ensureMjpegForRecording_1.ensureMjpegForRecording;
-        this.probeDurationMsFn = (_j = deps.probeDurationMsFn) !== null && _j !== void 0 ? _j : probeDuration_1.probeVideoDurationMs;
-        this.now = (_k = deps.now) !== null && _k !== void 0 ? _k : Date.now;
+        this.nodeSourceFn = (_j = deps.nodeSourceFn) !== null && _j !== void 0 ? _j : ((udid, actorId) => (0, nodeRecordingSource_1.recordingSourceFor)(udid, actorId));
+        this.probeDurationMsFn = (_k = deps.probeDurationMsFn) !== null && _k !== void 0 ? _k : probeDuration_1.probeVideoDurationMs;
+        this.now = (_l = deps.now) !== null && _l !== void 0 ? _l : Date.now;
     }
     get busyPrecheck() {
         return this._deps.busyPrecheck;
@@ -267,7 +271,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 const host = deviceHosts[udid];
                 const filePath = typedi_1.Container.get(ArtifactStore_1.ARTIFACT_STORE).resolve(id, 'video', `${id}.mp4`);
                 try {
-                    const mjpegPort = yield this.ensureMjpegPortFn(udid);
+                    const mjpegPort = yield this.sourcePort(id, udid, actorId);
                     mjpegPorts[udid] = mjpegPort;
                     yield this.store.create({
                         id,
@@ -294,6 +298,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 }
                 catch (err) {
                     recLog.error(`Failed to start recording for ${udid}: ${err === null || err === void 0 ? void 0 : err.message}`);
+                    yield this.closeNodeSource(id);
                     // Mark this one failed but continue with the rest of the group.
                     try {
                         yield this.store.finalize(id, {
@@ -392,6 +397,8 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 status = 'FAILED';
                 failReason = (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'ffmpeg_stop_failed';
             }
+            // Its ffmpeg is done reading; a group's composite stops before this.
+            yield this.closeNodeSource(r.id);
             // How long the video actually is, not how long the session was open. Those
             // agree only while capture keeps up: a recording whose device died at 26s
             // and was stopped 5 minutes later reported 5m36s for a 35s file (#204).
@@ -804,7 +811,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
             const filePath = typedi_1.Container.get(ArtifactStore_1.ARTIFACT_STORE).resolve(recordingId, 'video', `${recordingId}.mp4`);
             try {
-                const mjpegPort = yield this.ensureMjpegPortFn(udid);
+                const mjpegPort = yield this.sourcePort(recordingId, udid, actorId);
                 yield this.store.create({
                     id: recordingId,
                     groupId,
@@ -829,6 +836,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
             catch (err) {
                 recLog.error(`Failed to add device ${udid} to group ${groupId}: ${err === null || err === void 0 ? void 0 : err.message}`);
+                yield this.closeNodeSource(recordingId);
                 this.gate.release(recordingId);
                 yield this.tryUnblock(udid, host);
                 try {
@@ -940,6 +948,32 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
         });
     }
+    /**
+     * The loopback port a recording reads: this server's own phone's MJPEG
+     * stream, or, for another server's phone, a relay to its node's, kept until
+     * the recording is finalized (nodeRecordingSource.ts).
+     */
+    sourcePort(recordingId, udid, actorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relay = yield this.nodeSourceFn(udid, actorId);
+            if (!relay)
+                return this.ensureMjpegPortFn(udid);
+            this.nodeSources.set(recordingId, relay);
+            return relay.port;
+        });
+    }
+    closeNodeSource(recordingId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relay = this.nodeSources.get(recordingId);
+            if (!relay)
+                return;
+            this.nodeSources.delete(recordingId);
+            yield relay.close().catch((err) => {
+                var _a;
+                recLog.warn(`Closing the node relay of ${recordingId} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            });
+        });
+    }
     tryUnblock(udid, host) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/lib/src/services/recording/busy-precheck.js

@@ -64,7 +64,7 @@ let BusyPrecheck = class BusyPrecheck {
      */
     findBusy(udids, actorId, actorApiKeyId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const store = this.storeProvider();
             const out = [];
             for (const udid of udids) {
@@ -81,7 +81,10 @@ let BusyPrecheck = class BusyPrecheck {
                 }
                 if (!device.busy)
                     continue;
-                const blockId = (_a = device.session_id) !== null && _a !== void 0 ? _a : undefined;
+                // This server's own hold, else, on a hub, a node phone's preview hold
+                // its node reports (nodeHold): session_id is the hub's and stays empty
+                // for it, which read as unknown and refused the holder their own phone.
+                const blockId = (_b = (_a = device.session_id) !== null && _a !== void 0 ? _a : device.nodeHold) !== null && _b !== void 0 ? _b : undefined;
                 const lock = (0, manualLock_1.inspectManualLock)(blockId, actorId, udid);
                 // Single source of truth for "is this lock mine" — the same helper
                 // /control's guard, stream/start and stream/stop use. Checking only

package/lib/src/services/recording/nodeRecordingSource.js

@@ -0,0 +1,156 @@
+"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.NODE_STREAM_READY_TIMEOUT_MS = void 0;
+exports.openNodeMjpegRelay = openNodeMjpegRelay;
+exports.recordingSourceFor = recordingSourceFor;
+const http_1 = __importDefault(require("http"));
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const hubSessionToken_1 = require("../../gateway/hubSessionToken");
+const forwardToNode_1 = require("../../gateway/forwardToNode");
+const nodePhoneControl_1 = require("../../app/routers/nodePhoneControl");
+const controlDevice_1 = require("../../middleware/controlDevice");
+const relayLog = logger_1.default.scope('NodeRecordingSource');
+/**
+ * How long a node's phone has to start streaming: an iPhone's WebDriverAgent
+ * and tunnel take tens of seconds on a cold start.
+ */
+exports.NODE_STREAM_READY_TIMEOUT_MS = 90000;
+const defaultControlToken = (grant) => typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).controlTokenFor(grant);
+/**
+ * A node's phone, recorded on this server: a loopback server whose every
+ * connection gets the node's MJPEG stream (`GET /control/<udid>/stream`),
+ * signed afresh for the recording's user. ffmpeg reads it like one of this
+ * server's own phones, and reconnects on any hiccup; the hub's control token
+ * lasts a minute and a recording much longer, so each connection signs again.
+ * The node counts the connection as a viewer, so its idle release leaves the
+ * stream running for as long as the recording reads it. Loopback only, like
+ * this server's own phones' MJPEG servers.
+ */
+function openNodeMjpegRelay(target_1) {
+    return __awaiter(this, arguments, void 0, function* (target, deps = {}) {
+        var _a, _b;
+        const { udid, host, actorId } = target;
+        const origin = (0, nodePhoneControl_1.safeNodeOrigin)(host);
+        if (!origin)
+            throw new Error(`Unsafe device host for ${udid}`);
+        const controlToken = (_a = deps.controlToken) !== null && _a !== void 0 ? _a : defaultControlToken;
+        const url = `${origin}/xenon/api/control/${encodeURIComponent(udid)}/stream`;
+        const headers = () => __awaiter(this, void 0, void 0, function* () {
+            const token = yield controlToken({ userId: actorId, isAdmin: false, udid, host });
+            return Object.assign({ accept: '*/*', 'accept-encoding': 'identity' }, (token ? { [hubSessionToken_1.HUB_TOKEN_HEADER]: token } : {}));
+        });
+        // As local recording starts the phone's stream before ffmpeg, the node's
+        // must be sending frames before the port is handed out. Its GET stream
+        // starts the stream; an iPhone's takes seconds. Otherwise the video began
+        // late, and every mark on it, timed from ffmpeg's start, was off by that.
+        yield untilStreaming(url, yield headers(), (_b = deps.readyTimeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_STREAM_READY_TIMEOUT_MS);
+        const server = http_1.default.createServer((_req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const controller = new AbortController();
+            res.on('close', () => controller.abort());
+            try {
+                const upstream = yield (0, forwardToNode_1.sendToNode)({
+                    url,
+                    method: 'GET',
+                    headers: yield headers(),
+                    signal: controller.signal,
+                });
+                const type = upstream.headers['content-type'];
+                res.writeHead((_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502, Object.assign(Object.assign({}, (type ? { 'content-type': type } : {})), { 'cache-control': 'no-cache' }));
+                upstream.on('error', () => res.destroy());
+                upstream.pipe(res);
+            }
+            catch (err) {
+                if (res.headersSent) {
+                    res.destroy();
+                    return;
+                }
+                relayLog.warn(`[${udid}] node ${origin} stream unavailable: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                res.writeHead(502, { 'content-type': 'text/plain' });
+                res.end(`node unreachable: ${(_d = (_c = err === null || err === void 0 ? void 0 : err.code) !== null && _c !== void 0 ? _c : err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : err}`);
+            }
+        }));
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        relayLog.info(`[${udid}] recording relay for node ${origin} on 127.0.0.1:${port}`);
+        return {
+            port,
+            close: () => new Promise((resolve) => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+/**
+ * Resolves once the node's stream sends its first bytes; throws when the node
+ * refuses it, ends it first, or sends nothing within `timeoutMs`.
+ */
+function untilStreaming(url, headers, timeoutMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            const upstream = yield (0, forwardToNode_1.sendToNode)({ url, method: 'GET', headers, signal: controller.signal });
+            if (((_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502) !== 200) {
+                const answer = yield (0, forwardToNode_1.readAnswer)(upstream);
+                throw new Error(`the node answered ${answer.status} for the stream: ${answer.body.toString('utf8').slice(0, 200)}`);
+            }
+            yield new Promise((resolve, reject) => {
+                upstream.once('data', () => resolve());
+                upstream.once('end', () => reject(new Error("the node's stream ended before its first frame")));
+                upstream.once('error', reject);
+            });
+        }
+        catch (err) {
+            if (timedOut) {
+                throw new Error(`the node's stream sent no first frame within ${Math.round(timeoutMs / 1000)} s`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+        }
+    });
+}
+/**
+ * The recording source for a phone: a relay to its node for another server's
+ * phone, null for this server's own (or an unknown) phone, which the caller
+ * reads locally as before. A cloud provider's phone can't be recorded here.
+ */
+function recordingSourceFor(udid_1, actorId_1) {
+    return __awaiter(this, arguments, void 0, function* (udid, actorId, deps = {}) {
+        var _a;
+        const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
+        const device = yield findDevice(udid);
+        if (!device || !(0, nodePhoneControl_1.isOtherServersPhone)(device))
+            return null;
+        if (device.cloud) {
+            throw new Error(`${udid} is a cloud provider's phone and can't be recorded here.`);
+        }
+        return openNodeMjpegRelay({ udid, host: device.host, actorId }, deps);
+    });
+}

package/lib/test/unit/busy-precheck.spec.js

@@ -99,6 +99,38 @@ describe('BusyPrecheck', () => {
         const out = yield pc.findBusy(['U1'], 'actor-1');
         (0, chai_1.expect)(out[0]).to.deep.include({ udid: 'U1', reason: 'manual_other', blockId: 'manual_U1' });
     }));
+    // On a hub, a node's phone held by a preview has the holder in nodeHold,
+    // from the node's report; session_id is the hub's own and stays empty.
+    // Read as unknown, the user's own preview kept them from recording it.
+    it('reads a node phone’s preview hold from nodeHold: mine to take over, another user’s not', () => __awaiter(void 0, void 0, void 0, function* () {
+        const pc = precheck(withDevices({
+            MINE: {
+                udid: 'MINE',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: 'manual_alice_MINE',
+            },
+            THEIRS: {
+                udid: 'THEIRS',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: 'manual_bob_THEIRS',
+            },
+            NODE_SESSION: {
+                udid: 'NODE_SESSION',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: null,
+            },
+        }));
+        (0, chai_1.expect)(yield pc.findBusy(['MINE', 'THEIRS', 'NODE_SESSION'], 'alice')).to.deep.equal([
+            { udid: 'THEIRS', reason: 'manual_other', blockId: 'manual_bob_THEIRS' },
+            { udid: 'NODE_SESSION', reason: 'unknown' },
+        ]);
+    }));
     it('returns reason=unknown for missing devices', () => __awaiter(void 0, void 0, void 0, function* () {
         const pc = precheck(withDevices({}));
         const out = yield pc.findBusy(['MISSING']);

package/lib/test/unit/node-phone-control.spec.js

@@ -216,6 +216,32 @@ describe('nodePhoneControl', () => {
             (0, chai_1.expect)(cloud.body.error, action).to.equal('not_available_for_cloud_phone');
         }
     }));
+    // The node doesn't know this server is recording its phone, so it would stop
+    // the stream the recording reads; /control refuses a local phone's the same way.
+    it('refuses to stop a node phone’s preview while this server records it', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        const hits = [];
+        node.use((req, res) => {
+            hits.push(req.path);
+            res.json({ success: true });
+        });
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        let recording = { groupId: 'g-1' };
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use('/xenon/api/control', (0, nodePhoneControl_1.nodePhoneControl)({
+            findDevice: (udid) => findDevice(udid),
+            activeRecordingFor: () => __awaiter(void 0, void 0, void 0, function* () { return recording; }),
+        }));
+        const refused = yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/stop').send({});
+        (0, chai_1.expect)(refused.status).to.equal(409);
+        (0, chai_1.expect)(refused.body).to.include({ error: 'device_recording', groupId: 'g-1' });
+        (0, chai_1.expect)(hits).to.deep.equal([]);
+        recording = null;
+        yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/stop').send({}).expect(200);
+        (0, chai_1.expect)(hits).to.deep.equal(['/xenon/api/control/p/stream/stop']);
+    }));
     it('refuses a host it must never call', () => __awaiter(void 0, void 0, void 0, function* () {
         findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: 'http://169.254.169.254', nodeId: 'node-1' }); });
         const res = yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/control/p/screenshot');

package/lib/test/unit/node-recording-relay.spec.js

@@ -0,0 +1,165 @@
+"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 express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodeRecordingSource_1 = require("../../src/services/recording/nodeRecordingSource");
+/**
+ * Recording a node's phone on a hub. The recording's ffmpeg reads a loopback
+ * port, as for this server's own phones; for a node's phone that port is a
+ * relay to the node's MJPEG stream, signed for the recording's user on every
+ * connection. ffmpeg reconnects on any hiccup, and the hub's control token
+ * lasts a minute, so a token taken once would end the recording on the first
+ * reconnect after that.
+ */
+describe('nodeRecordingSource', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const closers = [];
+    let context;
+    let saved;
+    beforeEach(() => {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        context.setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), 1, 'hub-1', '');
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        for (const close of closers.splice(0))
+            yield close();
+        yield loopback.closeAll();
+    }));
+    /** A node serving GET /control/p/stream, recording each request's token. */
+    function fakeNode() {
+        return __awaiter(this, arguments, void 0, function* (status = 200, firstFrameAfterMs = 0) {
+            const seen = [];
+            const app = (0, express_1.default)();
+            app.get('/xenon/api/control/p/stream', (req, res) => {
+                const call = { token: req.header('x-xenon-hub-token'), closed: false };
+                seen.push(call);
+                req.on('close', () => (call.closed = true));
+                if (status !== 200)
+                    return res.status(status).json({ error: 'node says no' });
+                res.writeHead(200, { 'content-type': 'multipart/x-mixed-replace; boundary=f' });
+                let timer;
+                const wait = setTimeout(() => {
+                    timer = setInterval(() => res.write('--f\r\nFRAME\r\n'), 30);
+                }, firstFrameAfterMs);
+                res.on('close', () => {
+                    clearTimeout(wait);
+                    if (timer)
+                        clearInterval(timer);
+                });
+            });
+            const origin = `http://127.0.0.1:${(yield loopback.serve(app)).address().port}`;
+            return { origin, seen };
+        });
+    }
+    /** Read from the relay until `n` frames arrived, then hang up. */
+    const read = (port, n = 2) => new Promise((resolve, reject) => {
+        const req = http_1.default.get({ host: '127.0.0.1', port, path: '/' }, (res) => {
+            let body = '';
+            res.on('data', (c) => {
+                body += c.toString();
+                if (body.split('FRAME').length > n) {
+                    req.destroy();
+                    resolve({ status: res.statusCode, type: String(res.headers['content-type']), body });
+                }
+            });
+            res.on('end', () => resolve({ status: res.statusCode, body }));
+        });
+        req.on('error', (e) => (e.code === 'ECONNRESET' ? undefined : reject(e)));
+    });
+    it('relays the node’s stream, signed afresh for each connection', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = yield fakeNode();
+        let n = 0;
+        const relay = yield (0, nodeRecordingSource_1.openNodeMjpegRelay)({ udid: 'p', host: node.origin, actorId: 'alice' }, { controlToken: (grant) => __awaiter(void 0, void 0, void 0, function* () { return `token-${++n}-${grant.userId}-${grant.udid}`; }) });
+        closers.push(() => relay.close());
+        const first = yield read(relay.port);
+        const second = yield read(relay.port);
+        (0, chai_1.expect)(first.status).to.equal(200);
+        (0, chai_1.expect)(first.type).to.include('multipart/x-mixed-replace');
+        (0, chai_1.expect)(second.body).to.include('FRAME');
+        // The first is the relay making sure the node is streaming before it
+        // hands out the port.
+        (0, chai_1.expect)(node.seen.map((s) => s.token)).to.deep.equal([
+            'token-1-alice-p',
+            'token-2-alice-p',
+            'token-3-alice-p',
+        ]);
+    }));
+    it('hangs up on the node when the reader goes, and stops listening when closed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = yield fakeNode();
+        const relay = yield (0, nodeRecordingSource_1.openNodeMjpegRelay)({ udid: 'p', host: node.origin, actorId: 'alice' }, { controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) });
+        yield read(relay.port);
+        yield new Promise((r) => setTimeout(r, 100));
+        (0, chai_1.expect)(node.seen[1].closed, 'the node’s request ends with the reader').to.equal(true);
+        yield relay.close();
+        const refused = yield new Promise((resolve) => {
+            http_1.default
+                .get({ host: '127.0.0.1', port: relay.port, path: '/' }, () => resolve('answered'))
+                .on('error', (e) => resolve(e.code));
+        });
+        (0, chai_1.expect)(refused).to.equal('ECONNREFUSED');
+    }));
+    // Local recording starts the phone's stream before ffmpeg (ensureMjpegForRecording).
+    // Handed the port at once, ffmpeg started before the node's stream was up
+    // (an iPhone's WebDriverAgent takes seconds): the video began late, and
+    // every mark on it, timed from ffmpeg's start, was off by as much.
+    it('opens once the node is streaming, not before', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = yield fakeNode(200, 400);
+        const t0 = Date.now();
+        const relay = yield (0, nodeRecordingSource_1.openNodeMjpegRelay)({ udid: 'p', host: node.origin, actorId: 'alice' }, { controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) });
+        closers.push(() => relay.close());
+        (0, chai_1.expect)(Date.now() - t0).to.be.at.least(350);
+    }));
+    it('fails to open when the node refuses the stream, or never sends a frame', () => __awaiter(void 0, void 0, void 0, function* () {
+        const refusing = yield fakeNode(409);
+        let error;
+        yield (0, nodeRecordingSource_1.openNodeMjpegRelay)({ udid: 'p', host: refusing.origin, actorId: 'alice' }, { controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) }).catch((e) => (error = e));
+        (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.include('409');
+        const silent = yield fakeNode(200, 60000);
+        error = undefined;
+        yield (0, nodeRecordingSource_1.openNodeMjpegRelay)({ udid: 'p', host: silent.origin, actorId: 'alice' }, { controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }), readyTimeoutMs: 200 }).catch((e) => (error = e));
+        (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/first frame/);
+    }));
+    describe('recordingSourceFor', () => {
+        const rows = {};
+        const find = (udid) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = rows[udid]) !== null && _a !== void 0 ? _a : null; });
+        it('is null for this server’s own phone and an unknown one', () => __awaiter(void 0, void 0, void 0, function* () {
+            rows.own = { udid: 'own', host: 'http://10.0.0.9:4723', nodeId: 'hub-1' };
+            (0, chai_1.expect)(yield (0, nodeRecordingSource_1.recordingSourceFor)('own', 'alice', { findDevice: find })).to.equal(null);
+            (0, chai_1.expect)(yield (0, nodeRecordingSource_1.recordingSourceFor)('ghost', 'alice', { findDevice: find })).to.equal(null);
+        }));
+        it('opens a relay for a node’s phone, and refuses a cloud provider’s', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            rows.p = { udid: 'p', host: node.origin, nodeId: 'node-1' };
+            const relay = yield (0, nodeRecordingSource_1.recordingSourceFor)('p', 'alice', {
+                findDevice: find,
+                controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            });
+            (0, chai_1.expect)(relay === null || relay === void 0 ? void 0 : relay.port).to.be.a('number');
+            closers.push(() => relay.close());
+            rows.c = { udid: 'c', host: 'https://hub.cloud.example', cloud: '{"cloudName":"x"}' };
+            let error;
+            yield (0, nodeRecordingSource_1.recordingSourceFor)('c', 'alice', { findDevice: find }).catch((e) => (error = e));
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/cloud provider/);
+        }));
+    });
+});