@xenon-device-management/xenon 2.14.0 → 2.15.0

package/lib/src/services/healing/resilioPath.js

@@ -0,0 +1,274 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_LEAD = exports.MIN_SCORE = exports.RESILIO_PATH_FORMAT = void 0;
+exports.resilioPathOf = resilioPathOf;
+exports.isResilioPath = isResilioPath;
+exports.findLearntElement = findLearntElement;
+exports.nearestElement = nearestElement;
+exports.locatorsSelectingOnly = locatorsSelectingOnly;
+exports.contradictsSelector = contradictsSelector;
+const xmldom_1 = require("@xmldom/xmldom");
+const resiliotree_1 = require("resiliotree");
+const xpath_1 = require("xpath");
+/**
+ * The Resilio healing tier's view of a page source: an element's path from
+ * the root of the driver's element tree, as resiliotree compares paths.
+ *
+ * The page source is parsed as the XML it is. Through 2.14 it went through
+ * resiliotree's HTML parser, which lowercases every tag
+ * (`android.widget.button`, which the drivers' XPath doesn't match) and nests
+ * every element written `<x/>` around its next siblings.
+ *
+ * A path is stored with the selector's fingerprint (`LocatorEtalon.path`).
+ * Each node keeps what resiliotree compares (tag, id, labels, index, other
+ * attributes), not its children or text, so a path is a few kilobytes.
+ */
+/** Marks a path made here. A path without it (an HTML parse, before 2.15) is not used. */
+exports.RESILIO_PATH_FORMAT = 'page-source-1';
+/**
+ * How sure Resilio must be. An element that kept its id scores about 0.99
+ * after moving anywhere in the tree; once its id changed, or it is gone, the
+ * best element scores about 0.55, and a neighbour of the same type comes
+ * within a few hundredths of it. Below this, or with a second element as
+ * close as MIN_LEAD, the next tier decides.
+ */
+exports.MIN_SCORE = 0.8;
+exports.MIN_LEAD = 0.05;
+function platformOf(pageSource) {
+    if (/<XCUIElementType/.test(pageSource))
+        return 'ios';
+    if (/<hierarchy[\s>]/.test(pageSource))
+        return 'android';
+    return 'other';
+}
+const isElement = (n) => !!n && n.nodeType === 1;
+function childElements(el) {
+    const out = [];
+    for (let c = el.firstChild; c; c = c.nextSibling)
+        if (isElement(c))
+            out.push(c);
+    return out;
+}
+/**
+ * One element as a resiliotree node, without children. The platform decides
+ * what its id is: Android's resource-id, iOS's name, else `id`.
+ */
+function nodeBuilderFor(el, index, platform) {
+    const attributes = new Map();
+    for (let i = 0; i < el.attributes.length; i++) {
+        attributes.set(el.attributes[i].name, el.attributes[i].value);
+    }
+    const builder = new resiliotree_1.NodeBuilder().setTag(el.tagName).setIndex(index);
+    if (platform === 'android')
+        builder.setAndroidAttributes(attributes);
+    else if (platform === 'ios')
+        builder.setIOSAttributes(attributes);
+    else
+        builder.setAttributes(attributes);
+    return builder;
+}
+function parse(pageSource) {
+    return new xmldom_1.DOMParser({
+        errorHandler: { warning: () => { }, error: () => { }, fatalError: () => { } },
+    }).parseFromString(pageSource, 'text/xml');
+}
+/** The page source as a resiliotree tree, each node knowing its element. */
+function treeOf(pageSource) {
+    const doc = parse(pageSource);
+    const top = doc === null || doc === void 0 ? void 0 : doc.documentElement;
+    if (!isElement(top))
+        return null;
+    const platform = platformOf(pageSource);
+    const elementOf = new Map();
+    const build = (el, index) => {
+        const builder = nodeBuilderFor(el, index, platform);
+        childElements(el).forEach((child, i) => builder.addChild(build(child, i)));
+        const node = builder.build();
+        elementOf.set(node, el);
+        return node;
+    };
+    return { root: build(top, 0), elementOf };
+}
+function compact(node) {
+    const _a = node.toJSON(), { children: _children, innerText: _text } = _a, rest = __rest(_a, ["children", "innerText"]);
+    return rest;
+}
+/**
+ * The path of an element of a parsed page source (an xmldom Element, as the
+ * Fuzzy XML and Resilio tiers find them), from the root of the page source.
+ * `pageSource` decides the platform. Null for anything that isn't such an
+ * element.
+ */
+function resilioPathOf(element, pageSource) {
+    if (!isElement(element))
+        return null;
+    const platform = platformOf(pageSource);
+    const lineage = [];
+    for (let el = element; isElement(el); el = el.parentNode)
+        lineage.unshift(el);
+    const nodes = lineage.map((el) => {
+        const parent = el.parentNode;
+        const index = isElement(parent) ? childElements(parent).indexOf(el) : 0;
+        return compact(nodeBuilderFor(el, index, platform).build());
+    });
+    return { format: exports.RESILIO_PATH_FORMAT, nodes };
+}
+/** Whether `path` is one made here (not an older HTML parse). */
+function isResilioPath(path) {
+    return (!!path &&
+        typeof path === 'object' &&
+        path.format === exports.RESILIO_PATH_FORMAT &&
+        Array.isArray(path.nodes) &&
+        path.nodes.length > 0);
+}
+/** Attributes that say which element an element is, not where it is or what state it is in. */
+const IDENTITY_ATTRIBUTES = new Set([
+    'resource-id',
+    'content-desc',
+    'text',
+    'name',
+    'label',
+    'value',
+    'id',
+    'hint',
+    'accessibility-id',
+]);
+/**
+ * The element of the page source that the driver found, from its tag and the
+ * attributes Xenon read from it (`name`/`value` pairs: resource-id, text,
+ * name, label, ..., and x, y, width, height). The element of that tag with
+ * the most of them, among those that share at least one identity attribute or
+ * the whole rect with it: the page source is read after the find answered,
+ * so the screen may have changed, and a size alone names nothing. Null when
+ * none qualifies, or two qualify equally well.
+ */
+function findLearntElement(pageSource, nodeName, attributes) {
+    const doc = parse(pageSource);
+    if (!isElement(doc === null || doc === void 0 ? void 0 : doc.documentElement))
+        return null;
+    const tag = (nodeName || '').toLowerCase();
+    const anyTag = !tag || tag === 'xcuielementtypeany' || tag === 'unknown';
+    const wanted = new Map(attributes.map((a) => [a.name.toLowerCase(), String(a.value)]));
+    const rect = ['x', 'y', 'width', 'height'].map((k) => wanted.get(k));
+    const hasRect = rect.every((v) => v !== undefined);
+    /** How many of the attributes `el` shares, or 0 when it shares no identity and not the rect. */
+    const matchesOf = (el) => {
+        let all = 0;
+        let identity = 0;
+        for (const [name, value] of wanted) {
+            if (el.getAttribute(name) !== value)
+                continue;
+            all++;
+            if (IDENTITY_ATTRIBUTES.has(name))
+                identity++;
+        }
+        // Android writes a rect as bounds="[x1,y1][x2,y2]"; iOS as x, y, width, height.
+        let wholeRect = hasRect && ['x', 'y', 'width', 'height'].every((k, i) => el.getAttribute(k) === rect[i]);
+        const bounds = el.getAttribute('bounds');
+        if (bounds && hasRect) {
+            const [x, y, w, h] = rect.map(Number);
+            if (bounds === `[${x},${y}][${x + w},${y + h}]`) {
+                all++;
+                wholeRect = true;
+            }
+        }
+        return identity > 0 || wholeRect ? all : 0;
+    };
+    let best = null;
+    let bestCount = 0;
+    let tie = false;
+    const walk = (el) => {
+        if (anyTag || el.tagName.toLowerCase() === tag) {
+            const n = matchesOf(el);
+            if (n > bestCount) {
+                best = el;
+                bestCount = n;
+                tie = false;
+            }
+            else if (n > 0 && n === bestCount) {
+                tie = true;
+            }
+        }
+        childElements(el).forEach(walk);
+    };
+    walk(doc.documentElement);
+    return tie ? null : best;
+}
+/**
+ * The element of `pageSource` at the end of the path most like `path`, and
+ * how alike they are (0 to 1). Null when no element scores MIN_SCORE, or
+ * another comes within MIN_LEAD of the best: Resilio then has no answer.
+ */
+function nearestElement(path, pageSource) {
+    const tree = treeOf(pageSource);
+    if (!tree)
+        return null;
+    const finder = new resiliotree_1.PathFinder(new resiliotree_1.LCSPathDistance(), new resiliotree_1.HeuristicNodeDistance());
+    // resiliotree scores an element once for each leaf below it, so an element
+    // holding others (a list row) comes back several times at one score. Every
+    // result, best first, and the best of each element.
+    const scored = finder.find(resiliotree_1.Path.fromJSON(path), tree.root, Number.MAX_SAFE_INTEGER);
+    const best = scored[0];
+    if (!best || best.score < exports.MIN_SCORE)
+        return null;
+    const second = scored.find((s) => s.value !== best.value);
+    if (second && best.score - second.score < exports.MIN_LEAD)
+        return null;
+    const element = tree.elementOf.get(best.value);
+    return element ? { element, score: best.score } : null;
+}
+/**
+ * The locators among `candidates` that select `element` and nothing else in
+ * its page source. A driver answers a find with the first match, so a
+ * locator that also matches an element before it would hand back that one.
+ */
+function locatorsSelectingOnly(element, candidates) {
+    const doc = element.ownerDocument;
+    return candidates.filter((xpath) => {
+        try {
+            const found = (0, xpath_1.select)(xpath, doc);
+            return Array.isArray(found) && found.length === 1 && found[0] === element;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+/** The text-like attributes a selector can state that the element it means must have. */
+const STATED_ATTRIBUTES = 'text|content-desc|label|name|value';
+/**
+ * Whether `element` has, for an attribute the XPath `selector` states (the
+ * text, description, label, name or value), something other than what it
+ * says: `@text='OK'` on an element reading "Delete". Resilio compares paths,
+ * in which a changed text weighs little, so a dialog's OK button that now
+ * reads Delete would otherwise be healed to. A stated attribute may belong to
+ * another element of the XPath (an ancestor, a sibling); Resilio then
+ * declines a heal it could have made, and the next tier decides.
+ */
+function contradictsSelector(element, strategy, selector) {
+    if (strategy !== 'xpath' || typeof selector !== 'string')
+        return false;
+    const valueOf = (name) => { var _a; return (_a = element.getAttribute(name)) !== null && _a !== void 0 ? _a : ''; };
+    const equals = new RegExp(`@(${STATED_ATTRIBUTES})\\s*=\\s*(['"])(.*?)\\2`, 'g');
+    for (const [, name, , value] of selector.matchAll(equals)) {
+        if (valueOf(name) !== value)
+            return true;
+    }
+    const contains = new RegExp(`contains\\(\\s*@(${STATED_ATTRIBUTES})\\s*,\\s*(['"])(.*?)\\2\\s*\\)`, 'g');
+    for (const [, name, , value] of selector.matchAll(contains)) {
+        if (!valueOf(name).includes(value))
+            return true;
+    }
+    return false;
+}

package/lib/src/services/logcat/SessionDeviceLogs.js

@@ -0,0 +1,271 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionDeviceLogs = exports.WRITE_BATCH = exports.FLUSH_INTERVAL_MS = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const prisma_1 = require("../../prisma");
+const PluginContext_1 = require("../../PluginContext");
+const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
+const LogcatStreamService_1 = require("../../device-managers/android/LogcatStreamService");
+const adbForPhone_1 = require("../network/adbForPhone");
+const deviceLogBook_1 = require("./deviceLogBook");
+/** How often a session's new lines are written. */
+exports.FLUSH_INTERVAL_MS = 5000;
+/** Lines per write, and how many waiting lines start one before the interval. */
+exports.WRITE_BATCH = 500;
+/** The phone's `date`, read once a session; one that hangs this long is unknown. */
+const CLOCK_TIMEOUT_MS = 5000;
+/** Waits before opening the phone's log stream again: doubling from the first, up to the last. */
+const RETRY_FIRST_MS = 1000;
+const RETRY_MAX_MS = 30000;
+/**
+ * The session page's Device logs for a session on this server's own Android
+ * phone: its lines from start to end, each once, with its own time and level,
+ * up to a limit (DeviceLogBook).
+ *
+ * The session listens to the phone's log stream (LogcatStreamService, one
+ * `adb logcat` per phone, which the device page's Logs viewer may share) from
+ * EventManager's start, once the session's row exists, to its stop, which
+ * every ending reaches. While it listens, the stream has a viewer, so its idle
+ * stop leaves it running; afterwards it stops 30 s after its last viewer, as
+ * ever. The session never stops or restarts it. If the stream ends (the phone
+ * restarted, or was unplugged), the session opens it again and notes the gap.
+ *
+ * Until 2.14 each recorded command dumped the last 500 lines (`logcat -d`),
+ * kept the last 100 and skipped as many as the previous dump had given, so
+ * after the first command nothing more was ever saved, each line stamped with
+ * the time it was saved.
+ */
+let SessionDeviceLogs = class SessionDeviceLogs {
+    constructor() {
+        this.log = logger_1.default.scope('DeviceLogs');
+        this.running = new Map();
+    }
+    /** Whether a session on this phone is recorded: an Android phone (or emulator) this server drives. */
+    appliesTo(device) {
+        var _a;
+        if (!device || device.cloud)
+            return false;
+        if (String((_a = device.platform) !== null && _a !== void 0 ? _a : '').toLowerCase() !== 'android')
+            return false;
+        // A node's phone isn't reachable with this server's adb; the node has
+        // the session, and no row for it.
+        const ctx = this.context();
+        return (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(ctx.pluginArgs, ctx.port), ctx.nodeId, device);
+    }
+    /**
+     * Starts recording the session's device log. Resolves once it listens to
+     * the phone's stream (or is waiting to try again); callers needn't wait.
+     */
+    start({ sessionId, device, since }) {
+        var _a, _b;
+        if (this.running.has(sessionId) || !this.appliesTo(device))
+            return Promise.resolve();
+        const entry = {
+            udid: device.udid,
+            buffer: [],
+            flushTimer: setInterval(() => void this.write(sessionId, entry), this.flushIntervalMs()),
+            writing: Promise.resolve(),
+            lastCreatedAt: 0,
+            attempts: 0,
+            stopped: false,
+        };
+        (_b = (_a = entry.flushTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.running.set(sessionId, entry);
+        this.log.info(`[${sessionId}] Recording the device log of ${device.udid}`);
+        return this.open(sessionId, entry, since !== null && since !== void 0 ? since : Date.now()).catch((err) => { var _a; return this.log.warn(`[${sessionId}] Device log not recorded: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); });
+    }
+    /** Stops listening and writes what is left. Idempotent. */
+    stop(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const entry = this.running.get(sessionId);
+            if (!entry)
+                return;
+            this.running.delete(sessionId);
+            entry.stopped = true;
+            clearInterval(entry.flushTimer);
+            if (entry.retryTimer)
+                clearTimeout(entry.retryTimer);
+            (_a = entry.remove) === null || _a === void 0 ? void 0 : _a.call(entry);
+            entry.remove = undefined;
+            if (entry.book)
+                entry.buffer.push(...entry.book.finish(new Date()));
+            yield this.write(sessionId, entry);
+        });
+    }
+    /** Whether the session is recorded here. */
+    isRecording(sessionId) {
+        return this.running.has(sessionId);
+    }
+    open(sessionId, entry, since) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let clock = null;
+            try {
+                clock = yield this.readClock(entry.udid);
+            }
+            catch (err) {
+                this.log.debug(`[${sessionId}] Can't read the clock of ${entry.udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            if (!clock) {
+                this.log.warn(`[${sessionId}] The clock of ${entry.udid} is unknown; its log lines are read as this server's time`);
+            }
+            if (entry.stopped)
+                return;
+            entry.book = new deviceLogBook_1.DeviceLogBook({ since, clock: clock !== null && clock !== void 0 ? clock : deviceLogBook_1.UNKNOWN_CLOCK });
+            yield this.listen(sessionId, entry);
+        });
+    }
+    listen(sessionId, entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            entry.retryTimer = undefined;
+            if (entry.stopped)
+                return;
+            let mux;
+            try {
+                mux = yield this.streams().start(entry.udid);
+            }
+            catch (err) {
+                if (entry.attempts === 0) {
+                    this.log.warn(`[${sessionId}] Can't open the device log of ${entry.udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. Trying again.`);
+                }
+                this.retry(sessionId, entry);
+                return;
+            }
+            // Stopped while the stream started: leave it to its own idle stop.
+            if (entry.stopped)
+                return;
+            const book = entry.book;
+            let delivered = false;
+            const remove = mux.addClient((rec) => {
+                if (rec.synthetic)
+                    return;
+                if (!delivered) {
+                    delivered = true;
+                    entry.attempts = 0;
+                }
+                const rows = book.add(rec);
+                if (rows.length === 0)
+                    return;
+                entry.buffer.push(...rows);
+                if (entry.buffer.length >= exports.WRITE_BATCH)
+                    void this.write(sessionId, entry);
+            }, 
+            // Never refused: what the session keeps is bounded by its book.
+            () => true, () => {
+                if (entry.remove === remove)
+                    entry.remove = undefined;
+                if (entry.stopped)
+                    return;
+                const note = book.interrupted(new Date());
+                // A stream that delivered nothing (a phone that's gone) isn't noted
+                // again on every try.
+                if (delivered) {
+                    entry.buffer.push(...note);
+                    this.log.info(`[${sessionId}] The device log of ${entry.udid} ended; opening it again`);
+                }
+                this.retry(sessionId, entry);
+            });
+            entry.remove = remove;
+        });
+    }
+    retry(sessionId, entry) {
+        var _a, _b;
+        if (entry.stopped || entry.retryTimer)
+            return;
+        entry.attempts += 1;
+        const delay = Math.min(this.retryFirstMs() * 2 ** (entry.attempts - 1), RETRY_MAX_MS);
+        entry.retryTimer = setTimeout(() => void this.listen(sessionId, entry), delay);
+        (_b = (_a = entry.retryTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Writes what is waiting, WRITE_BATCH rows at a time. On a failure the rows
+     * wait for the next write: the book bounds how many there can be.
+     */
+    write(sessionId, entry) {
+        entry.writing = entry.writing.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            while (entry.buffer.length > 0) {
+                const batch = entry.buffer.splice(0, exports.WRITE_BATCH);
+                // The session's rows are read in `createdAt` order, so each is a
+                // millisecond after the one before: the lines of one moment (a stack
+                // trace's) keep their order whatever the database.
+                const first = Math.max(Date.now(), entry.lastCreatedAt + 1);
+                try {
+                    yield this.writeLines(sessionId, batch, first);
+                    entry.lastCreatedAt = first + batch.length - 1;
+                }
+                catch (err) {
+                    entry.buffer.unshift(...batch);
+                    this.log.warn(`[${sessionId}] Writing ${batch.length} device log lines failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                    return;
+                }
+            }
+        }));
+        return entry.writing;
+    }
+    // ---------------------------------------------------------------------
+    // Seams. Overridden by tests; the defaults are the real thing.
+    // ---------------------------------------------------------------------
+    context() {
+        return typedi_1.Container.get(PluginContext_1.PluginContext);
+    }
+    streams() {
+        return typedi_1.Container.get(LogcatStreamService_1.LogcatStreamService);
+    }
+    flushIntervalMs() {
+        return exports.FLUSH_INTERVAL_MS;
+    }
+    retryFirstMs() {
+        return RETRY_FIRST_MS;
+    }
+    /** The phone's clock against this server's, or null if its answer isn't one. */
+    readClock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield (0, adbForPhone_1.adbForPhone)(udid);
+            const asked = Date.now();
+            // One word: the phone's shell would take a second one as a time to set.
+            const out = yield adb.adbExec(['-s', udid, 'shell', deviceLogBook_1.DEVICE_CLOCK_COMMAND], {
+                timeout: CLOCK_TIMEOUT_MS,
+            });
+            return (0, deviceLogBook_1.parseDeviceClock)(String(out !== null && out !== void 0 ? out : ''), (asked + Date.now()) / 2);
+        });
+    }
+    writeLines(sessionId, lines, firstCreatedAt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.log.createMany({
+                data: lines.map((line, i) => ({
+                    session_id: sessionId,
+                    log_type: 'DEVICE',
+                    message: line.message,
+                    timestamp: line.timestamp,
+                    createdAt: new Date(firstCreatedAt + i),
+                })),
+            });
+        });
+    }
+};
+exports.SessionDeviceLogs = SessionDeviceLogs;
+exports.SessionDeviceLogs = SessionDeviceLogs = __decorate([
+    (0, typedi_1.Service)()
+], SessionDeviceLogs);