@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/src/data-service/device-service.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeDevice = removeDevice;
-exports.removeDevicesByHost = removeDevicesByHost;
+exports.removeNodeDevices = removeNodeDevices;
 exports.addNewDevice = addNewDevice;
 exports.syncDiscoveredDevices = syncDiscoveredDevices;
 exports.setSimulatorState = setSimulatorState;
@@ -23,6 +23,7 @@ exports.filterRowsByVisibleDevice = filterRowsByVisibleDevice;
 exports.getDevices = getDevices;
 exports.getDevice = getDevice;
 exports.updatedAllocatedDevice = updatedAllocatedDevice;
+exports.claimDeviceForSession = claimDeviceForSession;
 exports.updateDeviceProgress = updateDeviceProgress;
 exports.updateCmdExecutedTime = updateCmdExecutedTime;
 exports.userBlockDevice = userBlockDevice;
@@ -30,6 +31,9 @@ exports.userUnblockDevice = userUnblockDevice;
 exports.blockDevice = blockDevice;
 exports.unblockDevice = unblockDevice;
 exports.unblockDeviceMatchingFilter = unblockDeviceMatchingFilter;
+exports.releaseSessionDevices = releaseSessionDevices;
+exports.releaseSessionDevice = releaseSessionDevice;
+exports.releasePendingClaim = releasePendingClaim;
 exports.reserveDevice = reserveDevice;
 exports.releaseReservation = releaseReservation;
 exports.isDeviceReserved = isDeviceReserved;
@@ -43,6 +47,7 @@ const typedi_1 = require("typedi");
 const CircuitBreaker_1 = require("./CircuitBreaker");
 const NotificationService_1 = require("../services/NotificationService");
 const deviceFieldOwners_1 = require("./deviceFieldOwners");
+const deviceClaims_1 = require("./deviceClaims");
 const SocketServer_1 = require("../services/SocketServer");
 const prisma_1 = require("../prisma");
 const manualLock_1 = require("../services/recording/manualLock");
@@ -63,8 +68,8 @@ const store = new Proxy({}, {
 function deviceScope(udid, teamId) {
     return teamId === undefined ? { udid } : { udid, teamId };
 }
-function removeDevice(devices) {
-    return __awaiter(this, void 0, void 0, function* () {
+function removeDevice(devices_1) {
+    return __awaiter(this, arguments, void 0, function* (devices, options = {}) {
         for (const device of devices) {
             logger_1.default.info(`Removing device ${device.udid} from host ${device.host}`);
             const socket = typedi_1.Container.get(SocketServer_1.SocketServer);
@@ -75,18 +80,44 @@ function removeDevice(devices) {
             const team = socket.hasScopedDashboard()
                 ? yield typedi_1.Container.get(DeviceTeamResolver_1.DeviceTeamResolver).resolve(device.udid)
                 : undefined;
-            yield store.removeDevices({ udid: device.udid, host: device.host });
+            yield store.removeDevices({ udid: device.udid, host: device.host }, options);
             typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', device);
             void socket.emitToDashboardForDevices('device_removed', device, deviceScope(device.udid, (team === null || team === void 0 ? void 0 : team.known) ? team.teamId : undefined));
         }
     });
 }
-function removeDevicesByHost(host) {
+/**
+ * The phones a node asks the hub to forget (`POST /register`, `type=remove`
+ * for one phone, `type=unregister` when it shuts down). Only that node's: the
+ * rows its `nodeId` names when it sends one, else those filed under exactly
+ * its `host`, and never one of this server's own (`isOwn`). A udid-less
+ * `remove` names no phone and takes nothing.
+ *
+ * The store matched a host that isn't a URL as a substring, and a remove with
+ * no host by udid alone, so a node (an older one sends a bare IP) could delete
+ * the hub's own phones, or another node's. Returns how many rows went.
+ */
+function removeNodeDevices(removals, isOwn) {
     return __awaiter(this, void 0, void 0, function* () {
-        logger_1.default.info(`Removing all devices from host ${host}`);
-        // We can't easily dispatch events here without fetching first,
-        // but for now we'll stick to single device removal alerting
-        yield store.removeDevices({ host });
+        const all = yield store.getAllDevices();
+        const gone = new Map();
+        for (const removal of removals) {
+            if (!removal.nodeId && !removal.host)
+                continue;
+            for (const device of all) {
+                if (isOwn(device))
+                    continue;
+                if (removal.udid !== undefined && device.udid !== removal.udid)
+                    continue;
+                const theirs = removal.nodeId
+                    ? device.nodeId === removal.nodeId
+                    : device.host === removal.host;
+                if (theirs)
+                    gone.set(`${device.udid}\u0000${device.host}`, device);
+            }
+        }
+        yield removeDevice([...gone.values()].map((d) => ({ udid: d.udid, host: d.host })), { exactHost: true });
+        return gone.size;
     });
 }
 function addNewDevice(devices_1, host_1) {
@@ -237,6 +268,22 @@ function updatedAllocatedDevice(device, updateData) {
         yield store.updateDevice(device.udid, device.host, updateData);
     });
 }
+/**
+ * Put a created session on the claim its phone was allocated with
+ * (`device.claimedAt`), writing `updateData` with it. False, and nothing
+ * written, when another session holds the phone now: its claim is not
+ * overwritten.
+ */
+function claimDeviceForSession(device, sessionId, updateData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const claimed = yield store.claimForSession(device.udid, device.host, device.claimedAt, sessionId, updateData);
+        if (!claimed) {
+            logger_1.default.error(`Session ${sessionId} was created on ${device.udid} at ${device.host}, but another ` +
+                'session has claimed the device since. Leaving that claim in place.');
+        }
+        return claimed;
+    });
+}
 function updateDeviceProgress(udid_1, host_1, progress_1) {
     return __awaiter(this, arguments, void 0, function* (udid, host, progress, extra = {}) {
         logger_1.default.debug(`[${udid}] progress: ${progress}`);
@@ -249,9 +296,9 @@ function updateDeviceProgress(udid_1, host_1, progress_1) {
 }
 function updateCmdExecutedTime(sessionId) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield store.updateDevices({ session_id: sessionId }, (device) => {
-            device.lastCmdExecutedAt = new Date().getTime();
-        });
+        // One conditional write. Reading the row and writing all of it back would
+        // put back a claim released, or a node's report taken, in between.
+        yield store.touchSession(sessionId, new Date().getTime());
     });
 }
 /**
@@ -297,53 +344,109 @@ function blockDevice(udid, host, sessionId) {
         }, { udid });
     });
 }
+/**
+ * Free a phone whatever holds it: a manual hold (a preview, a recording) or
+ * an admin's release. A session's phone is released with
+ * releaseSessionDevices / releaseSessionDevice / releasePendingClaim instead,
+ * keyed on its claim.
+ *
+ * With a host, only that row. A hub also stores its nodes' phones, and a node
+ * on the same machine lists the same udid under its own host: matching the
+ * udid alone freed that row too, with a session on it.
+ */
 function unblockDevice(udid, host) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Prefer udid-only: device.host can be `http://IP:port` while callers pass
-        // `127.0.0.1` / bindHostOrIp, and a host mismatch silently no-ops (0 rows).
-        // UDID uniquely identifies a device in this store.
-        const byUdid = yield store.getDevices({ udid });
-        if (byUdid.length > 0) {
-            yield unblockDeviceMatchingFilter({ udid });
-            return;
+        const devices = yield store.findDevices(host === undefined ? { udid } : { udid, host });
+        yield forceRelease(devices);
+    });
+}
+/** unblockDevice for every phone matching `filter` (getDevices' filter). */
+function unblockDeviceMatchingFilter(filter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield forceRelease(yield store.getDevices(filter));
+    });
+}
+function forceRelease(devices) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(devices.map((device) => __awaiter(this, void 0, void 0, function* () {
+            const totalUtilization = utilizationAfter(device);
+            yield (0, device_utils_1.setUtilizationTime)(device.udid, totalUtilization);
+            yield store.updateDevice(device.udid, device.host, Object.assign(Object.assign({}, deviceClaims_1.CLAIM_RESET), { busy: false, totalUtilizationTimeMilliSec: totalUtilization }));
+            logger_1.default.debug(`Unblocked device ${device.udid}`);
+            emitUnblocked(device);
+        }))).catch((error) => {
+            logger_1.default.error(`Unable to unblock device: ${error}`);
+        });
+    });
+}
+/**
+ * End a session's claim on its phone, keyed on the session's id: a release
+ * for a session that has ended, arriving after its phone went to another one,
+ * matches nothing. The phone stays busy while its node still reports it busy
+ * (deviceClaims.ts). Never throws.
+ */
+function releaseSessionDevices(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const rows = new Map();
+            for (const device of [
+                ...(yield store.findDevices({ claimSessionId: sessionId })),
+                ...(yield store.findDevices({ session_id: sessionId })),
+            ]) {
+                rows.set(`${device.udid}@${device.host}`, device);
+            }
+            yield Promise.all([...rows.values()].map((device) => releaseClaimOn(device, { sessionId })));
         }
-        if (host) {
-            yield unblockDeviceMatchingFilter({ udid, host });
+        catch (error) {
+            logger_1.default.error(`Unable to release the device of session ${sessionId}: ${error}`);
         }
     });
 }
-function unblockDeviceMatchingFilter(filter) {
+/** releaseSessionDevices for one phone. */
+function releaseSessionDevice(udid, host, sessionId) {
     return __awaiter(this, void 0, void 0, function* () {
-        const devices = yield store.getDevices(filter);
-        if (devices.length > 0) {
-            yield Promise.all(devices.map((device) => __awaiter(this, void 0, void 0, function* () {
-                const sessionStart = device.sessionStartTime;
-                const currentTime = new Date().getTime();
-                let utilization = currentTime - sessionStart;
-                if (sessionStart === 0)
-                    utilization = 0;
-                const totalUtilization = device.totalUtilizationTimeMilliSec + utilization;
-                yield (0, device_utils_1.setUtilizationTime)(device.udid, totalUtilization);
-                yield store.updateDevice(device.udid, device.host, {
-                    session_id: null,
-                    busy: false,
-                    lastCmdExecutedAt: null,
-                    sessionStartTime: 0,
-                    totalUtilizationTimeMilliSec: totalUtilization,
-                    newCommandTimeout: null,
-                    sessionProgress: '',
-                });
-                logger_1.default.debug(`Unblocked device ${device.udid}`);
-                void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices('device_unblocked', {
-                    udid: device.udid,
-                    host: device.host,
-                }, deviceScope(device.udid, device.teamId));
-            }))).catch((error) => {
-                logger_1.default.error(`Unable to unblock device: ${error}`);
-            });
+        const device = yield store.findDevice({ udid, host });
+        return device ? releaseClaimOn(device, { sessionId }) : false;
+    });
+}
+/**
+ * Give back a phone allocated for a session that was never created: the
+ * pending claim it was allocated with (`claimedAt`, as the allocation read
+ * it). If that claim has gone (timed out, and the phone taken since) nothing
+ * is written.
+ */
+function releasePendingClaim(allocated) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const device = yield store.findDevice({ udid: allocated.udid, host: allocated.host });
+        return device ? releaseClaimOn(device, { claimedAt: (_a = allocated.claimedAt) !== null && _a !== void 0 ? _a : null }) : false;
+    });
+}
+function releaseClaimOn(device, ref) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const totalUtilization = utilizationAfter(device);
+        const released = yield store.releaseClaim(device.udid, device.host, ref, {
+            totalUtilizationTimeMilliSec: totalUtilization,
+        });
+        if (!released) {
+            logger_1.default.info(`Not releasing ${device.udid} at ${device.host}: it no longer holds ${JSON.stringify(ref)}`);
+            return false;
         }
+        yield (0, device_utils_1.setUtilizationTime)(device.udid, totalUtilization);
+        logger_1.default.debug(`Released ${JSON.stringify(ref)} on ${device.udid}`);
+        emitUnblocked(device);
+        return true;
     });
 }
+/** The phone's total use once the session on it now ends. */
+function utilizationAfter(device) {
+    var _a;
+    const started = device.sessionStartTime;
+    return ((_a = device.totalUtilizationTimeMilliSec) !== null && _a !== void 0 ? _a : 0) + (started ? Date.now() - started : 0);
+}
+function emitUnblocked(device) {
+    void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices('device_unblocked', { udid: device.udid, host: device.host }, deviceScope(device.udid, device.teamId));
+}
 /**
  * Reserve a device for exclusive manual use
  * @param udid Device UDID

package/lib/src/data-service/device-store.js

@@ -13,6 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceStoreFactory = void 0;
+const deviceFieldOwners_1 = require("./deviceFieldOwners");
+const deviceClaims_1 = require("./deviceClaims");
 const logger_1 = __importDefault(require("../logger"));
 const semver_1 = __importDefault(require("semver"));
 const db_1 = require("./db");
@@ -153,19 +155,37 @@ class LokiDeviceStore {
             });
         });
     }
-    updateDevices(filter, updateFn) {
+    touchSession(sessionId, at) {
         return __awaiter(this, void 0, void 0, function* () {
-            (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).update(updateFn);
+            (yield db_1.XenonDatabase.DeviceModel)
+                .chain()
+                .find({ session_id: sessionId })
+                .update((device) => {
+                device.lastCmdExecutedAt = at;
+            });
         });
     }
-    addDevices(devices) {
-        return __awaiter(this, void 0, void 0, function* () {
+    addDevices(devices_1) {
+        return __awaiter(this, arguments, void 0, function* (devices, options = {}) {
             const deviceModel = yield db_1.XenonDatabase.DeviceModel;
             const added = [];
             for (const device of devices) {
                 const existing = deviceModel.findOne({ udid: device.udid, host: device.host });
+                // A node's report (PrismaDeviceStore.addNodeReport has the rule).
+                const nodeBusy = device.busy === true;
+                if (existing && options.nodeReport) {
+                    Object.assign(existing, (0, deviceFieldOwners_1.pickNodeReportFields)(device), { nodeBusy });
+                    if (nodeBusy)
+                        existing.busy = true;
+                    else if ((0, deviceClaims_1.isUnheld)(existing))
+                        existing.busy = false;
+                    deviceModel.update(existing);
+                    continue;
+                }
                 if (!existing) {
-                    const cleanDevice = Object.assign({}, device);
+                    const cleanDevice = options.nodeReport
+                        ? Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(device)), { udid: device.udid, host: device.host, busy: nodeBusy, nodeBusy })
+                        : Object.assign({}, device);
                     if (cleanDevice.host === undefined)
                         cleanDevice.host = 'Local';
                     if (cleanDevice.userBlocked === undefined)
@@ -185,14 +205,24 @@ class LokiDeviceStore {
             return added;
         });
     }
+    // Loki's find() matches a host exactly already, so `exactHost` changes nothing here.
     removeDevices(filter) {
         return __awaiter(this, void 0, void 0, function* () {
             (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).remove();
         });
     }
-    clearStorage() {
+    clearStorage(onlyHosts) {
         return __awaiter(this, void 0, void 0, function* () {
-            (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            if (onlyHosts) {
+                model
+                    .chain()
+                    .find({ host: { $in: [...onlyHosts] } })
+                    .remove();
+            }
+            else {
+                model.removeDataOnly();
+            }
         });
     }
     findDevice(filter) {
@@ -205,8 +235,8 @@ class LokiDeviceStore {
             return (yield db_1.XenonDatabase.DeviceModel).find(filter);
         });
     }
-    findAndLockDevice(filterOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
+    findAndLockDevice(filterOptions_1) {
+        return __awaiter(this, arguments, void 0, function* (filterOptions, options = {}) {
             // Phase 2: exclude devices held by an active lease.
             const activeLeases = yield prisma_1.prisma.lease.findMany({
                 where: { status: 'active' },
@@ -216,12 +246,64 @@ class LokiDeviceStore {
             const devices = yield this.getDevices(filterOptions);
             const available = devices.find((d) => !d.busy && !d.userBlocked && !blockedKeys.has(`${d.udid}@${d.host}`));
             if (available) {
-                yield this.updateDevice(available.udid, available.host, { busy: true });
+                yield this.updateDevice(available.udid, available.host, Object.assign({ busy: true }, (options.claim ? { claimedAt: Date.now(), claimSessionId: null } : {})));
                 return available;
             }
             return null;
         });
     }
+    claimForSession(udid, host, claimedAt, sessionId, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device || device.claimSessionId != null)
+                return false;
+            if (device.claimedAt != null && device.claimedAt !== claimedAt)
+                return false;
+            Object.assign(device, update, {
+                busy: true,
+                claimSessionId: sessionId,
+                claimedAt: claimedAt !== null && claimedAt !== void 0 ? claimedAt : Date.now(),
+            });
+            model.update(device);
+            return true;
+        });
+    }
+    releaseClaim(udid, host, ref, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device || !(0, deviceClaims_1.holdsClaim)(device, ref))
+                return false;
+            Object.assign(device, update, deviceClaims_1.CLAIM_RESET);
+            if ((0, deviceClaims_1.isUnheld)(device))
+                device.busy = false;
+            model.update(device);
+            return true;
+        });
+    }
+    releaseLeaseLock(udid, host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!(device === null || device === void 0 ? void 0 : device.busy) || !(0, deviceClaims_1.isUnheld)(device))
+                return false;
+            device.busy = false;
+            model.update(device);
+            return true;
+        });
+    }
+    markNodeBusy(udid, host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device)
+                return;
+            device.nodeBusy = true;
+            device.busy = true;
+            model.update(device);
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             (yield db_1.XenonDatabase.DeviceModel)

package/lib/src/data-service/deviceClaims.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIM_RESET = exports.UNHELD = exports.NO_CLAIM = exports.PENDING_CLAIM_TIMEOUT_MS = void 0;
+exports.isPendingClaim = isPendingClaim;
+exports.pendingClaimExpired = pendingClaimExpired;
+exports.claimWhere = claimWhere;
+exports.holdsClaim = holdsClaim;
+exports.hasNoClaim = hasNoClaim;
+exports.isUnheld = isUnheld;
+exports.heldHere = heldHere;
+/**
+ * Why a phone is busy, on the server that allocates it.
+ *
+ * Allocation reads `busy` (findAndLockDevice takes a phone only where it is
+ * false, in one conditional update). On a hub a node's phone is busy for one
+ * of two reasons, each kept in its own columns so neither can erase the
+ * other:
+ *
+ * - **The claim**, this server's: `claimedAt` (when allocation took the phone)
+ *   and `claimSessionId` (the session's id, written when the session exists).
+ *   A claim with no session id yet is *pending*: its session is being
+ *   created, which can take minutes on a first driver install.
+ * - **The node's report**: `nodeBusy`, what the node last said
+ *   (`POST /xenon/api/register`). Always false for a phone this server drives.
+ *
+ * `busy` is claim OR report. No write that can clear it reads the row first:
+ *
+ * - A node reporting its phone free clears `busy` only where nothing of the
+ *   hub's holds it (UNHELD: no claim, and no hold such as a preview or a
+ *   recording in `session_id`), in one conditional update. A report sent
+ *   before the hub's claim (every 30 s by default) can no longer undo it.
+ * - A release names the claim it ends (ClaimRef): a session's id, or when a
+ *   pending claim was taken. A stale release, for a session that ended while
+ *   the phone went on to another, matches nothing. Then `busy` is cleared
+ *   only where nothing else holds the phone (UNHELD), again one conditional
+ *   update: a node still reporting it busy keeps it busy.
+ * - The idle sweeper leaves a pending claim alone until
+ *   PENDING_CLAIM_TIMEOUT_MS, whatever the new-command timeout.
+ *
+ * A server with no nodes (standalone, or a node itself) never has `nodeBusy`
+ * set, so `busy` is its claim as it always was.
+ *
+ * Only a session's allocation takes a claim. A lease locks with `busy` alone,
+ * as before; a manual hold (a preview, a recording) writes `session_id`.
+ */
+/**
+ * How long a claim may wait for its session to be created before the idle
+ * sweeper frees it: a create that never finished (the hub restarted during
+ * it, or it hung). Well past a create's own budget: the phone's wait
+ * (`deviceAvailabilityTimeoutMs`) comes before the claim, and a first
+ * UiAutomator2 or WebDriverAgent install fits in a few minutes.
+ */
+exports.PENDING_CLAIM_TIMEOUT_MS = 10 * 60000;
+/** A claim whose session is still being created. */
+function isPendingClaim(device) {
+    return device.claimedAt != null && device.claimSessionId == null;
+}
+/** A pending claim older than PENDING_CLAIM_TIMEOUT_MS. */
+function pendingClaimExpired(device, now) {
+    return isPendingClaim(device) && now - device.claimedAt > exports.PENDING_CLAIM_TIMEOUT_MS;
+}
+/** Prisma `where` (beside udid and host) for the claim `ref` names. */
+function claimWhere(ref) {
+    if ('sessionId' in ref) {
+        return {
+            OR: [{ claimSessionId: ref.sessionId }, { claimSessionId: null, session_id: ref.sessionId }],
+        };
+    }
+    if (ref.claimedAt == null)
+        return { claimSessionId: null, claimedAt: null, session_id: null };
+    return { claimSessionId: null, claimedAt: ref.claimedAt };
+}
+/** claimWhere as a predicate, for the in-memory store. */
+function holdsClaim(device, ref) {
+    if ('sessionId' in ref) {
+        return (device.claimSessionId === ref.sessionId ||
+            (device.claimSessionId == null && device.session_id === ref.sessionId));
+    }
+    if (device.claimSessionId != null)
+        return false;
+    if (ref.claimedAt == null)
+        return device.claimedAt == null && device.session_id == null;
+    return device.claimedAt === ref.claimedAt;
+}
+/** No claim of this server's on the phone, pending or not. */
+exports.NO_CLAIM = { claimSessionId: null, claimedAt: null };
+function hasNoClaim(device) {
+    return device.claimSessionId == null && device.claimedAt == null;
+}
+/**
+ * Nothing holds the phone: no claim, no session or manual hold, and no node
+ * reporting it busy. Only then may a release clear `busy`.
+ */
+exports.UNHELD = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id: null, nodeBusy: false });
+function isUnheld(device) {
+    return hasNoClaim(device) && device.session_id == null && device.nodeBusy !== true;
+}
+/**
+ * Busy for a reason this server has on record: its claim, a session or hold
+ * in `session_id`, or plain `busy` on a phone of its own. False for a node's
+ * phone busy only by the node's report (`nodeBusy`), a preview the node
+ * holds say: this server knows no holder for it, and the node, which does,
+ * judges every call forwarded there with its own guard. An ownership check
+ * reads this, not `busy`, or it fails closed on every such phone, refusing
+ * the preview's own holder. A server with no nodes never has nodeBusy, so
+ * for it this is `busy`.
+ */
+function heldHere(device) {
+    if (!device.busy)
+        return false;
+    if (device.nodeBusy !== true)
+        return true;
+    return device.session_id != null || device.claimedAt != null || device.claimSessionId != null;
+}
+/** What ending a claim resets: the claim, and the session's bookkeeping. */
+exports.CLAIM_RESET = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id: null, lastCmdExecutedAt: null, sessionStartTime: 0, newCommandTimeout: null, sessionProgress: '', owningSessionId: null, lockedAt: null });

package/lib/src/data-service/deviceFieldOwners.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DISCOVERY_FIELDS = void 0;
+exports.NODE_REPORT_FIELDS = exports.DISCOVERY_FIELDS = void 0;
 exports.pickDiscoveryFields = pickDiscoveryFields;
+exports.pickNodeReportFields = pickNodeReportFields;
 exports.discoveryChanges = discoveryChanges;
 const lodash_1 = __importDefault(require("lodash"));
 /**
@@ -12,12 +13,21 @@ const lodash_1 = __importDefault(require("lodash"));
  *
  * The periodic device sync reads every row, spends seconds in adb or simctl,
  * then writes each phone back. For a phone it already knows it may write only
- * what discovery itself observes (`discovery`). Every `runtime` column has
+ * what discovery itself observes (`discovery`). Every other column has
  * another writer: a session's lock, a preview's hold, an admin's block,
  * reservation or team, a counter, the health check. A sync that read the row
  * before one of those writes would put the old value back. That erased a live
  * preview hold on the lab, and could hand a phone in a session to a second one.
  *
+ * A hub also stores its nodes' phones, from each node's report
+ * (`POST /xenon/api/register`, NODE_REPORT_FIELDS). The report carries what
+ * the node observes of its own phone: `discovery`, and `observed` (its health,
+ * which only the server driving the phone can check). It never writes a
+ * `runtime` column: the hub's claim for a session, and the settings the hub
+ * owns for the phone (team, tags, reservation, block). Whether the node says
+ * the phone is busy goes to `nodeBusy` (`report`), never to `busy`
+ * (deviceClaims.ts).
+ *
  * Typed over every column, so a new column won't compile until it is placed.
  */
 const OWNER = {
@@ -59,8 +69,9 @@ const OWNER = {
     newCommandTimeout: 'runtime',
     owningSessionId: 'runtime',
     lockedAt: 'runtime',
+    claimSessionId: 'runtime',
+    claimedAt: 'runtime',
     userBlocked: 'runtime',
-    offline: 'runtime',
     reservationReason: 'runtime',
     reservedBy: 'runtime',
     reservedUntil: 'runtime',
@@ -68,14 +79,16 @@ const OWNER = {
     tags: 'runtime',
     totalUtilizationTimeMilliSec: 'runtime',
     total_session_count: 'runtime',
-    totalHealedCount: 'runtime',
     dashboard_link: 'runtime',
-    healthStatus: 'runtime',
-    healthCheckError: 'runtime',
-    lastHealthCheckAt: 'runtime',
-    batteryLevel: 'runtime',
-    thermalStatus: 'runtime',
-    storageFree: 'runtime',
+    offline: 'observed',
+    totalHealedCount: 'observed',
+    healthStatus: 'observed',
+    healthCheckError: 'observed',
+    lastHealthCheckAt: 'observed',
+    batteryLevel: 'observed',
+    thermalStatus: 'observed',
+    storageFree: 'observed',
+    nodeBusy: 'report',
 };
 /** The columns a sync may write to a phone it already knows. */
 exports.DISCOVERY_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[column] === 'discovery'));
@@ -83,6 +96,15 @@ exports.DISCOVERY_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[c
 function pickDiscoveryFields(data) {
     return lodash_1.default.pickBy(data, (_value, key) => exports.DISCOVERY_FIELDS.has(key));
 }
+/**
+ * The columns a hub takes from a node's report of a phone: what the node
+ * observes of it. Not `nodeBusy`, which the hub sets from the report's `busy`.
+ */
+exports.NODE_REPORT_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[column] === 'discovery' || OWNER[column] === 'observed'));
+/** Only the columns of `data` a hub takes from a node's report. */
+function pickNodeReportFields(data) {
+    return lodash_1.default.pickBy(data, (_value, key) => exports.NODE_REPORT_FIELDS.has(key));
+}
 /**
  * What a sync writes to a phone it already knows: the discovery columns whose
  * value differs from `known`, the row the sync started from. Discovery hands