@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,122 @@
+"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.XenonDatabase = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const lokijs_1 = __importDefault(require("lokijs"));
+// database class singleton
+class XenonDatabase {
+    static get DeviceModel() {
+        return XenonDatabase.getDeviceModel();
+    }
+    static get PendingSessionsModel() {
+        return XenonDatabase.getPendingSessionsModel();
+    }
+    static get CLIArgs() {
+        return XenonDatabase.getCLIArgs();
+    }
+    static get db() {
+        return XenonDatabase.getDB();
+    }
+    constructor() {
+        this._dbList = [];
+        logger_1.default.info('Initializing database');
+        XenonDatabase._instance = this;
+    }
+    static instance() {
+        return XenonDatabase._instance || new XenonDatabase();
+    }
+    static dbname() {
+        const appium_home = process.env.APPIUM_HOME || './temp-appium';
+        const isTest = process.env.NODE_ENV === 'test';
+        const dbFile = isTest ? `xenon-test-${process.pid}.json` : 'xenon-db.json';
+        return `${appium_home}/${dbFile}`;
+    }
+    static getDeviceModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield XenonDatabase.getDB();
+            return db.getCollection('devices') || db.addCollection('devices');
+        });
+    }
+    static getPendingSessionsModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield XenonDatabase.getDB();
+            return db.getCollection('pending-sessions') || db.addCollection('pending-sessions');
+        });
+    }
+    static getCLIArgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield XenonDatabase.getDB();
+            return db.getCollection('cliArgs') || db.addCollection('cliArgs');
+        });
+    }
+    static initCollections(db) {
+        db.addCollection('devices');
+        db.addCollection('pending-sessions');
+        db.addCollection('cliArgs');
+    }
+    static getDB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingDb = XenonDatabase.instance()._dbList.find((db) => db.dbname === XenonDatabase.dbname());
+            if (existingDb)
+                return existingDb.db;
+            logger_1.default.debug(`Creating new database: ${XenonDatabase.dbname()}`);
+            const db = yield new Promise((resolve, reject) => {
+                const isTest = process.env.NODE_ENV === 'test';
+                const db = new lokijs_1.default(XenonDatabase.dbname(), {
+                    autoload: !isTest,
+                });
+                if (isTest) {
+                    XenonDatabase.initCollections(db);
+                    resolve(db);
+                    return;
+                }
+                db.on('autoload', () => {
+                    logger_1.default.info('Database autoloaded');
+                });
+                db.on('error', (err) => {
+                    logger_1.default.error(`Error in database: ${err}`);
+                    reject(err);
+                });
+                db.on('loaded', () => {
+                    logger_1.default.info('Database loaded');
+                    XenonDatabase.initCollections(db);
+                    resolve(db);
+                });
+                db.on('flushChanges', () => {
+                    logger_1.default.info('Database changes flushed');
+                });
+                db.on('close', () => {
+                    logger_1.default.info('Database closed');
+                });
+            });
+            XenonDatabase.instance()._dbList.push({ dbname: XenonDatabase.dbname(), db });
+            return db;
+        });
+    }
+    static reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (XenonDatabase._instance) {
+                console.log(`[XenonDatabase] Resetting ${XenonDatabase._instance._dbList.length} databases`);
+                for (const dbInfo of XenonDatabase._instance._dbList) {
+                    dbInfo.db.collections.forEach((c) => {
+                        console.log(`[XenonDatabase] Removing data from collection: ${c.name}`);
+                        c.removeDataOnly();
+                    });
+                }
+            }
+        });
+    }
+}
+exports.XenonDatabase = XenonDatabase;

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

@@ -0,0 +1,320 @@
+"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.removeDevice = removeDevice;
+exports.removeDevicesByHost = removeDevicesByHost;
+exports.addNewDevice = addNewDevice;
+exports.setSimulatorState = setSimulatorState;
+exports.getAllDevices = getAllDevices;
+exports.getDevices = getDevices;
+exports.getDevice = getDevice;
+exports.updatedAllocatedDevice = updatedAllocatedDevice;
+exports.updateDeviceProgress = updateDeviceProgress;
+exports.updateCmdExecutedTime = updateCmdExecutedTime;
+exports.userBlockDevice = userBlockDevice;
+exports.userUnblockDevice = userUnblockDevice;
+exports.blockDevice = blockDevice;
+exports.unblockDevice = unblockDevice;
+exports.unblockDeviceMatchingFilter = unblockDeviceMatchingFilter;
+exports.reserveDevice = reserveDevice;
+exports.releaseReservation = releaseReservation;
+exports.isDeviceReserved = isDeviceReserved;
+exports.getReservedDevices = getReservedDevices;
+exports.cleanExpiredReservations = cleanExpiredReservations;
+exports.updateDeviceTags = updateDeviceTags;
+const logger_1 = __importDefault(require("../logger"));
+const device_utils_1 = require("../device-utils");
+const device_store_1 = require("./device-store");
+const typedi_1 = require("typedi");
+const CircuitBreaker_1 = require("./CircuitBreaker");
+const NotificationService_1 = require("../services/NotificationService");
+const SocketServer_1 = require("../services/SocketServer");
+// Use a Proxy to ensure we're always using the latest store from the factory,
+// which is critical for test isolation when the factory cache is cleared.
+const store = new Proxy({}, {
+    get: (target, prop) => {
+        return device_store_1.DeviceStoreFactory.getStore()[prop];
+    },
+});
+function removeDevice(devices) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const device of devices) {
+            logger_1.default.info(`Removing device ${device.udid} from host ${device.host}`);
+            yield store.removeDevices({ udid: device.udid, host: device.host });
+            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', device);
+            typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_removed', device);
+        }
+    });
+}
+function removeDevicesByHost(host) {
+    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 });
+    });
+}
+function addNewDevice(devices, host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const normalizedDevices = devices.map((device) => {
+            const d = Object.assign({}, device);
+            if (d.host === undefined && host !== undefined)
+                d.host = host;
+            return Object.assign({ userBlocked: false, offline: false }, d);
+        });
+        const added = yield store.addDevices(normalizedDevices);
+        // Notify for new devices
+        for (const device of added) {
+            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_new', device);
+            typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_added', device);
+        }
+        logger_1.default.debug(`Sync: Added ${added.length} new devices to store`);
+        return added;
+    });
+}
+function setSimulatorState(devices) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allInStore = yield store.getAllDevices();
+        const simMap = new Map(allInStore.filter((d) => d.deviceType === 'simulator').map((d) => [d.udid, d]));
+        for (const device of devices) {
+            if (device.deviceType !== 'simulator')
+                continue;
+            const found = simMap.get(device.udid);
+            if (found && found.state !== device.state) {
+                logger_1.default.info(`Updating Simulator ${device.udid} state: ${found.state} -> ${device.state}`);
+                yield store.updateDevice(device.udid, device.host, { state: device.state });
+            }
+        }
+    });
+}
+function getAllDevices() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield store.getAllDevices();
+    });
+}
+function getDevices(filterOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const devices = yield store.getDevices(filterOptions);
+        // Principal Intelligence: Multi-layered Reliability Filter
+        const breaker = typedi_1.Container.get(CircuitBreaker_1.CircuitBreaker);
+        return devices.filter((device) => {
+            // 1. Host Stability (Circuit Breaker)
+            if (breaker.isOpen(device.host))
+                return false;
+            // 2. Device Health (Proactive Status)
+            // Only exclude if healthStatus is explicitly defined and not 'Healthy'
+            if (device.healthStatus && device.healthStatus !== 'Healthy') {
+                logger_1.default.debug(`[DeviceService] Skipping unhealthy device ${device.udid}: ${device.healthCheckError}`);
+                return false;
+            }
+            return true;
+        });
+    });
+}
+/**
+ * Find device matching the filter options
+ * @param filterOptions IDeviceFilterOptions
+ * @returns IDevice | undefined
+ */
+function getDevice(filterOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const devices = yield getDevices(filterOptions);
+        // log.debug(`getDevice devices: ${JSON.stringify(devices)}`);
+        if (devices.length === 0) {
+            return undefined;
+        }
+        else {
+            return devices[0];
+        }
+    });
+}
+function updatedAllocatedDevice(device, updateData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info(`Updating allocated device: ${device.udid}`);
+        yield store.updateDevice(device.udid, device.host, updateData);
+    });
+}
+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}`);
+        yield store.updateDevice(udid, host, Object.assign({ sessionProgress: progress }, extra));
+        // Emit progress update via socket
+        typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_progress', Object.assign({ udid,
+            host,
+            progress }, extra));
+    });
+}
+function updateCmdExecutedTime(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.updateDevices({ session_id: sessionId }, (device) => {
+            device.lastCmdExecutedAt = new Date().getTime();
+        });
+    });
+}
+/**
+ * Apply user blocking device. Device busy status will not be affected.
+ * @param udid string
+ * @param host string
+ */
+function userBlockDevice(udid, host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.updateDevice(udid, host, { userBlocked: true });
+    });
+}
+function userUnblockDevice(udid, host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.updateDevice(udid, host, { userBlocked: false });
+    });
+}
+/**
+ * Block device from being allocated to a session. Device busy status will be set to true.
+ * @param udid
+ * @param host
+ */
+function blockDevice(udid, host, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield store.updateDevice(udid, host, {
+            busy: true,
+            lastCmdExecutedAt: undefined,
+            sessionProgress: '',
+            session_id: sessionId || null,
+        });
+        typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_blocked', {
+            udid,
+            host,
+            session_id: sessionId,
+        });
+    });
+}
+function unblockDevice(udid, host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield unblockDeviceMatchingFilter({ udid, host });
+    });
+}
+function unblockDeviceMatchingFilter(filter) {
+    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}`);
+                typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_unblocked', {
+                    udid: device.udid,
+                    host: device.host,
+                });
+            }))).catch((error) => {
+                logger_1.default.error(`Unable to unblock device: ${error}`);
+            });
+        }
+    });
+}
+/**
+ * Reserve a device for exclusive manual use
+ * @param udid Device UDID
+ * @param host Device host
+ * @param reservedBy Username or identifier
+ * @param durationMs Duration in milliseconds
+ * @param reason Optional reservation reason
+ */
+function reserveDevice(udid, host, reservedBy, durationMs, reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const reservedUntil = Date.now() + durationMs;
+        logger_1.default.info(`Reserving device ${udid} for ${reservedBy} until ${new Date(reservedUntil).toISOString()}`);
+        yield store.updateDevice(udid, host, {
+            reservedBy,
+            reservedUntil,
+            reservationReason: reason,
+        });
+    });
+}
+/**
+ * Release a device reservation
+ * @param udid Device UDID
+ * @param host Device host
+ */
+function releaseReservation(udid, host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info(`Releasing reservation for device ${udid}`);
+        yield store.updateDevice(udid, host, {
+            reservedBy: null,
+            reservedUntil: null,
+            reservationReason: null,
+        });
+    });
+}
+/**
+ * Check if a device is currently reserved
+ * @param device The device to check
+ * @returns true if device is reserved and reservation has not expired
+ */
+function isDeviceReserved(device) {
+    if (!device.reservedUntil)
+        return false;
+    return Date.now() < device.reservedUntil;
+}
+/**
+ * Get all currently reserved devices
+ * @returns Array of reserved devices
+ */
+function getReservedDevices() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allDevices = yield store.getAllDevices();
+        return allDevices.filter(isDeviceReserved);
+    });
+}
+/**
+ * Clean up expired reservations
+ */
+function cleanExpiredReservations() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allDevices = yield store.getAllDevices();
+        const expiredReservations = allDevices.filter((device) => {
+            return device.reservedUntil && Date.now() >= device.reservedUntil;
+        });
+        for (const device of expiredReservations) {
+            logger_1.default.info(`Reservation expired for device ${device.udid}, releasing...`);
+            yield releaseReservation(device.udid, device.host);
+        }
+        if (expiredReservations.length > 0) {
+            logger_1.default.info(`Cleaned ${expiredReservations.length} expired reservations`);
+        }
+    });
+}
+/**
+ * Update tags for a device
+ * @param udid string
+ * @param host string
+ * @param tags string[]
+ */
+function updateDeviceTags(udid, host, tags) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info(`Updating tags for device ${udid}: ${tags.join(', ')}`);
+        yield store.updateDevice(udid, host, { tags });
+    });
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });