@xen-orchestra/rest-api 0.10.0 → 0.12.0

package/dist/abstract-classes/base-controller.mjs

@@ -1,4 +1,6 @@
 import { Controller } from 'tsoa';
+import { createGzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { BASE_URL } from '../index.mjs';
 import { makeNdJsonStream } from '../helpers/stream.helper.mjs';
@@ -11,8 +13,8 @@ export class BaseController extends Controller {
         super();
         this.restApi = restApi;
     }
-    sendObjects(objects, req) {
-        const mapper = makeObjectMapper(req);
+    sendObjects(objects, req, path) {
+        const mapper = makeObjectMapper(req, path);
         const mappedObjects = objects.map(mapper);
         if (req.query.ndjson === 'true') {
             const res = req.res;
@@ -49,4 +51,24 @@ export class BaseController extends Controller {
     getXapi(maybeId) {
         return this.restApi.xoApp.getXapi(maybeId);
     }
+    maybeCompressResponse(req, res) {
+        let transform;
+        let acceptEncoding = req.headers['accept-encoding'];
+        acceptEncoding = Array.isArray(acceptEncoding) ? acceptEncoding : acceptEncoding?.split(',');
+        if (acceptEncoding !== undefined &&
+            acceptEncoding.some(encoding => {
+                const value = encoding.split(';')[0].trim().toLowerCase();
+                // support `x-gzip` as an alias for `gzip`
+                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Encoding#gzip
+                return value === 'gzip' || value === 'x-gzip';
+            })) {
+            res.setHeader('Content-Encoding', 'gzip');
+            transform = createGzip();
+        }
+        if (transform !== undefined) {
+            pipeline(transform, res).catch(noop);
+            return transform;
+        }
+        return res;
+    }
 }

package/dist/alarms/alarm.controller.mjs

@@ -7,87 +7,36 @@ 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 * as CM from 'complex-matcher';
 import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
 import { inject } from 'inversify';
 import { noSuchObject } from 'xo-common/api-errors.js';
 import { provide } from 'inversify-binding-decorators';
 import { alarm, alarmIds, partialAlarms } from '../open-api/oa-examples/alarm.oa-example.mjs';
-import { BASE_URL } from '../index.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';
-// E.g: 'value: 0.6\nconfig:\n<variable>\n<name value="cpu_usage"/>\n<alarm_trigger_level value="0.4"/>\n<alarm_trigger_period value ="60"/>\n</variable>';
-const ALARM_BODY_REGEX = /^value:\s*(Infinity|NaN|-Infinity|\d+(?:\.\d+)?)\s*config:\s*<variable>\s*<name value="(.*?)"/;
-const ALARM_NAMES = ['ALARM', 'BOND_STATUS_CHANGED', 'MULTIPATH_PERIODIC_ALERT'];
-export const alarmPredicate = CM.parse(`name:|(${ALARM_NAMES.join(' ')})`).createPredicate();
+import { AlarmService } from './alarm.service.mjs';
 let AlarmController = class AlarmController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('message', restApi);
-    }
-    #parseAlarm({ $object, body, ...alarm }) {
-        let object;
-        try {
-            object = this.restApi.getObject($object);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (err) {
-            object = {
-                type: 'unknown',
-                uuid: $object,
-            };
-        }
-        let href;
-        if (object.type !== 'unknown') {
-            href = `${BASE_URL}/${object.type.toLowerCase() + 's'}/${object.uuid}`;
-        }
-        const [, value, name] = body.match(ALARM_BODY_REGEX) ?? [];
-        return {
-            ...alarm,
-            body: {
-                value, // Keep the value as a string because NaN, Infinity, -Infinity is not valid JSON
-                name: name ?? body, // for 'BOND_STATUS_CHANGED' and 'MULTIPATH_PERIODIC_ALERT', body is a non-xml string. ("body": "The status of the eth0+eth1 bond is: 1/2 up")
-            },
-            object: {
-                type: object.type,
-                uuid: object.uuid,
-                href,
-            },
-        };
+        this.#alarmService = alarmService;
     }
     /**
      * Override parent getObjects in order to only get `ALARM` messages
      */
-    getObjects({ filter, limit = Infinity } = {}) {
-        const rawAlarms = this.restApi.getObjectsByType('message', {
-            filter: alarmPredicate,
-        });
-        let userFilter = () => true;
-        if (filter !== undefined) {
-            userFilter = CM.parse(filter).createPredicate();
-        }
-        const alarms = {};
-        for (const id in rawAlarms) {
-            if (limit === 0) {
-                break;
-            }
-            const alarm = this.#parseAlarm(rawAlarms[id]);
-            if (userFilter(alarm)) {
-                alarms[id] = alarm;
-                limit--;
-            }
-        }
-        return alarms;
+    getObjects(opts) {
+        return this.#alarmService.getAlarms(opts);
     }
     /**
      * Override parent getObject in order to only get `ALARM` message
      */
     getObject(id) {
         const maybeAlarm = this.restApi.getObject(id, 'message');
-        if (!alarmPredicate(maybeAlarm)) {
-            /* throw */ noSuchObject(id, 'alarm');
+        if (!this.#alarmService.isAlarm(maybeAlarm)) {
+            throw noSuchObject(id, 'alarm');
         }
-        return this.#parseAlarm(maybeAlarm);
+        return this.#alarmService.parseAlarm(maybeAlarm);
     }
     /**
      * @example fields "body,id,object"
@@ -126,6 +75,7 @@ AlarmController = __decorate([
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('alarms'),
     provide(AlarmController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], AlarmController);
 export { AlarmController };

package/dist/alarms/alarm.service.mjs

@@ -0,0 +1,67 @@
+import * as CM from 'complex-matcher';
+import { BASE_URL } from '../index.mjs';
+// E.g: 'value: 0.6\nconfig:\n<variable>\n<name value="cpu_usage"/>\n<alarm_trigger_level value="0.4"/>\n<alarm_trigger_period value ="60"/>\n</variable>';
+const ALARM_BODY_REGEX = /^value:\s*(Infinity|NaN|-Infinity|\d+(?:\.\d+)?)\s*config:\s*<variable>\s*<name value="(.*?)"/;
+const ALARM_NAMES = ['ALARM', 'BOND_STATUS_CHANGED', 'MULTIPATH_PERIODIC_ALERT'];
+export const alarmPredicate = CM.parse(`name:|(${ALARM_NAMES.join(' ')})`).createPredicate();
+export class AlarmService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    isAlarm(maybeAlarm) {
+        return alarmPredicate(maybeAlarm);
+    }
+    parseAlarm({ $object, body, time, ...alarm }) {
+        let object;
+        try {
+            object = this.#restApi.getObject($object);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (err) {
+            object = {
+                type: 'unknown',
+                uuid: $object,
+            };
+        }
+        let href;
+        if (object.type !== 'unknown') {
+            href = `${BASE_URL}/${object.type.toLowerCase() + 's'}/${object.uuid}`;
+        }
+        const [, value, name] = body.match(ALARM_BODY_REGEX) ?? [];
+        return {
+            ...alarm,
+            body: {
+                value: Number.isFinite(+value) ? (+value * 100).toFixed(1) : value, // Keep the value as a string because NaN, Infinity, -Infinity is not valid JSON
+                name: name ?? body, // for 'BOND_STATUS_CHANGED' and 'MULTIPATH_PERIODIC_ALERT', body is a non-xml string. ("body": "The status of the eth0+eth1 bond is: 1/2 up")
+            },
+            object: {
+                type: object.type,
+                uuid: object.uuid,
+                href,
+            },
+            time: time * 1000,
+        };
+    }
+    getAlarms({ filter, limit = Infinity } = {}) {
+        const rawAlarms = this.#restApi.getObjectsByType('message', {
+            filter: alarmPredicate,
+        });
+        let userFilter = () => true;
+        if (filter !== undefined) {
+            userFilter = typeof filter === 'string' ? CM.parse(filter).createPredicate() : filter;
+        }
+        const alarms = {};
+        for (const id in rawAlarms) {
+            if (limit === 0) {
+                break;
+            }
+            const alarm = this.parseAlarm(rawAlarms[id]);
+            if (userFilter(alarm)) {
+                alarms[id] = alarm;
+                limit--;
+            }
+        }
+        return alarms;
+    }
+}

package/dist/backup-repositories/backup-repositories.controller.mjs

@@ -0,0 +1,61 @@
+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 { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { provide } from 'inversify-binding-decorators';
+import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { backupRepositoryIds, partialBackupRepositories, backupRepository, } from '../open-api/oa-examples/backup-repository.oa-example.mjs';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+let BackupRepositoryController = class BackupRepositoryController extends XoController {
+    // --- abstract methods
+    getAllCollectionObjects() {
+        return this.restApi.xoApp.getAllRemotes();
+    }
+    getCollectionObject(id) {
+        return this.restApi.xoApp.getRemote(id);
+    }
+    /**
+     * @example fields "id,name,enabled"
+     * @example filter "enabled?"
+     * @example limit 42
+     */
+    async getRepositories(req, fields, ndjson, filter, limit) {
+        return this.sendObjects(Object.values(await this.getObjects({ filter, limit })), req);
+    }
+    /**
+     * @example id "c4284e12-37c9-7967-b9e8-83ef229c3e03"
+     */
+    getRepository(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(backupRepositoryIds),
+    Example(partialBackupRepositories),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], BackupRepositoryController.prototype, "getRepositories", null);
+__decorate([
+    Example(backupRepository),
+    Get('{id}'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], BackupRepositoryController.prototype, "getRepository", null);
+BackupRepositoryController = __decorate([
+    Route('backup-repositories'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('backup-repositories'),
+    provide(BackupRepositoryController)
+], BackupRepositoryController);
+export { BackupRepositoryController };

package/dist/groups/group.controller.mjs

@@ -7,9 +7,9 @@ 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 { Delete, Example, Get, Path, Query, Request, Response, Route, Security, SuccessResponse, Tags } from 'tsoa';
 import { provide } from 'inversify-binding-decorators';
-import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { noContentResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { group, groupIds, partialGroups } from '../open-api/oa-examples/group.oa-example.mjs';
 import { XoController } from '../abstract-classes/xo-controller.mjs';
 let GroupController = class GroupController extends XoController {
@@ -34,6 +34,13 @@ let GroupController = class GroupController extends XoController {
     getGroup(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "7d98fee4-3357-41a7-ac3f-9124212badb7"
+     */
+    async deleteGroup(id) {
+        const groupId = id;
+        await this.restApi.xoApp.deleteGroup(groupId);
+    }
 };
 __decorate([
     Example(groupIds),
@@ -51,6 +58,12 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], GroupController.prototype, "getGroup", null);
+__decorate([
+    Delete('{id}'),
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], GroupController.prototype, "deleteGroup", null);
 GroupController = __decorate([
     Route('groups'),
     Security('*'),

package/dist/helpers/object-wrapper.helper.mjs

@@ -1,7 +1,14 @@
 import path from 'node:path';
 import pick from 'lodash/pick.js';
+import { BASE_URL } from '../index.mjs';
 const { join } = path.posix;
-export function makeObjectMapper(req, path = req.path) {
+export function makeObjectMapper(req, path) {
+    if (path === undefined) {
+        path = req.path;
+    }
+    else {
+        path = `${BASE_URL}/${path}`;
+    }
     const makeUrl = ({ id }) => join(path, typeof id === 'number' ? String(id) : id);
     let objectMapper;
     const { query } = req;

package/dist/helpers/utils.helper.mjs

@@ -1,4 +1,77 @@
+import { createLogger } from '@xen-orchestra/log';
+import { isPromise } from 'node:util/types';
 export const NDJSON_CONTENT_TYPE = 'application/x-ndjson';
-export const isSrWritable = (sr) => sr.content_type !== 'iso' && sr.size > 0;
+const log = createLogger('xo:rest-api:utils-helper');
+export const isSrWritable = (sr) => isSrWritableOrIso(sr) && sr.content_type !== 'iso';
+export const isSrWritableOrIso = (sr) => sr.size > 0;
 export const isReplicaVm = (vm) => 'start' in vm.blockedOperations && vm.other['xo:backup:job'] !== undefined;
 export const vmContainsNoBakTag = (vm) => vm.tags.some(t => t.split('=', 1)[0] === 'xo:no-bak');
+export const getTopPerProperty = (array, { length = Infinity, prop }) => {
+    // avoid mutate original array
+    let arr = [...array];
+    arr.sort((prev, next) => {
+        const prevProp = +prev[prop];
+        const nextProp = +next[prop];
+        if (typeof prevProp !== 'number' || typeof nextProp !== 'number') {
+            throw new Error(`cannot parse: ${prop} as number. ${prev}, ${next}`);
+        }
+        if (isNaN(prevProp) && isNaN(nextProp)) {
+            return 0;
+        }
+        if (isNaN(prevProp)) {
+            return 1;
+        }
+        if (isNaN(nextProp)) {
+            return -1;
+        }
+        return nextProp - prevProp;
+    });
+    if (arr.length > length) {
+        arr = arr.slice(0, length);
+    }
+    return arr;
+};
+export async function promiseWriteInStream({ maybePromise, path, stream, handleError = false, }) {
+    let data;
+    if (isPromise(maybePromise)) {
+        try {
+            data = await maybePromise;
+        }
+        catch (err) {
+            if (!handleError) {
+                throw err;
+            }
+            log.error(`promiseWriteInStream for ${path} failed`, err);
+            data = { error: true };
+        }
+    }
+    else {
+        data = maybePromise;
+    }
+    if (stream !== undefined) {
+        if (stream.writableNeedDrain) {
+            await new Promise(resolve => stream.once('drain', resolve));
+        }
+        // handle path like `foo.bar` -> `{foo: {bar: data}}`
+        const obj = {};
+        let current = obj;
+        const keys = path.split('.');
+        keys.forEach((key, index) => {
+            if (index === keys.length - 1) {
+                current[key] = data;
+            }
+            else {
+                current[key] = {};
+                current = current[key];
+            }
+        });
+        stream.write(JSON.stringify(obj) + '\n');
+    }
+    return data;
+}
+export function escapeUnsafeComplexMatcher(maybeString) {
+    if (maybeString === undefined || maybeString === '') {
+        return maybeString;
+    }
+    return `(${maybeString})`;
+}

package/dist/hosts/host.controller.mjs

@@ -7,16 +7,22 @@ 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 { Example, Get, Path, Query, Request, Response, Route, Security, SuccessResponse, Tags } from 'tsoa';
 import { inject } from 'inversify';
+import { pipeline } from 'node:stream/promises';
 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 { host, hostIds, hostStats, partialHosts } from '../open-api/oa-examples/host.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { internalServerErrorResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 let HostController = class HostController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('host', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "id,name_label,productBrand"
@@ -39,6 +45,55 @@ let HostController = class HostController extends XapiXoController {
     getHostStats(id, granularity) {
         return this.restApi.xoApp.getXapiHostStats(id, granularity);
     }
+    /**
+     * Host must be running
+     *
+     * Download the audit log of a host.
+     *
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     *
+     */
+    async getAuditLog(req, id) {
+        const xapiHost = this.getXapiObject(id);
+        const res = req.res;
+        const response = await xapiHost.$xapi.getResource('/audit_log', { host: xapiHost });
+        const date = new Date().toISOString();
+        const headers = new Headers({
+            'Content-Type': 'application/octet-stream',
+            'Content-Disposition': `attachment; filename="${host.name_label}-${date}-audit.txt"`,
+        });
+        res.setHeaders(headers);
+        await pipeline(response.body, this.maybeCompressResponse(req, res));
+    }
+    /**
+     * Host must be running
+     *
+     * Download all logs of a host.
+     *
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     *
+     */
+    async getHostLogs(req, id) {
+        const xapiHost = this.getXapiObject(id);
+        const res = req.res;
+        const response = await xapiHost.$xapi.getResource('/host_logs_download', { host: xapiHost });
+        res.setHeader('Content-Type', 'application/gzip');
+        await pipeline(response.body, res);
+    }
+    /**
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getHostAlarms(req, id, fields, ndjson, filter, limit) {
+        const host = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${host.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(hostIds),
@@ -65,12 +120,41 @@ __decorate([
     __param(0, Path()),
     __param(1, Query())
 ], HostController.prototype, "getHostStats", null);
+__decorate([
+    Get('{id}/audit.txt'),
+    SuccessResponse(200, 'Download started', 'application/octet-stream'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Request()),
+    __param(1, Path())
+], HostController.prototype, "getAuditLog", null);
+__decorate([
+    Get('{id}/logs.tgz'),
+    SuccessResponse(200, 'Download started', 'application/gzip'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Request()),
+    __param(1, Path())
+], HostController.prototype, "getHostLogs", 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())
+], HostController.prototype, "getHostAlarms", null);
 HostController = __decorate([
     Route('hosts'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('hosts'),
     provide(HostController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], HostController);
 export { HostController };

package/dist/hosts/host.service.mjs

@@ -0,0 +1,78 @@
+import { asyncEach } from '@vates/async-each';
+import { createLogger } from '@xen-orchestra/log';
+import { HOST_POWER_STATE } from '@vates/types';
+const log = createLogger('xo:rest-api:host-service');
+export class HostService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    getHostsStatus(opts) {
+        const hosts = this.#restApi.getObjectsByType('host', opts);
+        let nRunning = 0;
+        let nHalted = 0;
+        let nDisabled = 0;
+        let nUnknown = 0;
+        let total = 0;
+        for (const id in hosts) {
+            total++;
+            const host = hosts[id];
+            if (!host.enabled) {
+                nDisabled++;
+                continue;
+            }
+            switch (host.power_state) {
+                case HOST_POWER_STATE.RUNNING:
+                    nRunning++;
+                    break;
+                case HOST_POWER_STATE.HALTED:
+                    nHalted++;
+                    break;
+                default:
+                    nUnknown++;
+                    break;
+            }
+        }
+        return {
+            disabled: nDisabled,
+            running: nRunning,
+            halted: nHalted,
+            unknown: nUnknown,
+            total,
+        };
+    }
+    async getMissingPatchesInfo(opts) {
+        if (!(await this.#restApi.xoApp.hasFeatureAuthorization('LIST_MISSING_PATCHES'))) {
+            return {
+                hasAuthorization: false,
+            };
+        }
+        const hosts = Object.values(this.#restApi.getObjectsByType('host', opts));
+        const missingPatches = new Map();
+        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);
+                    patches.forEach(patch => missingPatches.set(patch.id ?? patch.name, patch));
+                }
+            }
+            catch (err) {
+                log.error('listMissingPatches failed', err);
+                nHostsFailed++;
+            }
+        });
+        return {
+            hasAuthorization: true,
+            missingPatches: Array.from(missingPatches.values()),
+            nHostsFailed,
+            nHostsWithMissingPatches,
+            nPoolsWithMissingPatches: poolsWithMissingPatches.size,
+        };
+    }
+}

package/dist/ioc/ioc.mjs

@@ -4,6 +4,9 @@ import { Controller } from 'tsoa';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { VmService } from '../vms/vm.service.mjs';
 import { XoaService } from '../xoa/xoa.service.mjs';
+import { HostService } from '../hosts/host.service.mjs';
+import { PoolService } from '../pools/pool.service.mjs';
+import { AlarmService } from '../alarms/alarm.service.mjs';
 const iocContainer = new Container();
 decorate(injectable(), Controller);
 iocContainer.load(buildProviderModule());
@@ -13,7 +16,7 @@ export function setupContainer(xoApp) {
     }
     iocContainer
         .bind(RestApi)
-        .toDynamicValue(() => new RestApi(xoApp))
+        .toDynamicValue(() => new RestApi(xoApp, iocContainer))
         .inSingletonScope();
     iocContainer
         .bind(XoaService)
@@ -29,5 +32,26 @@ export function setupContainer(xoApp) {
         return new VmService(restApi);
     })
         .inSingletonScope();
+    iocContainer
+        .bind(PoolService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new PoolService(restApi);
+    })
+        .inSingletonScope();
+    iocContainer
+        .bind(HostService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new HostService(restApi);
+    })
+        .inSingletonScope();
+    iocContainer
+        .bind(AlarmService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new AlarmService(restApi);
+    })
+        .inSingletonScope();
 }
 export { iocContainer };

package/dist/messages/message.controller.mjs

@@ -12,7 +12,7 @@ import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } f
 import { inject } from 'inversify';
 import { noSuchObject } from 'xo-common/api-errors.js';
 import { provide } from 'inversify-binding-decorators';
-import { alarmPredicate } from '../alarms/alarm.controller.mjs';
+import { alarmPredicate } from '../alarms/alarm.service.mjs';
 import { message, messageIds, partialMessages } from '../open-api/oa-examples/message.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
@@ -38,7 +38,7 @@ let MessageController = class MessageController extends XapiXoController {
     getObject(id) {
         const message = super.getObject(id);
         if (alarmPredicate(message)) {
-            /* throw */ noSuchObject(id, 'message');
+            throw noSuchObject(id, 'message');
         }
         return message;
     }