@xen-orchestra/rest-api 0.8.0 → 0.9.0

package/dist/vms/vm.controller.mjs

@@ -7,11 +7,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Example, Get, Path, Post, Query, Request, Response, Route, Security, Tags, SuccessResponse, Body } from 'tsoa';
+import { Example, Get, Path, Post, Query, Request, Response, Route, Security, Tags, SuccessResponse, Body, Put, Delete, } from 'tsoa';
 import { inject } from 'inversify';
 import { incorrectState, invalidParameters } from 'xo-common/api-errors.js';
 import { provide } from 'inversify-binding-decorators';
-import { actionAsyncroneResp, createdResp, internalServerErrorResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { asynchronousActionResp, createdResp, internalServerErrorResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { BASE_URL } from '../index.mjs';
 import { partialVms, vm, vmIds, vmStatsExample } from '../open-api/oa-examples/vm.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
@@ -28,7 +28,7 @@ let VmController = class VmController extends XapiXoController {
      * @example filter "power_state:Running"
      * @example limit 42
      */
-    getVms(req, fields, filter, limit) {
+    getVms(req, fields, ndjson, filter, limit) {
         return this.sendObjects(Object.values(this.getObjects({ filter, limit })), req);
     }
     /**
@@ -57,6 +57,52 @@ let VmController = class VmController extends XapiXoController {
             throw error;
         }
     }
+    /**
+     * The VM must be running
+     *
+     * List of possible data_source (Based on [Xenserver doc](https://docs.xenserver.com/en-us/xenserver/8/monitor-performance#available-vm-metrics))
+     * - **cpu#** : Utilization of vCPU cpu (fraction). Enabled by default. *Condition*: vCPU cpu exists.
+     * - **cpu_usage** : Domain CPU usage. *Condition*: None.
+     * - **memory** : Memory currently allocated to VM (Bytes). Enabled by default. *Condition*: None.
+     * - **memory_target** : Target of VM balloon driver (Bytes). Enabled by default. *Condition*: None.
+     * - **memory_internal_free** : Memory used as reported by the guest agent (KiB). Enabled by default. *Condition*: None.
+     * - **runstate_fullrun** : Fraction of time that all vCPUs are running. *Condition*: None.
+     * - **runstate_full_contention** : Fraction of time that all vCPUs are runnable (waiting for CPU). *Condition*: None.
+     * - **runstate_concurrency_hazard** : Fraction of time that some vCPUs are running and some are runnable. *Condition*: None.
+     * - **runstate_blocked** : Fraction of time that all vCPUs are blocked or offline. *Condition*: None.
+     * - **runstate_partial_run** : Fraction of time that some vCPUs are running, and some are blocked. *Condition*: None.
+     * - **runstate_partial_contention** : Fraction of time that some vCPUs are runnable and some are blocked. *Condition*: None.
+     * - **vbd_#_write** : Writes to device vbd in bytes per second. Enabled by default. *Condition*: VBD vbd exists.
+     * - **vbd_#_read** : Reads from device vbd in bytes per second. Enabled by default. *Condition*: VBD vbd exists.
+     * - **vbd_#_write_latency** : Writes to device vbd in microseconds. *Condition*: VBD vbd exists.
+     * - **vbd_#_read_latency** : Reads from device vbd in microseconds. *Condition*: VBD vbd exists.
+     * - **vbd_#_iops_read** : Read requests per second. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vbd_#_iops_write** : Write requests per second. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vbd_#_iops_total** : I/O requests per second. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vbd_#_iowait** : Percentage of time waiting for I/O. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vbd_#_inflight** : Number of I/O requests currently in flight. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vbd_#_avgqu_sz** : Average I/O queue size. *Condition*: At least one plugged VBD for non-ISO VDI on the host.
+     * - **vif_#_rx** : Bytes per second received on virtual interface number vif. Enabled by default. *Condition*: VIF vif exists.
+     * - **vif_#_tx** : Bytes per second transmitted on virtual interface vif. Enabled by default. *Condition*: VIF vif exists.
+     * - **vif_#_rx_errors** : Receive errors per second on virtual interface vif. Enabled by default. *Condition*: VIF vif exists.
+     * - **vif_#_tx_errors** : Transmit errors per second on virtual interface vif. Enabled by default. *Condition*: VIF vif exists.
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     * @example dataSource "cpu0"
+     */
+    async addDataSource(id, dataSource) {
+        await this.getXapiObject(id).$call('record_data_source', dataSource);
+    }
+    /**
+     * The VM must be running
+     *
+     * For a list of possible data sources, see the endpoint documentation: `GET {id}/stats/data_source/{data_source}`
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     * @example dataSource "cpu0"
+     */
+    async deleteDataSource(id, dataSource) {
+        await this.getXapiObject(id).$call('forget_data_source_archives', dataSource);
+    }
     /**
      * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
      */
@@ -174,7 +220,8 @@ __decorate([
     __param(0, Request()),
     __param(1, Query()),
     __param(2, Query()),
-    __param(3, Query())
+    __param(3, Query()),
+    __param(4, Query())
 ], VmController.prototype, "getVms", null);
 __decorate([
     Example(vm),
@@ -190,10 +237,26 @@ __decorate([
     __param(0, Path()),
     __param(1, Query())
 ], VmController.prototype, "getVmStats", null);
+__decorate([
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    Put('{id}/stats/data_source/{data_source}'),
+    __param(0, Path()),
+    __param(1, Path('data_source'))
+], VmController.prototype, "addDataSource", null);
+__decorate([
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    Delete('{id}/stats/data_source/{data_source}'),
+    __param(0, Path()),
+    __param(1, Path('data_source'))
+], VmController.prototype, "deleteDataSource", null);
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/start'),
-    SuccessResponse(actionAsyncroneResp.status, actionAsyncroneResp.description, actionAsyncroneResp.produce),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
     Response(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
@@ -203,7 +266,7 @@ __decorate([
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/clean_shutdown'),
-    SuccessResponse(actionAsyncroneResp.status, actionAsyncroneResp.description, actionAsyncroneResp.produce),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
     Response(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
@@ -219,7 +282,7 @@ __decorate([
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/hard_shutdown'),
-    SuccessResponse(actionAsyncroneResp.status, actionAsyncroneResp.description, actionAsyncroneResp.produce),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
     Response(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
@@ -229,7 +292,7 @@ __decorate([
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/hard_reboot'),
-    SuccessResponse(actionAsyncroneResp.status, actionAsyncroneResp.description, actionAsyncroneResp.produce),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
     Response(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
@@ -239,7 +302,7 @@ __decorate([
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/snapshot'),
-    SuccessResponse(actionAsyncroneResp.status, actionAsyncroneResp.description, actionAsyncroneResp.produce),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
     Response(createdResp.status, 'Snapshot created'),
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),

package/dist/xoa/xoa.controller.mjs

@@ -0,0 +1,39 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Example, Get, Response, Route, Security, Tags } from 'tsoa';
+import { inject } from 'inversify';
+import { provide } from 'inversify-binding-decorators';
+import { unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { xoaDashboard } from '../open-api/oa-examples/xoa.oa-example.mjs';
+import { XoaService } from './xoa.service.mjs';
+let XoaController = class XoaController extends Controller {
+    #xoaService;
+    constructor(xoaService) {
+        super();
+        this.#xoaService = xoaService;
+    }
+    async getDashboard() {
+        const dashboard = await this.#xoaService.getDashboard();
+        return dashboard;
+    }
+};
+__decorate([
+    Example(xoaDashboard),
+    Get('dashboard')
+], XoaController.prototype, "getDashboard", null);
+XoaController = __decorate([
+    Route(''),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('xoa'),
+    provide(XoaController),
+    __param(0, inject(XoaService))
+], XoaController);
+export { XoaController };

package/dist/xoa/xoa.service.mjs

@@ -0,0 +1,407 @@
+import groupBy from 'lodash/groupBy.js';
+import semver from 'semver';
+import { BACKUP_TYPE, } from '@vates/types';
+import { asyncEach } from '@vates/async-each';
+import { createLogger } from '@xen-orchestra/log';
+import { createPredicate } from 'value-matcher';
+import { extractIdsFromSimplePattern } from '@xen-orchestra/backups/extractIdsFromSimplePattern.mjs';
+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';
+const log = createLogger('xo:rest-api:xoa-service');
+export class XoaService {
+    #restApi;
+    #dashboardAsyncCache = new Map();
+    #dashboardCacheOpts;
+    constructor(restApi) {
+        this.#restApi = restApi;
+        this.#dashboardCacheOpts = {
+            timeout: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheTimeout'),
+            expiresIn: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheExpiresIn'),
+        };
+    }
+    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,
+            };
+            const backupRepositories = await xoApp.getAllRemotes();
+            const backupRepositoriesInfo = await xoApp.getAllRemotesInfo();
+            for (const backupRepository of backupRepositories) {
+                const { type } = parse(backupRepository.url);
+                const backupRepositoryInfo = backupRepositoriesInfo[backupRepository.id];
+                if (!backupRepository.enabled || backupRepositoryInfo === undefined) {
+                    continue;
+                }
+                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;
+                }
+            }
+            return { s3: { size: s3Brsize }, other: { size: otherBrSize } };
+        }, this.#dashboardCacheOpts);
+        if (brResult?.value !== undefined) {
+            return { ...brResult.value, isExpired: brResult.isExpired };
+        }
+    }
+    #getNumberOfPools() {
+        const pools = this.#restApi.getObjectsByType('pool');
+        return Object.keys(pools).length;
+    }
+    #getNumberOfHosts() {
+        const hosts = this.#restApi.getObjectsByType('host');
+        return Object.keys(hosts).length;
+    }
+    #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 maxLenght = Math.max(hosts.length, writableSrs.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];
+            if (pool !== undefined) {
+                resourcesOverview.nCpus += pool.cpus.cores ?? 0;
+            }
+            if (host !== undefined) {
+                resourcesOverview.memorySize += host.memory.size;
+            }
+            if (sr !== undefined) {
+                resourcesOverview.srSize += sr.size;
+            }
+        }
+        return resourcesOverview;
+    }
+    async #getPoolsStatus() {
+        const servers = await this.#restApi.xoApp.getAllXenServers();
+        const pools = this.#restApi.getObjectsByType('pool');
+        let nConnectedServers = 0;
+        let nUnreachableServers = 0;
+        let nUnknownServers = 0;
+        servers.forEach(server => {
+            // it may happen that some servers are marked as "connected", but no pool matches "server.pool"
+            // so they are counted as `nUnknownServers`
+            if (server.status === 'connected' && server.poolId !== undefined && pools[server.poolId] !== undefined) {
+                nConnectedServers++;
+                return;
+            }
+            if (server.status === 'disconnected' &&
+                server.error !== undefined &&
+                server.error.connectedServerId === undefined) {
+                nUnreachableServers++;
+                return;
+            }
+            if (server.status === 'disconnected') {
+                return;
+            }
+            nUnknownServers++;
+        });
+        return {
+            connected: nConnectedServers,
+            unreachable: nUnreachableServers,
+            unknown: nUnknownServers,
+        };
+    }
+    async #getNumberOfEolHosts() {
+        const getHVSupportedVersions = this.#restApi.xoApp.getHVSupportedVersions;
+        if (getHVSupportedVersions === undefined) {
+            return;
+        }
+        const hvSupportedVersions = await getHVSupportedVersions();
+        const hosts = this.#restApi.getObjectsByType('host');
+        let nHostsEol = 0;
+        for (const hostId in hosts) {
+            const host = hosts[hostId];
+            if (!semver.satisfies(host.version, hvSupportedVersions[host.productBrand])) {
+                nHostsEol++;
+            }
+        }
+        return nHostsEol;
+    }
+    async #getMissingPatchesInfo() {
+        if (!(await this.#restApi.xoApp.hasFeatureAuthorization('LIST_MISSING_PATCHES'))) {
+            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++;
+            }
+        });
+        return {
+            hasAuthorization: true,
+            nHostsFailed,
+            nHostsWithMissingPatches,
+            nPoolsWithMissingPatches: poolsWithMissingPatches.size,
+        };
+    }
+    #isReplicaVmInVdb(vbds) {
+        for (const vbd of vbds) {
+            try {
+                const vdbObject = this.#restApi.getObject(vbd);
+                const { VM } = vdbObject;
+                const vmObject = this.#restApi.getObject(VM);
+                return isReplicaVm(vmObject);
+            }
+            catch (err) {
+                if (!noSuchObject.is(err)) {
+                    throw err;
+                }
+            }
+        }
+        return false;
+    }
+    #calculateReplicatedSize(vdiId, cache) {
+        if (cache.has(vdiId)) {
+            return 0;
+        }
+        let vdiObject;
+        try {
+            vdiObject = this.#restApi.getObject(vdiId);
+            cache.add(vdiId);
+        }
+        catch (err) {
+            if (!noSuchObject.is(err)) {
+                throw err;
+            }
+            return 0;
+        }
+        const { parent, usage, $VBDs } = vdiObject;
+        const replicaUsage = this.#isReplicaVmInVdb($VBDs) && usage ? usage : 0;
+        const parentUsage = parent ? this.#calculateReplicatedSize(parent, cache) : 0;
+        return replicaUsage + parentUsage;
+    }
+    #getStorageRepositoriesSizeInfo() {
+        const writableSrs = this.#restApi.getObjectsByType('SR', {
+            filter: isSrWritable,
+        });
+        let replicated = 0;
+        let total = 0;
+        let used = 0;
+        for (const srId in writableSrs) {
+            const sr = writableSrs[srId];
+            const cache = new Set();
+            const { VDIs } = sr;
+            replicated += VDIs.reduce((total, vdi) => total + this.#calculateReplicatedSize(vdi, cache), 0);
+            total += sr.size;
+            used += sr.physical_usage;
+        }
+        return {
+            size: { available: total - used, other: used - replicated, replicated, total, used },
+        };
+    }
+    async #getbackupsInfo() {
+        const vmIdsProtected = new Set();
+        const vmIdsUnprotected = new Set();
+        const nonReplicaVms = Object.values(this.#restApi.getObjectsByType('VM', { filter: vm => !isReplicaVm(vm) }));
+        const restApi = this.#restApi;
+        const xoApp = restApi.xoApp;
+        function _extractVmIdsFromBackupJob(job) {
+            let vmIds;
+            try {
+                vmIds = extractIdsFromSimplePattern(job.vms);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (_) {
+                const predicate = createPredicate(job.vms);
+                vmIds = nonReplicaVms.filter(predicate).map(vm => vm.id);
+            }
+            return vmIds;
+        }
+        function _processVmsProtection(job, isProtected) {
+            if (job.type !== BACKUP_TYPE.backup) {
+                return;
+            }
+            _extractVmIdsFromBackupJob(job).forEach(vmId => {
+                _updateVmProtection(vmId, isProtected);
+            });
+        }
+        function _updateVmProtection(vmId, isProtected) {
+            if (vmIdsProtected.has(vmId) || !xoApp.hasObject(vmId, 'VM')) {
+                return;
+            }
+            const vm = restApi.getObject(vmId, 'VM');
+            if (vmContainsNoBakTag(vm)) {
+                return;
+            }
+            if (isProtected) {
+                vmIdsProtected.add(vmId);
+                vmIdsUnprotected.delete(vmId);
+            }
+            else {
+                vmIdsUnprotected.add(vmId);
+            }
+        }
+        async function _jobHasAtLeastOneScheduleEnabled(job) {
+            for (const maybeScheduleId in job.settings) {
+                if (maybeScheduleId === '') {
+                    continue;
+                }
+                try {
+                    const schedule = await xoApp.getSchedule(maybeScheduleId);
+                    if (schedule.enabled) {
+                        return true;
+                    }
+                }
+                catch (error) {
+                    if (!noSuchObject.is(error, { id: maybeScheduleId, type: 'schedule' })) {
+                        console.error(error);
+                    }
+                    continue;
+                }
+            }
+            return false;
+        }
+        const backupsResult = await getFromAsyncCache(this.#dashboardAsyncCache, 'backups', async () => {
+            const [logs, jobs] = await Promise.all([
+                xoApp.getBackupNgLogsSorted({
+                    filter: log => log.message === 'backup' || log.message === 'metadata',
+                }),
+                Promise.all([
+                    xoApp.getAllJobs('backup'),
+                    xoApp.getAllJobs('mirrorBackup'),
+                    xoApp.getAllJobs('metadataBackup'),
+                ]).then(jobs => jobs.flat(1)),
+            ]);
+            const logsByJob = groupBy(logs, 'jobId');
+            let disabledJobs = 0;
+            let failedJobs = 0;
+            let skippedJobs = 0;
+            let successfulJobs = 0;
+            const backupJobIssues = [];
+            for (const job of jobs) {
+                if (!(await _jobHasAtLeastOneScheduleEnabled(job))) {
+                    _processVmsProtection(job, false);
+                    disabledJobs++;
+                    continue;
+                }
+                // Get only the last 3 runs
+                const jobLogs = logsByJob[job.id]?.slice(-3).reverse();
+                if (jobLogs === undefined || jobLogs.length === 0) {
+                    _processVmsProtection(job, false);
+                    continue;
+                }
+                if (job.type === BACKUP_TYPE.backup) {
+                    const lastJobLog = jobLogs[0];
+                    const { tasks, status } = lastJobLog;
+                    if (tasks === undefined) {
+                        _processVmsProtection(job, status === 'success');
+                    }
+                    else {
+                        // @TODO: remove as when logs are correctly typed
+                        ;
+                        tasks.forEach(task => {
+                            _updateVmProtection(task.data.id, task.status === 'success');
+                        });
+                    }
+                }
+                const failedLog = jobLogs.find(log => log.status !== 'success');
+                if (failedLog !== undefined) {
+                    const { status } = failedLog;
+                    if (status === 'failure' || status === 'interrupted') {
+                        failedJobs++;
+                    }
+                    else if (status === 'skipped') {
+                        skippedJobs++;
+                    }
+                    backupJobIssues.push({
+                        // @TODO: remove as when logs are correctly typed
+                        logs: jobLogs.map(log => log.status),
+                        name: job.name,
+                        type: job.type,
+                        uuid: job.id,
+                    });
+                }
+                else {
+                    successfulJobs++;
+                }
+            }
+            const nVmsProtected = vmIdsProtected.size;
+            const nVmsUnprotected = vmIdsUnprotected.size;
+            const nVmsNotInJob = nonReplicaVms.length - (nVmsProtected + nVmsUnprotected);
+            return {
+                jobs: {
+                    disabled: disabledJobs,
+                    failed: failedJobs,
+                    skipped: skippedJobs,
+                    successful: successfulJobs,
+                    total: jobs.length,
+                },
+                issues: backupJobIssues,
+                vmsProtection: {
+                    protected: nVmsProtected,
+                    unprotected: nVmsUnprotected,
+                    notInJob: nVmsNotInJob,
+                },
+            };
+        }, this.#dashboardCacheOpts);
+        if (backupsResult?.value !== undefined) {
+            return { ...backupsResult.value, isExpired: backupsResult.isExpired };
+        }
+    }
+    async getDashboard() {
+        const nPools = this.#getNumberOfPools();
+        const nHosts = this.#getNumberOfHosts();
+        const resourcesOverview = this.#getResourcesOverview();
+        const storageRepositories = this.#getStorageRepositoriesSizeInfo();
+        const poolsStatus = await this.#getPoolsStatus();
+        const missingPatches = await this.#getMissingPatchesInfo();
+        const backupRepositories = await this.#getBackupRepositoriesSizeInfo().catch(err => {
+            log.error('#getBackupRepositoriesSizeInfo failed', err);
+            // explicitly return undefined because typescript understand it as void instead of undefined
+            return undefined;
+        });
+        const nHostsEol = await this.#getNumberOfEolHosts().catch(err => {
+            log.err('#getNumberOfEolHosts failed', err);
+            return undefined;
+        });
+        const backups = await this.#getbackupsInfo().catch(err => {
+            log.error('#getbackupsInfo failed', err);
+            return undefined;
+        });
+        return {
+            nPools,
+            nHosts,
+            backupRepositories,
+            resourcesOverview,
+            poolsStatus,
+            nHostsEol,
+            missingPatches,
+            storageRepositories,
+            backups,
+        };
+    }
+}

package/dist/xoa/xoa.type.mjs

@@ -0,0 +1 @@
+export {};