@xen-orchestra/rest-api 0.11.0 → 0.12.0

package/dist/vm-templates/vm-template.controller.mjs

@@ -10,13 +10,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Example, Get, Security, Query, Request, Response, Route, Tags, Path } from 'tsoa';
 import { inject } from 'inversify';
 import { provide } from 'inversify-binding-decorators';
+import { AlarmService } from '../alarms/alarm.service.mjs';
+import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
 import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { partialVmTemplates, vmTemplate, vmTemplateIds } from '../open-api/oa-examples/vm-template.oa-example.mjs';
 let VmTemplateController = class VmTemplateController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VM-template', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "id,isDefaultTemplate,name_label"
@@ -32,6 +37,20 @@ let VmTemplateController = class VmTemplateController extends XapiXoController {
     getVmTemplate(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "b7569d99-30f8-178a-7d94-801de3e29b5b-f873abe0-b138-4995-8f6f-498b423d234d"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVmTemplateAlarms(req, id, fields, ndjson, filter, limit) {
+        const vmTemplate = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vmTemplate.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vmTemplateIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VmTemplateController.prototype, "getVmTemplate", null);
+__decorate([
+    Example(genericAlarmsExample),
+    Get('{id}/alarms'),
+    Tags('alarms'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query()),
+    __param(5, Query())
+], VmTemplateController.prototype, "getVmTemplateAlarms", null);
 VmTemplateController = __decorate([
     Route('vm-templates'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vms'),
     provide(VmTemplateController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VmTemplateController);
 export { VmTemplateController };

package/dist/vms/vm.service.mjs

@@ -1,6 +1,7 @@
 import { createLogger } from '@xen-orchestra/log';
 import { defer } from 'golike-defer';
 import { Task } from '@vates/task';
+import { VM_POWER_STATE, } from '@vates/types';
 const log = createLogger('xo:rest-api:vm-service');
 export class VmService {
     #restApi;
@@ -44,4 +45,43 @@ export class VmService {
         return xoVm.id;
     }
     create = defer(this.#create);
+    getVmsStatus(opts) {
+        const vms = this.#restApi.getObjectsByType('VM', opts);
+        let nRunning = 0;
+        let nPaused = 0;
+        let nSuspended = 0;
+        let nHalted = 0;
+        let nUnknown = 0;
+        let total = 0;
+        for (const id in vms) {
+            total++;
+            const vm = vms[id];
+            switch (vm.power_state) {
+                case VM_POWER_STATE.RUNNING:
+                    nRunning++;
+                    break;
+                case VM_POWER_STATE.HALTED:
+                    nHalted++;
+                    break;
+                case VM_POWER_STATE.PAUSED:
+                    nPaused++;
+                    break;
+                case VM_POWER_STATE.SUSPENDED:
+                    nSuspended++;
+                    break;
+                default:
+                    log.warn('Invalid VM power_state', vm.id, vm.power_state);
+                    nUnknown++;
+                    break;
+            }
+        }
+        return {
+            running: nRunning,
+            halted: nHalted,
+            paused: nPaused,
+            suspended: nSuspended,
+            unknown: nUnknown,
+            total,
+        };
+    }
 }

package/dist/xoa/xoa.service.mjs

@@ -1,22 +1,23 @@
 import groupBy from 'lodash/groupBy.js';
 import semver from 'semver';
-import { BACKUP_TYPE, HOST_POWER_STATE, VM_POWER_STATE, } from '@vates/types';
-import { asyncEach } from '@vates/async-each';
+import { BACKUP_TYPE, VM_POWER_STATE, } from '@vates/types';
 import { createLogger } from '@xen-orchestra/log';
 import { createPredicate } from 'value-matcher';
 import { extractIdsFromSimplePattern } from '@xen-orchestra/backups/extractIdsFromSimplePattern.mjs';
-import { isPromise } from 'node:util/types';
 import { noSuchObject } from 'xo-common/api-errors.js';
 import { parse } from 'xo-remote-parser';
 import { getFromAsyncCache } from '../helpers/cache.helper.mjs';
-import { isReplicaVm, isSrWritable, vmContainsNoBakTag } from '../helpers/utils.helper.mjs';
+import { isReplicaVm, isSrWritableOrIso, promiseWriteInStream, vmContainsNoBakTag } from '../helpers/utils.helper.mjs';
+import { HostService } from '../hosts/host.service.mjs';
 const log = createLogger('xo:rest-api:xoa-service');
 export class XoaService {
     #restApi;
+    #hostService;
     #dashboardAsyncCache = new Map();
     #dashboardCacheOpts;
     constructor(restApi) {
         this.#restApi = restApi;
+        this.#hostService = restApi.ioc.get(HostService);
         this.#dashboardCacheOpts = {
             timeout: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheTimeout') ?? 60000,
             expiresIn: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheExpiresIn'),
@@ -25,15 +26,12 @@ export class XoaService {
     async #getBackupRepositoriesSizeInfo() {
         const brResult = await getFromAsyncCache(this.#dashboardAsyncCache, 'backupRepositories', async () => {
             const xoApp = this.#restApi.xoApp;
-            const s3Brsize = { backups: 0 };
-            const otherBrSize = {
-                available: 0,
-                backups: 0,
-                other: 0,
-                total: 0,
-                used: 0,
-            };
+            let s3Brsize;
+            let otherBrSize;
             const backupRepositories = await xoApp.getAllRemotes();
+            if (backupRepositories.length === 0) {
+                return undefined;
+            }
             const backupRepositoriesInfo = await xoApp.getAllRemotesInfo();
             for (const backupRepository of backupRepositories) {
                 const { type } = parse(backupRepository.url);
@@ -44,17 +42,48 @@ export class XoaService {
                 const totalBackupSize = await xoApp.getTotalBackupSizeOnRemote(backupRepository.id);
                 const { available, size, used } = backupRepositoryInfo;
                 const isS3 = type === 's3';
-                const target = isS3 ? s3Brsize : otherBrSize;
-                target.backups += totalBackupSize.onDisk;
-                if (!isS3) {
-                    const _target = target;
-                    _target.available += available ?? 0;
-                    _target.other += used - totalBackupSize.onDisk;
-                    _target.total += size ?? 0;
-                    _target.used += used;
+                if (isS3) {
+                    if (s3Brsize === undefined) {
+                        s3Brsize = { size: { backups: 0 } };
+                    }
+                    s3Brsize.size.backups += totalBackupSize.onDisk;
+                }
+                else {
+                    if (otherBrSize === undefined) {
+                        otherBrSize = {
+                            size: {
+                                backups: 0,
+                                available: undefined,
+                                other: undefined,
+                                total: undefined,
+                                used: undefined,
+                            },
+                        };
+                    }
+                    if (available === undefined || size === undefined || used === undefined) {
+                        log.info('#getBackupRepositoriesSizeInfo missing info for BR:', backupRepository.id);
+                    }
+                    otherBrSize.size.backups += totalBackupSize.onDisk;
+                    if (available !== undefined) {
+                        otherBrSize.size.available = (otherBrSize.size.available ?? 0) + available;
+                    }
+                    if (used !== undefined) {
+                        otherBrSize.size.used = (otherBrSize.size.used ?? 0) + used;
+                        otherBrSize.size.other = (otherBrSize.size.other ?? 0) + (used - totalBackupSize.onDisk);
+                    }
+                    if (size !== undefined) {
+                        otherBrSize.size.total = (otherBrSize.size.total ?? 0) + size;
+                    }
                 }
             }
-            return { s3: { size: s3Brsize }, other: { size: otherBrSize } };
+            const result = {};
+            if (s3Brsize !== undefined) {
+                result.s3 = s3Brsize;
+            }
+            if (otherBrSize !== undefined) {
+                result.other = otherBrSize;
+            }
+            return result;
         }, this.#dashboardCacheOpts);
         if (brResult?.value !== undefined) {
             return { ...brResult.value, isExpired: brResult.isExpired };
@@ -71,15 +100,15 @@ export class XoaService {
     #getResourcesOverview() {
         const pools = Object.values(this.#restApi.getObjectsByType('pool'));
         const hosts = Object.values(this.#restApi.getObjectsByType('host'));
-        const writableSrs = Object.values(this.#restApi.getObjectsByType('SR', {
-            filter: isSrWritable,
+        const srs = Object.values(this.#restApi.getObjectsByType('SR', {
+            filter: isSrWritableOrIso,
         }));
-        const maxLenght = Math.max(hosts.length, writableSrs.length);
+        const maxLenght = Math.max(hosts.length, srs.length);
         const resourcesOverview = { nCpus: 0, memorySize: 0, srSize: 0 };
         for (let index = 0; index < maxLenght; index++) {
             const pool = pools[index];
             const host = hosts[index];
-            const sr = writableSrs[index];
+            const sr = srs[index];
             if (pool !== undefined) {
                 resourcesOverview.nCpus += pool.cpus.cores ?? 0;
             }
@@ -139,34 +168,16 @@ export class XoaService {
         return nHostsEol;
     }
     async #getMissingPatchesInfo() {
-        if (!(await this.#restApi.xoApp.hasFeatureAuthorization('LIST_MISSING_PATCHES'))) {
-            return {
-                hasAuthorization: false,
-            };
+        const missingPatchesInfo = await this.#hostService.getMissingPatchesInfo();
+        if (!missingPatchesInfo.hasAuthorization) {
+            return { hasAuthorization: false };
         }
-        const hosts = Object.values(this.#restApi.getObjectsByType('host'));
-        const poolsWithMissingPatches = new Set();
-        let nHostsWithMissingPatches = 0;
-        let nHostsFailed = 0;
-        await asyncEach(hosts, async (host) => {
-            const xapi = this.#restApi.xoApp.getXapi(host);
-            try {
-                const patches = await xapi.listMissingPatches(host.id);
-                if (patches.length > 0) {
-                    nHostsWithMissingPatches++;
-                    poolsWithMissingPatches.add(host.$pool);
-                }
-            }
-            catch (err) {
-                log.error('listMissingPatches failed', err);
-                nHostsFailed++;
-            }
-        });
+        const { hasAuthorization, nHostsFailed, nHostsWithMissingPatches, nPoolsWithMissingPatches } = missingPatchesInfo;
         return {
-            hasAuthorization: true,
+            hasAuthorization,
             nHostsFailed,
             nHostsWithMissingPatches,
-            nPoolsWithMissingPatches: poolsWithMissingPatches.size,
+            nPoolsWithMissingPatches,
         };
     }
     #isReplicaVmInVdb(vbds) {
@@ -207,7 +218,7 @@ export class XoaService {
     }
     #getStorageRepositoriesSizeInfo() {
         const writableSrs = this.#restApi.getObjectsByType('SR', {
-            filter: isSrWritable,
+            filter: isSrWritableOrIso,
         });
         let replicated = 0;
         let total = 0;
@@ -374,30 +385,11 @@ export class XoaService {
         }
     }
     #getHostsStatus() {
-        const hosts = this.#restApi.getObjectsByType('host');
-        let nRunning = 0;
-        let nHalted = 0;
-        let nUnknown = 0;
-        let total = 0;
-        for (const id in hosts) {
-            total++;
-            const host = hosts[id];
-            switch (host.power_state) {
-                case HOST_POWER_STATE.RUNNING:
-                    nRunning++;
-                    break;
-                case HOST_POWER_STATE.HALTED:
-                    nHalted++;
-                    break;
-                default:
-                    nUnknown++;
-                    break;
-            }
-        }
+        const { running, halted, total, unknown } = this.#hostService.getHostsStatus();
         return {
-            running: nRunning,
-            halted: nHalted,
-            unknown: nUnknown,
+            running,
+            halted,
+            unknown,
             total,
         };
     }
@@ -432,44 +424,38 @@ export class XoaService {
         };
     }
     async getDashboard({ stream } = {}) {
-        async function promiseWriteInStream(maybePromise, key) {
-            let data;
-            if (isPromise(maybePromise)) {
-                data = await maybePromise;
-            }
-            else {
-                data = maybePromise;
-            }
-            if (stream !== undefined) {
-                if (stream.writableNeedDrain) {
-                    await new Promise(resolve => stream.once('drain', resolve));
-                }
-                stream.write(JSON.stringify({ [key]: data }) + '\n');
-            }
-            return data;
-        }
         const [nPools, nHosts, hostsStatus, resourcesOverview, vmsStatus, storageRepositories, poolsStatus, missingPatches, backupRepositories, nHostsEol, backups,] = await Promise.all([
-            promiseWriteInStream(this.#getNumberOfPools(), 'nPools'),
-            promiseWriteInStream(this.#getNumberOfHosts(), 'nHosts'),
-            promiseWriteInStream(this.#getHostsStatus(), 'hostsStatus'),
-            promiseWriteInStream(this.#getResourcesOverview(), 'resourcesOverview'),
-            promiseWriteInStream(this.#getVmsStatus(), 'vmsStatus'),
-            promiseWriteInStream(this.#getStorageRepositoriesSizeInfo(), 'storageRepositories'),
-            promiseWriteInStream(this.#getPoolsStatus(), 'poolsStatus'),
-            promiseWriteInStream(this.#getMissingPatchesInfo(), 'missingPatches'),
-            promiseWriteInStream(this.#getBackupRepositoriesSizeInfo().catch(err => {
-                log.error('#getBackupRepositoriesSizeInfo failed', err);
-                // explicitly return undefined because typescript understand it as void instead of undefined
-                return undefined;
-            }), 'backupRepositories'),
-            promiseWriteInStream(this.#getNumberOfEolHosts().catch(err => {
-                log.error('#getNumberOfEolHosts failed', err);
-                return undefined;
-            }), 'nHostsEol'),
-            promiseWriteInStream(this.#getbackupsInfo().catch(err => {
-                log.error('#getbackupsInfo failed', err);
-                return undefined;
-            }), 'backups'),
+            promiseWriteInStream({ maybePromise: this.#getNumberOfPools(), path: 'nPools', stream }),
+            promiseWriteInStream({ maybePromise: this.#getNumberOfHosts(), path: 'nHosts', stream }),
+            promiseWriteInStream({ maybePromise: this.#getHostsStatus(), path: 'hostsStatus', stream }),
+            promiseWriteInStream({ maybePromise: this.#getResourcesOverview(), path: 'resourcesOverview', stream }),
+            promiseWriteInStream({ maybePromise: this.#getVmsStatus(), path: 'vmsStatus', stream }),
+            promiseWriteInStream({
+                maybePromise: this.#getStorageRepositoriesSizeInfo(),
+                path: 'storageRepositories',
+                stream,
+                handleError: true,
+            }),
+            promiseWriteInStream({ maybePromise: this.#getPoolsStatus(), path: 'poolsStatus', stream }),
+            promiseWriteInStream({ maybePromise: this.#getMissingPatchesInfo(), path: 'missingPatches', stream }),
+            promiseWriteInStream({
+                maybePromise: this.#getBackupRepositoriesSizeInfo(),
+                path: 'backupRepositories',
+                stream,
+                handleError: true,
+            }),
+            promiseWriteInStream({
+                maybePromise: this.#getNumberOfEolHosts(),
+                path: 'nHostsEol',
+                stream,
+                handleError: true,
+            }),
+            promiseWriteInStream({
+                maybePromise: this.#getbackupsInfo(),
+                path: 'backups',
+                stream,
+                handleError: true,
+            }),
         ]);
         return {
             nPools,