@xen-orchestra/rest-api 0.22.1 → 0.23.0

package/dist/pools/pool.controller.mjs

@@ -9,11 +9,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Example, Get, Path, Query, Response, Request, Route, Security, Tags, Post, Middlewares, Body, SuccessResponse, Put, Delete, } from 'tsoa';
 import { inject } from 'inversify';
+import { invalidParameters } from 'xo-common/api-errors.js';
 import { PassThrough } from 'node:stream';
 import { provide } from 'inversify-binding-decorators';
 import { json } from 'express';
 import { RestApi } from '../rest-api/rest-api.mjs';
-import { asynchronousActionResp, badRequestResp, createdResp, featureUnauthorized, internalServerErrorResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { asynchronousActionResp, badRequestResp, createdResp, featureUnauthorized, internalServerErrorResp, invalidParameters as invalidParametersResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { AlarmService } from '../alarms/alarm.service.mjs';
 import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
@@ -265,6 +266,36 @@ let PoolController = class PoolController extends XapiXoController {
         const tasks = await this.getTasksForObject(id, { filter, limit });
         return this.sendObjects(Object.values(tasks), req, 'tasks');
     }
+    /**
+     * Reconfigure the management interface for all hosts in the pool to use the given network.
+     *
+     * Each host in the pool will switch their management interface to a PIF on the specified network.
+     * The PIFs on the target network must already have IP addresses configured.
+     *
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629676"
+     * @example body { "network": "c787b75c-3e0d-70fa-d0c3-cbfd382d7e33" }
+     */
+    managementReconfigure(id, body, sync) {
+        const poolId = id;
+        const action = async () => {
+            const pool = this.getObject(poolId);
+            const network = this.restApi.getObject(body.network, 'network');
+            if (network.$pool !== pool.id) {
+                throw invalidParameters(`the network ${network.uuid} does not belong to pool ${pool.uuid}`);
+            }
+            const xapiPool = this.getXapiObject(poolId);
+            await xapiPool.$xapi.callAsync('pool.management_reconfigure', network._xapiRef);
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'reconfigure pool management interface',
+                objectId: poolId,
+                args: body,
+            },
+        });
+    }
 };
 __decorate([
     Example(poolIds),
@@ -426,6 +457,20 @@ __decorate([
     __param(4, Query()),
     __param(5, Query())
 ], PoolController.prototype, "getPoolTasks", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/management_reconfigure'),
+    Middlewares(json()),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(badRequestResp.status, badRequestResp.description),
+    Response(invalidParametersResp.status, invalidParametersResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Body()),
+    __param(2, Query())
+], PoolController.prototype, "managementReconfigure", null);
 PoolController = __decorate([
     Route('pools'),
     Security('*'),

package/dist/vbds/vbd.controller.mjs

@@ -7,14 +7,17 @@ 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, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { Body, Delete, Example, Get, Middlewares, Path, Post, Query, Request, Response, Route, Security, SuccessResponse, Tags, } from 'tsoa';
+import { json } from 'express';
 import { inject } from 'inversify';
+import { invalidParameters as invalidParametersError } from 'xo-common/api-errors.js';
 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 { badRequestResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
-import { partialVbds, vbd, vbdIds } from '../open-api/oa-examples/vbd.oa-example.mjs';
+import { badRequestResp, createdResp, invalidParameters, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { BASE_URL } from '../index.mjs';
+import { partialVbds, vbd, vbdId, vbdIds } from '../open-api/oa-examples/vbd.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { messageIds, partialMessages } from '../open-api/oa-examples/message.oa-example.mjs';
@@ -25,6 +28,29 @@ let VbdController = class VbdController extends XapiXoController {
         super('VBD', restApi);
         this.#alarmService = alarmService;
     }
+    /**
+     * Create a VBD to attach a VDI to a VM
+     *
+     * @example body { "VM": "4fe90510-8da4-1530-38e2-a7876ef374c7", "VDI": "656052a2-2e3e-467b-88ba-63a9ea5e4a54", "bootable": false, "mode": "RW" }
+     */
+    async createVbd(body) {
+        const xoVm = this.restApi.getObject(body.VM, 'VM');
+        const xoVdi = this.restApi.getObject(body.VDI, 'VDI');
+        if (xoVm.$pool !== xoVdi.$pool) {
+            throw invalidParametersError('VM and VDI must be in the same pool');
+        }
+        const xapiVm = this.restApi.getXapiObject(xoVm.id, 'VM');
+        const xapiVdi = this.restApi.getXapiObject(xoVdi.id, 'VDI');
+        const xapi = xapiVm.$xapi;
+        const vbdRef = await xapi.VBD_create({
+            ...body,
+            VDI: xapiVdi.$ref,
+            VM: xapiVm.$ref,
+        });
+        const vbdUuid = await xapi.call('VBD.get_uuid', vbdRef);
+        this.setHeader('Location', `${BASE_URL}/vbds/${vbdUuid}`);
+        return { id: vbdUuid };
+    }
     /**
      *
      * @example fields "device,bootable,uuid"
@@ -41,6 +67,18 @@ let VbdController = class VbdController extends XapiXoController {
     getVbd(id) {
         return this.getObject(id);
     }
+    /**
+     * Delete a VBD
+     *
+     * Removes the virtual block device, detaching the VDI from the VM.
+     * The VDI itself is NOT deleted.
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     */
+    async deleteVbd(id) {
+        const xapiVbd = this.getXapiObject(id);
+        await xapiVbd.$xapi.VBD_destroy(xapiVbd.$ref);
+    }
     /**
      * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
      * @example fields "id,time"
@@ -76,6 +114,15 @@ let VbdController = class VbdController extends XapiXoController {
         return this.sendObjects(Object.values(tasks), req, 'tasks');
     }
 };
+__decorate([
+    Example(vbdId),
+    Post(''),
+    Middlewares(json()),
+    SuccessResponse(createdResp.status, createdResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(invalidParameters.status, invalidParameters.description),
+    __param(0, Body())
+], VbdController.prototype, "createVbd", null);
 __decorate([
     Example(vbdIds),
     Example(partialVbds),
@@ -92,6 +139,12 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VbdController.prototype, "getVbd", null);
+__decorate([
+    Delete('{id}'),
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], VbdController.prototype, "deleteVbd", null);
 __decorate([
     Example(genericAlarmsExample),
     Get('{id}/alarms'),

package/dist/vms/vm.controller.mjs

@@ -7,7 +7,8 @@ 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, Put, Delete, } from 'tsoa';
+import { Example, Get, Path, Post, Query, Request, Response, Route, Security, Tags, SuccessResponse, Body, Put, Delete, Middlewares, } from 'tsoa';
+import { json } from 'express';
 import { inject } from 'inversify';
 import { incorrectState, invalidParameters } from 'xo-common/api-errors.js';
 import { provide } from 'inversify-binding-decorators';
@@ -480,6 +481,7 @@ __decorate([
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/start'),
+    Middlewares(json()),
     SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description),
     Response(noContentResp.status, noContentResp.description),
     Response(notFoundResp.status, notFoundResp.description),

package/dist/vms/vm.service.mjs

@@ -21,13 +21,17 @@ export class VmService {
         this.#backupLogService = restApi.ioc.get(BackupLogService);
     }
     async #create($defer, params) {
-        const { pool, template, cloud_config, boot, destroy_cloud_config_vdi, network_config, ...rest } = params;
+        const { pool, template, cloud_config, boot, destroy_cloud_config_vdi, network_config, createVtpm, ...rest } = params;
         const xoApp = this.#restApi.xoApp;
         const xapi = xoApp.getXapi(pool);
         const currentUser = this.#restApi.getCurrentUser();
         const xapiVm = await xapi.createVm(template, rest, undefined, currentUser.id);
         $defer.onFailure(() => xapi.VM_destroy(xapiVm.$ref));
         const xoVm = this.#restApi.getObject(xapiVm.uuid, 'VM');
+        if (createVtpm) {
+            const vtpmRef = await xapi.VTPM_create({ VM: xapiVm.$ref });
+            $defer.onFailure(() => xapi.call('VTPM.destroy', vtpmRef));
+        }
         let cloudConfigVdi;
         if (cloud_config !== undefined) {
             const cloudConfigVdiUuid = await xapi.VM_createCloudInitConfig(xapiVm.$ref, cloud_config, {
@@ -88,6 +92,8 @@ export class VmService {
             }
         }
         return {
+            active: nRunning + nPaused,
+            inactive: nHalted + nSuspended,
             running: nRunning,
             halted: nHalted,
             paused: nPaused,
@@ -103,7 +109,7 @@ export class VmService {
         for (const vbdId of vm.$VBDs) {
             const vbd = getObject(vbdId, 'VBD');
             if (vbd.VDI !== undefined) {
-                const vdi = getObject(vbd.VDI, ['VDI-snapshot', 'VDI']);
+                const vdi = getObject(vbd.VDI, [vmType === 'VM-snapshot' ? 'VDI-snapshot' : 'VDI']);
                 vdis.push(vdi);
             }
         }
@@ -182,7 +188,7 @@ export class VmService {
             }
         }
         if (lastReplica === undefined) {
-            return;
+            return {};
         }
         const vdis = this.getVmVdis(id, 'VM');
         let sr = undefined;
@@ -239,7 +245,7 @@ export class VmService {
                 status,
             };
         });
-        let vmProtection = 'not-in-job';
+        let vmProtection = 'not-in-active-job';
         if (!vmContainsNoBakTag(vm)) {
             const backupLogsByJob = groupBy(backupLogs, 'jobId');
             for (const backupJob of relevantJobsWithSchedule) {
@@ -272,7 +278,7 @@ export class VmService {
         const backupArchivesByVmByBr = await this.#restApi.xoApp.listVmBackupsNg(brIds, { vmId: vm.id });
         return Object.values(backupArchivesByVmByBr)
             .filter(backupArchiveByVm => backupArchiveByVm !== undefined)
-            .flatMap(backupArchiveByVm => backupArchiveByVm[vm.id])
+            .flatMap(backupArchiveByVm => backupArchiveByVm[vm.id] ?? [])
             .sort((a, b) => b.timestamp - a.timestamp)
             .splice(0, 3)
             .map(ba => ({ id: ba.id, timestamp: ba.timestamp, backupRepository: ba.backupRepository, size: ba.size }));

package/dist/xoa/xoa.service.mjs

@@ -1,7 +1,7 @@
 import groupBy from 'lodash/groupBy.js';
 import { featureUnauthorized } from 'xo-common/api-errors.js';
 import semver from 'semver';
-import { BACKUP_TYPE, VM_POWER_STATE, } from '@vates/types';
+import { BACKUP_TYPE, } from '@vates/types';
 import { createLogger } from '@xen-orchestra/log';
 import { createPredicate } from 'value-matcher';
 import { extractIdsFromSimplePattern } from '@xen-orchestra/backups/extractIdsFromSimplePattern.mjs';
@@ -11,6 +11,8 @@ import { getFromAsyncCache } from '../helpers/cache.helper.mjs';
 import { isReplicaVm, isSrWritableOrIso, promiseWriteInStream, vmContainsNoBakTag } from '../helpers/utils.helper.mjs';
 import { HostService } from '../hosts/host.service.mjs';
 import { BackupLogService } from '../backup-logs/backup-log.service.mjs';
+import { VmService } from '../vms/vm.service.mjs';
+import { BackupJobService } from '../backup-jobs/backup-job.service.mjs';
 const log = createLogger('xo:rest-api:xoa-service');
 export class XoaService {
     #restApi;
@@ -18,6 +20,8 @@ export class XoaService {
     #dashboardAsyncCache = new Map();
     #dashboardCacheOpts;
     #backupLogService;
+    #vmService;
+    #backupJobService;
     constructor(restApi) {
         this.#restApi = restApi;
         this.#hostService = restApi.ioc.get(HostService);
@@ -26,6 +30,8 @@ export class XoaService {
             expiresIn: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheExpiresIn'),
         };
         this.#backupLogService = this.#restApi.ioc.get(BackupLogService);
+        this.#vmService = this.#restApi.ioc.get(VmService);
+        this.#backupJobService = this.#restApi.ioc.get(BackupJobService);
     }
     async #getBackupRepositoriesSizeInfo() {
         const brResult = await getFromAsyncCache(this.#dashboardAsyncCache, 'backupRepositories', async () => {
@@ -34,7 +40,7 @@ export class XoaService {
             let otherBrSize;
             const backupRepositories = await xoApp.getAllRemotes();
             if (backupRepositories.length === 0) {
-                return undefined;
+                return { isEmpty: true };
             }
             const backupRepositoriesInfo = await xoApp.getAllRemotesInfo();
             for (const backupRepository of backupRepositories) {
@@ -80,6 +86,10 @@ export class XoaService {
                     }
                 }
             }
+            // if only disabled BR
+            if (otherBrSize === undefined && s3Brsize === undefined) {
+                return { isEmpty: true };
+            }
             const result = {};
             if (s3Brsize !== undefined) {
                 result.s3 = s3Brsize;
@@ -107,6 +117,9 @@ export class XoaService {
         const srs = Object.values(this.#restApi.getObjectsByType('SR', {
             filter: isSrWritableOrIso,
         }));
+        if (pools.length === 0 && hosts.length === 0 && srs.length === 0) {
+            return { isEmpty: true };
+        }
         const maxLenght = Math.max(hosts.length, srs.length);
         const resourcesOverview = { nCpus: 0, memorySize: 0, srSize: 0 };
         for (let index = 0; index < maxLenght; index++) {
@@ -131,6 +144,7 @@ export class XoaService {
         let nConnectedServers = 0;
         let nUnreachableServers = 0;
         let nUnknownServers = 0;
+        let nDisconnectedServers = 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`
@@ -145,20 +159,23 @@ export class XoaService {
                 return;
             }
             if (server.status === 'disconnected') {
+                nDisconnectedServers++;
                 return;
             }
             nUnknownServers++;
         });
         return {
             connected: nConnectedServers,
+            disconnected: nDisconnectedServers,
             unreachable: nUnreachableServers,
             unknown: nUnknownServers,
+            total: servers.length,
         };
     }
     async #getNumberOfEolHosts() {
         const getHVSupportedVersions = this.#restApi.xoApp.getHVSupportedVersions;
         if (getHVSupportedVersions === undefined) {
-            return;
+            return { isEmpty: true };
         }
         const hvSupportedVersions = await getHVSupportedVersions();
         const hosts = this.#restApi.getObjectsByType('host');
@@ -176,11 +193,15 @@ export class XoaService {
      */
     async #getMissingPatchesInfo() {
         const missingPatchesInfo = await this.#hostService.getMissingPatchesInfo();
+        const eolHosts = await this.#getNumberOfEolHosts();
         const { hasAuthorization, nHostsFailed, nHostsWithMissingPatches, nPoolsWithMissingPatches } = missingPatchesInfo;
         return {
             hasAuthorization,
+            nHosts: this.#getNumberOfHosts(),
             nHostsFailed,
             nHostsWithMissingPatches,
+            nHostsEol: eolHosts,
+            nPools: this.#getNumberOfPools(),
             nPoolsWithMissingPatches,
         };
     }
@@ -224,11 +245,14 @@ export class XoaService {
         const writableSrs = this.#restApi.getObjectsByType('SR', {
             filter: isSrWritableOrIso,
         });
+        const srs = Object.values(writableSrs);
+        if (srs.length === 0) {
+            return { isEmpty: true };
+        }
         let replicated = 0;
         let total = 0;
         let used = 0;
-        for (const srId in writableSrs) {
-            const sr = writableSrs[srId];
+        for (const sr of srs) {
             const cache = new Set();
             const { VDIs } = sr;
             replicated += VDIs.reduce((total, vdi) => total + this.#calculateReplicatedSize(vdi, cache), 0);
@@ -239,7 +263,7 @@ export class XoaService {
             size: { available: total - used, other: used - replicated, replicated, total, used },
         };
     }
-    async #getbackupsInfo() {
+    async #getBackupsInfo() {
         const vmIdsProtected = new Set();
         const vmIdsUnprotected = new Set();
         const nonReplicaVms = Object.values(this.#restApi.getObjectsByType('VM', { filter: vm => !isReplicaVm(vm) }));
@@ -281,26 +305,6 @@ export class XoaService {
                 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({
@@ -312,58 +316,106 @@ export class XoaService {
                     xoApp.getAllJobs('metadataBackup'),
                 ]).then(jobs => jobs.flat(1)),
             ]);
+            if (jobs.length === 0) {
+                return { isEmpty: true };
+            }
             const logsByJob = groupBy(logs, 'jobId');
             let disabledJobs = 0;
             let failedJobs = 0;
             let skippedJobs = 0;
             let successfulJobs = 0;
+            let noRecentRun = 0;
             const backupJobIssues = [];
+            const now = new Date();
+            const sevenDaysAgo = new Date(now);
+            sevenDaysAgo.setDate(now.getDate() - 7);
+            sevenDaysAgo.setHours(0, 0, 0, 0);
             for (const job of jobs) {
-                if (!(await _jobHasAtLeastOneScheduleEnabled(job))) {
+                if (!(await this.#backupJobService.backupJobHasAtLeastOneScheduleEnabled(job.id))) {
                     _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) {
+                const last3BackupLogs = [];
+                const backupLogsOfTheWeek = [];
+                logsByJob[job.id]?.reverse().forEach(log => {
+                    if (log.status === 'pending') {
+                        return;
+                    }
+                    const nonPendingLog = log;
+                    if (last3BackupLogs.length < 3) {
+                        last3BackupLogs.push(nonPendingLog);
+                    }
+                    if (log.start > sevenDaysAgo.getTime()) {
+                        backupLogsOfTheWeek.push(nonPendingLog);
+                    }
+                });
+                if (backupLogsOfTheWeek.length === 0) {
+                    noRecentRun++;
+                }
+                else {
+                    let hasSoftFailure = false;
+                    let hasHardFailure = false;
+                    for (const log of backupLogsOfTheWeek) {
+                        if (log.status === 'interrupted' || log.status === 'failure') {
+                            hasHardFailure = true;
+                            break;
+                        }
+                        if (log.status === 'skipped') {
+                            hasSoftFailure = true;
+                        }
+                    }
+                    if (hasHardFailure) {
+                        failedJobs++;
+                    }
+                    else if (hasSoftFailure) {
+                        skippedJobs++;
+                    }
+                    else {
+                        successfulJobs++;
+                    }
+                }
+                if (last3BackupLogs.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');
+                    // VM should only be considered protected if these last logs have been successful
+                    const backupLogStatusesByVm = {};
+                    function updateVmBackupLogStatuses(id, isSuccess) {
+                        if (backupLogStatusesByVm[id] === undefined) {
+                            backupLogStatusesByVm[id] = [];
+                        }
+                        backupLogStatusesByVm[id].push(isSuccess);
                     }
-                    else {
-                        // @TODO: remove as when logs are correctly typed
-                        ;
-                        tasks.forEach(task => {
-                            _updateVmProtection(task.data.id, task.status === 'success');
-                        });
+                    last3BackupLogs.forEach(jobLob => {
+                        const { tasks, status } = jobLob;
+                        if (tasks === undefined) {
+                            const vmIds = _extractVmIdsFromBackupJob(job);
+                            vmIds.forEach(vmId => updateVmBackupLogStatuses(vmId, status === 'success'));
+                        }
+                        else {
+                            tasks.forEach(task => {
+                                if (task.data === undefined) {
+                                    return;
+                                }
+                                updateVmBackupLogStatuses(task.data.id, task.status === 'success');
+                            });
+                        }
+                    });
+                    for (const [vmId, statuses] of Object.entries(backupLogStatusesByVm)) {
+                        _updateVmProtection(vmId, statuses.every(status => status));
                     }
                 }
-                const failedLog = jobLogs.find(log => log.status !== 'success');
+                const failedLog = last3BackupLogs.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),
+                        logs: last3BackupLogs.map(log => log.status),
                         name: job.name,
                         type: job.type,
                         uuid: job.id,
                     });
                 }
-                else {
-                    successfulJobs++;
-                }
             }
             const nVmsProtected = vmIdsProtected.size;
             const nVmsUnprotected = vmIdsUnprotected.size;
@@ -372,6 +424,7 @@ export class XoaService {
                 jobs: {
                     disabled: disabledJobs,
                     failed: failedJobs,
+                    noRecentRun,
                     skipped: skippedJobs,
                     successful: successfulJobs,
                     total: jobs.length,
@@ -389,8 +442,9 @@ export class XoaService {
         }
     }
     #getHostsStatus() {
-        const { running, halted, total, unknown } = this.#hostService.getHostsStatus();
+        const { disabled, running, halted, total, unknown } = this.#hostService.getHostsStatus();
         return {
+            disabled,
             running,
             halted,
             unknown,
@@ -398,37 +452,10 @@ export class XoaService {
         };
     }
     #getVmsStatus() {
-        const vms = this.#restApi.getObjectsByType('VM');
-        let nActive = 0;
-        let nInactive = 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:
-                case VM_POWER_STATE.PAUSED:
-                    nActive++;
-                    break;
-                case VM_POWER_STATE.HALTED:
-                case VM_POWER_STATE.SUSPENDED:
-                    nInactive++;
-                    break;
-                default:
-                    nUnknown++;
-                    break;
-            }
-        }
-        return {
-            active: nActive,
-            inactive: nInactive,
-            unknown: nUnknown,
-            total,
-        };
+        return this.#vmService.getVmsStatus();
     }
     async getDashboard({ stream } = {}) {
-        const [nPools, nHosts, hostsStatus, resourcesOverview, vmsStatus, storageRepositories, poolsStatus, missingPatches, backupRepositories, nHostsEol, backups,] = await Promise.all([
+        const [nPools, nHosts, hostsStatus, resourcesOverview, vmsStatus, storageRepositories, poolsStatus, missingPatches, backupRepositories, backups,] = await Promise.all([
             promiseWriteInStream({ maybePromise: this.#getNumberOfPools(), path: 'nPools', stream }),
             promiseWriteInStream({ maybePromise: this.#getNumberOfHosts(), path: 'nHosts', stream }),
             promiseWriteInStream({ maybePromise: this.#getHostsStatus(), path: 'hostsStatus', stream }),
@@ -450,6 +477,7 @@ export class XoaService {
                 }),
                 path: 'missingPatches',
                 stream,
+                handleError: true,
             }),
             promiseWriteInStream({
                 maybePromise: this.#getBackupRepositoriesSizeInfo(),
@@ -458,13 +486,7 @@ export class XoaService {
                 handleError: true,
             }),
             promiseWriteInStream({
-                maybePromise: this.#getNumberOfEolHosts(),
-                path: 'nHostsEol',
-                stream,
-                handleError: true,
-            }),
-            promiseWriteInStream({
-                maybePromise: this.#getbackupsInfo(),
+                maybePromise: this.#getBackupsInfo(),
                 path: 'backups',
                 stream,
                 handleError: true,
@@ -476,7 +498,6 @@ export class XoaService {
             backupRepositories,
             resourcesOverview,
             poolsStatus,
-            nHostsEol,
             missingPatches,
             storageRepositories,
             backups,