@xen-orchestra/rest-api 0.10.0 → 0.12.0

package/dist/pifs/pif.controller.mjs

@@ -10,13 +10,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } 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 { partialPifs, pif, pifIds } from '../open-api/oa-examples/pif.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 let PifController = class PifController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('PIF', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "attached,device,deviceName,id"
@@ -32,6 +37,20 @@ let PifController = class PifController extends XapiXoController {
     getPif(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "d9e42451-3794-089f-de81-4ee0e6137bee"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getPifAlarms(req, id, fields, ndjson, filter, limit) {
+        const pif = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${pif.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(pifIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], PifController.prototype, "getPif", 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())
+], PifController.prototype, "getPifAlarms", null);
 PifController = __decorate([
     Route('pifs'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('pifs'),
     provide(PifController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], PifController);
 export { PifController };

package/dist/pools/pool.controller.mjs

@@ -9,21 +9,30 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Example, Get, Path, Query, Response, Request, Route, Security, Tags, Post, Middlewares, Body, SuccessResponse, } from 'tsoa';
 import { inject } from 'inversify';
+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, createdResp, featureUnauthorized, internalServerErrorResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
-import { createVm, importVm, partialPools, pool, poolIds } from '../open-api/oa-examples/pool.oa-example.mjs';
+import { AlarmService } from '../alarms/alarm.service.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
+import { createVm, importVm, partialPools, pool, poolDashboard, poolIds, poolStats, } from '../open-api/oa-examples/pool.oa-example.mjs';
 import { taskLocation } from '../open-api/oa-examples/task.oa-example.mjs';
 import { createNetwork } from '../open-api/oa-examples/schedule.oa-example.mjs';
 import { BASE_URL } from '../index.mjs';
 import { VmService } from '../vms/vm.service.mjs';
+import { PoolService } from './pool.service.mjs';
+import { escapeUnsafeComplexMatcher, NDJSON_CONTENT_TYPE } from '../helpers/utils.helper.mjs';
 let PoolController = class PoolController extends XapiXoController {
     #vmService;
-    constructor(restApi, vmService) {
+    #poolService;
+    #alarmService;
+    constructor(restApi, vmService, poolService, alarmService) {
         super('pool', restApi);
         this.#vmService = vmService;
+        this.#poolService = poolService;
+        this.#alarmService = alarmService;
     }
     /**
      *
@@ -170,6 +179,48 @@ let PoolController = class PoolController extends XapiXoController {
             },
         });
     }
+    /**
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629677"
+     */
+    getStats(id, granularity) {
+        return this.restApi.xoApp.getXapiPoolStats(id, granularity);
+    }
+    /**
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629677"
+     */
+    async getPoolDashboard(req, id, ndjson) {
+        const poolId = id;
+        // throw if pool not found
+        this.getObject(poolId);
+        const stream = ndjson ? new PassThrough() : undefined;
+        const isStream = ndjson && stream !== undefined;
+        if (isStream) {
+            const res = req.res;
+            res.setHeader('Content-Type', NDJSON_CONTENT_TYPE);
+            stream.pipe(res);
+        }
+        const dashboard = await this.#poolService.getDashboard(poolId, { stream });
+        if (isStream) {
+            stream.end();
+        }
+        else {
+            return dashboard;
+        }
+    }
+    /**
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629676"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getPoolAlarms(req, id, fields, ndjson, filter, limit) {
+        const pool = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${pool.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(poolIds),
@@ -256,6 +307,34 @@ __decorate([
     __param(1, Body()),
     __param(2, Query())
 ], PoolController.prototype, "createVm", null);
+__decorate([
+    Example(poolStats),
+    Get('{id}/stats'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(422, 'Invalid granularity'),
+    __param(0, Path()),
+    __param(1, Query())
+], PoolController.prototype, "getStats", null);
+__decorate([
+    Example(poolDashboard),
+    Get('{id}/dashboard'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query())
+], PoolController.prototype, "getPoolDashboard", 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())
+], PoolController.prototype, "getPoolAlarms", null);
 PoolController = __decorate([
     Route('pools'),
     Security('*'),
@@ -263,6 +342,8 @@ PoolController = __decorate([
     Tags('pools'),
     provide(PoolController),
     __param(0, inject(RestApi)),
-    __param(1, inject(VmService))
+    __param(1, inject(VmService)),
+    __param(2, inject(PoolService)),
+    __param(3, inject(AlarmService))
 ], PoolController);
 export { PoolController };

package/dist/pools/pool.service.mjs

@@ -0,0 +1,212 @@
+import { createLogger } from '@xen-orchestra/log';
+import { HOST_POWER_STATE, VM_POWER_STATE, } from '@vates/types';
+import { HostService } from '../hosts/host.service.mjs';
+import { VmService } from '../vms/vm.service.mjs';
+import { AlarmService } from '../alarms/alarm.service.mjs';
+import { getTopPerProperty, isSrWritableOrIso, promiseWriteInStream } from '../helpers/utils.helper.mjs';
+import { getFromAsyncCache } from '../helpers/cache.helper.mjs';
+const log = createLogger('xo:rest-api:pool-service');
+export class PoolService {
+    #restApi;
+    #hostService;
+    #vmService;
+    #alarmService;
+    #dashboardAsyncCache = new Map();
+    #dashboardCacheOpts;
+    constructor(restApi) {
+        this.#restApi = restApi;
+        this.#hostService = this.#restApi.ioc.get(HostService);
+        this.#vmService = this.#restApi.ioc.get(VmService);
+        this.#alarmService = this.#restApi.ioc.get(AlarmService);
+        this.#dashboardCacheOpts = {
+            timeout: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheTimeout') ?? 60000,
+            expiresIn: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheExpiresIn'),
+        };
+    }
+    #getHostsStatus(poolId) {
+        const { running, disabled, halted, total } = this.#hostService.getHostsStatus({
+            filter: host => host.$pool === poolId,
+        });
+        return { running, disabled, halted, total };
+    }
+    #getVmsStatus(poolId) {
+        const { running, halted, paused, total, suspended } = this.#vmService.getVmsStatus({
+            filter: vm => vm.$pool === poolId,
+        });
+        return {
+            running,
+            halted,
+            paused,
+            total,
+            suspended,
+        };
+    }
+    #getAlarms(poolId) {
+        const alarms = this.#alarmService.getAlarms({ filter: alarm => alarm.$pool === poolId });
+        return Object.keys(alarms);
+    }
+    async #getMissingPatches(poolId) {
+        const missingPatchesInfo = await this.#hostService.getMissingPatchesInfo({ filter: host => host.$pool === poolId });
+        if (!missingPatchesInfo.hasAuthorization) {
+            return {
+                hasAuthorization: false,
+            };
+        }
+        const { hasAuthorization, missingPatches } = missingPatchesInfo;
+        return {
+            hasAuthorization,
+            missingPatches,
+        };
+    }
+    #getTopFiveSrsUsage(poolId) {
+        const srs = Object.values(this.#restApi.getObjectsByType('SR', {
+            filter: sr => sr.$pool === poolId && isSrWritableOrIso(sr),
+        }));
+        const topFive = getTopPerProperty(srs.map(({ name_label, id, physical_usage, size }) => ({
+            name_label,
+            id,
+            percent: (physical_usage / size) * 100,
+            physical_usage,
+            size,
+        })), { prop: 'percent', length: 5 });
+        return topFive;
+    }
+    #getTopFiveHostsRamUsage(poolId) {
+        const hosts = Object.values(this.#restApi.getObjectsByType('host', {
+            filter: host => host.$pool === poolId && host.power_state === HOST_POWER_STATE.RUNNING,
+        }));
+        const topFive = getTopPerProperty(hosts.map(({ name_label, id, memory: { size, usage } }) => ({
+            name_label,
+            id,
+            size,
+            usage,
+            percent: (usage / size) * 100,
+        })), { length: 5, prop: 'percent' });
+        return topFive;
+    }
+    #getVmWithLastRamInfo(vm, stats) {
+        const memory = stats.stats.memory?.pop() ?? 0;
+        const memoryFree = stats.stats.memoryFree?.pop() ?? 0;
+        const usage = memory - memoryFree;
+        return { ...vm, memoryStats: { memory, memoryFree, usage } };
+    }
+    #getVmWithLastCpuInfo(vm, stats) {
+        const cpusStats = Object.values(stats.stats.cpus ?? {});
+        const usage = cpusStats.reduce((total, cpuStats, index) => {
+            const lastCpuStat = cpuStats.pop();
+            if (lastCpuStat == null) {
+                log.warn(`cpu#${index} is null. vm:`, vm.id);
+            }
+            total += lastCpuStat ?? 0;
+            return total;
+        }, 0) / cpusStats.length;
+        return { ...vm, usage };
+    }
+    async #getTopFiveVmsRamCpuUsage(poolId) {
+        const vmsUsageResult = await getFromAsyncCache(this.#dashboardAsyncCache, 'vmsRamCpuUsage', async () => {
+            const vms = this.#restApi.getObjectsByType('VM', {
+                filter: vm => vm.$pool === poolId &&
+                    (vm.power_state === VM_POWER_STATE.RUNNING || vm.power_state === VM_POWER_STATE.PAUSED),
+            });
+            const vmsWithRamInfo = [];
+            const vmsWithCpuInfo = [];
+            for (const id in vms) {
+                const vm = vms[id];
+                const stats = await this.#restApi.xoApp.getXapiVmStats(vm.id);
+                if (vm.managementAgentDetected) {
+                    const { memoryStats: { memory, memoryFree, usage }, } = this.#getVmWithLastRamInfo(vm, stats);
+                    vmsWithRamInfo.push({
+                        id: vm.id,
+                        name_label: vm.name_label,
+                        memory,
+                        memoryFree,
+                        percent: (usage / memory) * 100,
+                    });
+                }
+                const { usage: cpuUsage } = this.#getVmWithLastCpuInfo(vm, stats);
+                vmsWithCpuInfo.push({ id: vm.id, name_label: vm.name_label, percent: cpuUsage });
+            }
+            const topFiveRamUsage = getTopPerProperty(vmsWithRamInfo, { prop: 'percent', length: 5 });
+            const topFiveCpuUsage = getTopPerProperty(vmsWithCpuInfo, { prop: 'percent', length: 5 });
+            return {
+                ram: topFiveRamUsage,
+                cpu: topFiveCpuUsage,
+            };
+        }, this.#dashboardCacheOpts);
+        if (vmsUsageResult?.value !== undefined) {
+            return { ...vmsUsageResult.value, isExpired: vmsUsageResult.isExpired };
+        }
+    }
+    async #getTopFiveHostsCpuUsage(poolId) {
+        const hosts = this.#restApi.getObjectsByType('host', {
+            filter: host => host.$pool === poolId && host.power_state === HOST_POWER_STATE.RUNNING,
+        });
+        const hostsWithPercent = [];
+        for (const id in hosts) {
+            const host = hosts[id];
+            const stats = await this.#restApi.xoApp.getXapiHostStats(host.id, 'seconds');
+            const cpusStats = Object.values(stats.stats.cpus ?? {});
+            const percent = cpusStats.reduce((total, cpuStats, index) => {
+                const lastCpuStat = cpuStats.pop();
+                if (lastCpuStat == null) {
+                    log.warn(`cpu#${index} is null. host:`, host.id);
+                }
+                total += lastCpuStat ?? 0;
+                return total;
+            }, 0) / cpusStats.length;
+            hostsWithPercent.push({ percent, id: host.id, name_label: host.name_label });
+        }
+        const topFive = getTopPerProperty(hostsWithPercent, { prop: 'percent', length: 5 });
+        return topFive;
+    }
+    #getCpuProvisioning(poolId) {
+        const pool = this.#restApi.getObject(poolId, 'pool');
+        const vms = this.#restApi.getObjectsByType('VM', {
+            filter: vm => vm.$pool === poolId && (vm.power_state === VM_POWER_STATE.RUNNING || vm.power_state === VM_POWER_STATE.PAUSED),
+        });
+        let assignedVcpu = 0;
+        for (const id in vms) {
+            const vm = vms[id];
+            assignedVcpu += vm.CPUs.number;
+        }
+        const total = pool.cpus.cores ?? 0;
+        const percent = total === 0 ? 0 : (assignedVcpu * 100) / total;
+        return {
+            total,
+            assigned: assignedVcpu,
+            percent,
+        };
+    }
+    async getDashboard(id, { stream } = {}) {
+        const [hostStatus, vmsStatus, alarms, missingPatches, storageUsage, hostsRamUsage, hostsCpuUsage, cpuProvisioning, vmsUsage,] = await Promise.all([
+            promiseWriteInStream({ maybePromise: this.#getHostsStatus(id), path: 'hosts.status', stream }),
+            promiseWriteInStream({ maybePromise: this.#getVmsStatus(id), path: 'vms.status', stream }),
+            promiseWriteInStream({ maybePromise: this.#getAlarms(id), path: 'alarms', stream }),
+            promiseWriteInStream({ maybePromise: this.#getMissingPatches(id), path: 'hosts.missingPatches', stream }),
+            promiseWriteInStream({ maybePromise: this.#getTopFiveSrsUsage(id), path: 'srs.topFiveUsage', stream }),
+            promiseWriteInStream({ maybePromise: this.#getTopFiveHostsRamUsage(id), path: 'hosts.topFiveUsage.ram', stream }),
+            promiseWriteInStream({ maybePromise: this.#getTopFiveHostsCpuUsage(id), path: 'hosts.topFiveUsage.cpu', stream }),
+            promiseWriteInStream({ maybePromise: this.#getCpuProvisioning(id), path: 'cpuProvisioning', stream }),
+            promiseWriteInStream({ maybePromise: this.#getTopFiveVmsRamCpuUsage(id), path: 'vms.topFiveUsage', stream }),
+        ]);
+        return {
+            hosts: {
+                status: hostStatus,
+                topFiveUsage: {
+                    ram: hostsRamUsage,
+                    cpu: hostsCpuUsage,
+                },
+                missingPatches,
+            },
+            vms: {
+                status: vmsStatus,
+                topFiveUsage: vmsUsage,
+            },
+            srs: {
+                topFiveUsage: storageUsage,
+            },
+            alarms,
+            cpuProvisioning,
+        };
+    }
+}

package/dist/rest-api/rest-api.mjs

@@ -1,7 +1,9 @@
 export class RestApi {
+    #ioc;
     #xoApp;
-    constructor(xoApp) {
+    constructor(xoApp, iocContainer) {
         this.#xoApp = xoApp;
+        this.#ioc = iocContainer;
     }
     get tasks() {
         return this.#xoApp.tasks;
@@ -9,6 +11,9 @@ export class RestApi {
     get xoApp() {
         return this.#xoApp;
     }
+    get ioc() {
+        return this.#ioc;
+    }
     authenticateUser(...args) {
         return this.#xoApp.authenticateUser(...args);
     }

package/dist/srs/sr.controller.mjs

@@ -10,13 +10,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } 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 { partialSrs, sr, srIds } from '../open-api/oa-examples/sr.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 let SrController = class SrController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('SR', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "uuid,name_label,allocationStrategy"
@@ -32,6 +37,20 @@ let SrController = class SrController extends XapiXoController {
     getSr(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "c4284e12-37c9-7967-b9e8-83ef229c3e03"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getSrAlarms(req, id, fields, ndjson, filter, limit) {
+        const sr = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${sr.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(srIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], SrController.prototype, "getSr", 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())
+], SrController.prototype, "getSrAlarms", null);
 SrController = __decorate([
     Route('srs'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('srs'),
     provide(SrController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], SrController);
 export { SrController };

package/dist/users/user.controller.mjs

@@ -7,10 +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, 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 { provide } from 'inversify-binding-decorators';
-import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
-import { partialUsers, user, userIds } from '../open-api/oa-examples/user.oa-example.mjs';
+import { createdResp, invalidParameters, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
+import { partialUsers, user, userId, userIds } from '../open-api/oa-examples/user.oa-example.mjs';
 import { XoController } from '../abstract-classes/xo-controller.mjs';
 let UserController = class UserController extends XoController {
     // --- abstract methods
@@ -44,6 +45,19 @@ let UserController = class UserController extends XoController {
     getUser(id) {
         return this.getObject(id);
     }
+    /**
+     * @example body { "name": "new user", "password": "password", "permission": "none" }
+     */
+    async createUser(body) {
+        const user = await this.restApi.xoApp.createUser(body);
+        return { id: user.id };
+    }
+    /**
+     * @example id "722d17b9-699b-49d2-8193-be1ac573d3de"
+     */
+    async deleteUser(id) {
+        await this.restApi.xoApp.deleteUser(id);
+    }
 };
 __decorate([
     Example(userIds),
@@ -61,6 +75,21 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], UserController.prototype, "getUser", null);
+__decorate([
+    Example(userId),
+    Post(''),
+    Middlewares(json()),
+    SuccessResponse(createdResp.status, createdResp.description),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Response(invalidParameters.status, invalidParameters.description),
+    __param(0, Body())
+], UserController.prototype, "createUser", null);
+__decorate([
+    Delete('{id}'),
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], UserController.prototype, "deleteUser", null);
 UserController = __decorate([
     Route('users'),
     Security('*'),

package/dist/vdi-snapshots/vdi-snapshot.controller.mjs

@@ -10,13 +10,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
 import { inject } from 'inversify';
 import { provide } from 'inversify-binding-decorators';
+import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
 import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { partialVdiSnapshots, vdiSnapshot, vdiSnapshotIds } from '../open-api/oa-examples/vdi-snapshot.oa-example.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
+import { AlarmService } from '../alarms/alarm.service.mjs';
 let VdiSnapshotController = class VdiSnapshotController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VDI-snapshot', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "uuid,snapshot_time,$snapshot_of"
@@ -32,6 +37,20 @@ let VdiSnapshotController = class VdiSnapshotController extends XapiXoController
     getVdiSnapshot(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "d2727772-735b-478f-b6f9-11e7db56dfd0"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVdiSnapshotAlarms(req, id, fields, ndjson, filter, limit) {
+        const vdiSnapshot = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vdiSnapshot.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vdiSnapshotIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VdiSnapshotController.prototype, "getVdiSnapshot", 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())
+], VdiSnapshotController.prototype, "getVdiSnapshotAlarms", null);
 VdiSnapshotController = __decorate([
     Route('vdi-snapshots'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vdis'),
     provide(VdiSnapshotController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VdiSnapshotController);
 export { VdiSnapshotController };