@xenon-device-management/xenon 2.3.0 → 2.5.0

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

package/lib/test/unit/recording-orchestrator.spec.js

@@ -60,7 +60,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 function makeOrch(overrides = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const busyPrecheck = (_a = overrides.busyPrecheck) !== null && _a !== void 0 ? _a : { findBusy: sinon_1.default.stub().resolves([]) };
     const store = (_b = overrides.store) !== null && _b !== void 0 ? _b : {
         create: sinon_1.default.stub().callsFake((i) => __awaiter(this, void 0, void 0, function* () { return (Object.assign({ id: `rec-${i.deviceUdid}` }, i)); })),
@@ -80,7 +80,9 @@ function makeOrch(overrides = {}) {
     const blockDeviceFn = (_e = overrides.blockDeviceFn) !== null && _e !== void 0 ? _e : sinon_1.default.stub().resolves();
     const unblockDeviceFn = (_f = overrides.unblockDeviceFn) !== null && _f !== void 0 ? _f : sinon_1.default.stub().resolves();
     const ensureMjpegPortFn = (_g = overrides.ensureMjpegPortFn) !== null && _g !== void 0 ? _g : sinon_1.default.stub().callsFake(() => __awaiter(this, void 0, void 0, function* () { return 9100; }));
-    const eventMgr = (_h = overrides.eventMgr) !== null && _h !== void 0 ? _h : {
+    // This server's own phones, unless a test says otherwise.
+    const nodeSourceFn = (_h = overrides.nodeSourceFn) !== null && _h !== void 0 ? _h : sinon_1.default.stub().resolves(null);
+    const eventMgr = (_j = overrides.eventMgr) !== null && _j !== void 0 ? _j : {
         emitRecordingStarted: sinon_1.default.stub(),
         emitRecordingStopped: sinon_1.default.stub(),
         emitRecordingFailed: sinon_1.default.stub(),
@@ -96,6 +98,7 @@ function makeOrch(overrides = {}) {
         eventMgr: eventMgr,
         unblockDeviceFn,
         ensureMjpegPortFn,
+        nodeSourceFn,
         now: overrides.now,
     });
     return {
@@ -108,8 +111,89 @@ function makeOrch(overrides = {}) {
         unblockDeviceFn,
         eventMgr,
         ensureMjpegPortFn,
+        nodeSourceFn,
     };
 }
+// On a hub, a node's phone is recorded from a loopback relay to its node's
+// stream (nodeRecordingSource.ts); this server's own phones as before.
+describe('RecordingOrchestrator: a node’s phone', () => {
+    (0, artifact_store_1.useArtifactStore)();
+    beforeEach(() => {
+        sinon_1.default.stub(deviceStoreModule.DeviceStoreFactory, 'getStore').returns({
+            findDevice: sinon_1.default
+                .stub()
+                .callsFake((_a) => __awaiter(void 0, [_a], void 0, function* ({ udid }) { return ({ udid, host: 'h', busy: false }); })),
+        });
+    });
+    afterEach(() => sinon_1.default.restore());
+    /** A store that keeps what create() was given, as listGroup's rows. */
+    function rowStore() {
+        const rows = [];
+        return {
+            rows,
+            create: sinon_1.default.stub().callsFake((i) => __awaiter(this, void 0, void 0, function* () {
+                rows.push({
+                    id: i.id,
+                    group_id: i.groupId,
+                    device_udid: i.deviceUdid,
+                    device_host: i.deviceHost,
+                    file_path: i.filePath,
+                    started_at: new Date().toISOString(),
+                    status: 'RECORDING',
+                });
+                return i;
+            })),
+            finalize: sinon_1.default.stub().resolves({}),
+            listActive: sinon_1.default.stub().resolves([]),
+            listGroup: sinon_1.default.stub().callsFake(() => __awaiter(this, void 0, void 0, function* () { return rows; })),
+        };
+    }
+    const relayFor = (udid, port) => {
+        const close = sinon_1.default.stub().resolves();
+        const fn = sinon_1.default.stub().callsFake((u) => __awaiter(void 0, void 0, void 0, function* () { return (u === udid ? { port, close } : null); }));
+        return { fn, close };
+    };
+    it('records it from its relay’s port, and this server’s own phone from its own stream', () => __awaiter(void 0, void 0, void 0, function* () {
+        const relay = relayFor('N1', 5555);
+        const { orch, videoPipeline, ensureMjpegPortFn } = makeOrch({ nodeSourceFn: relay.fn });
+        yield orch.start({ udids: ['N1', 'L1'], actorId: 'alice' });
+        const ports = videoPipeline.startRecording
+            .getCalls()
+            .map((c) => [c.args[0].udid, c.args[0].mjpegPort]);
+        (0, chai_1.expect)(ports).to.deep.equal([
+            ['N1', 5555],
+            ['L1', 9100],
+        ]);
+        (0, chai_1.expect)(ensureMjpegPortFn.getCalls().map((c) => c.args[0])).to.deep.equal(['L1']);
+        (0, chai_1.expect)(relay.fn.getCalls().map((c) => c.args)).to.deep.equal([
+            ['N1', 'alice'],
+            ['L1', 'alice'],
+        ]);
+        const composite = videoPipeline.startComposite.firstCall.args[0].inputs.map((i) => i.mjpegPort);
+        (0, chai_1.expect)(composite).to.deep.equal([5555, 9100]);
+    }));
+    it('closes the relay once the recording has stopped', () => __awaiter(void 0, void 0, void 0, function* () {
+        const relay = relayFor('N1', 5555);
+        const store = rowStore();
+        const { orch } = makeOrch({ nodeSourceFn: relay.fn, store });
+        const { groupId } = yield orch.start({ udids: ['N1'], actorId: 'alice' });
+        (0, chai_1.expect)(relay.close.called).to.equal(false);
+        yield orch.stop(groupId);
+        (0, chai_1.expect)(relay.close.calledOnce).to.equal(true);
+    }));
+    it('closes the relay when that phone’s recording can’t start', () => __awaiter(void 0, void 0, void 0, function* () {
+        const relay = relayFor('N1', 5555);
+        const videoPipeline = {
+            startRecording: sinon_1.default.stub().rejects(new Error('ffmpeg would not start')),
+            stopRecording: sinon_1.default.stub().resolves('/tmp/x.mp4'),
+            startComposite: sinon_1.default.stub().resolves(),
+            stopComposite: sinon_1.default.stub().resolves(null),
+        };
+        const { orch } = makeOrch({ nodeSourceFn: relay.fn, videoPipeline });
+        yield orch.start({ udids: ['N1'], actorId: 'alice' });
+        (0, chai_1.expect)(relay.close.calledOnce).to.equal(true);
+    }));
+});
 describe('RecordingOrchestrator.start', () => {
     // compositeOutputPath and per-device paths resolve through ArtifactStore.
     (0, artifact_store_1.useArtifactStore)();