@xen-orchestra/rest-api 0.11.0 → 0.13.0

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 };

package/dist/vdis/vdi.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 { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { partialVdis, vdi, vdiIds } from '../open-api/oa-examples/vdi.oa-example.mjs';
 let VdiController = class VdiController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VDI', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "*"
@@ -32,6 +37,20 @@ let VdiController = class VdiController extends XapiXoController {
     getVdi(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "c77f9955-c1d2-4b39-aa1c-73cdb2dacb7e"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVdiAlarms(req, id, fields, ndjson, filter, limit) {
+        const vdi = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vdi.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vdiIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VdiController.prototype, "getVdi", 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())
+], VdiController.prototype, "getVdiAlarms", null);
 VdiController = __decorate([
     Route('vdis'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vdis'),
     provide(VdiController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VdiController);
 export { VdiController };

package/dist/vifs/vif.controller.mjs

@@ -9,14 +9,19 @@ 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 { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
 import { provide } from 'inversify-binding-decorators';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { partialVifs, vif, vifIds } from '../open-api/oa-examples/vif.oa-example.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
+import { AlarmService } from '../alarms/alarm.service.mjs';
 let VifController = class VifController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VIF', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      * @example fields "attached,id,device"
@@ -32,6 +37,20 @@ let VifController = class VifController extends XapiXoController {
     getVif(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "f028c5d4-578a-332c-394e-087aaca32dd3"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVifAlarms(req, id, fields, ndjson, filter, limit) {
+        const vif = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vif.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vifIds),
@@ -49,12 +68,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VifController.prototype, "getVif", 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())
+], VifController.prototype, "getVifAlarms", null);
 VifController = __decorate([
     Route('vifs'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vifs'),
     provide(VifController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VifController);
 export { VifController };

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

@@ -11,12 +11,17 @@ import { inject } from 'inversify';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+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 { provide } from 'inversify-binding-decorators';
 import { partialVmControllers, vmController, vmControllerIds, } from '../open-api/oa-examples/vm-controller.oa-example.mjs';
 let VmControllerController = class VmControllerController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VM-controller', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      *
@@ -33,6 +38,20 @@ let VmControllerController = class VmControllerController extends XapiXoControll
     getVmController(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "9b4775bd-9493-490a-9afa-f786a44caa4f"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVmControllerAlarms(req, id, fields, ndjson, filter, limit) {
+        const vmController = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vmController.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vmControllerIds),
@@ -50,12 +69,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VmControllerController.prototype, "getVmController", 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())
+], VmControllerController.prototype, "getVmControllerAlarms", null);
 VmControllerController = __decorate([
     Route('vm-controllers'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vms'),
     provide(VmControllerController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VmControllerController);
 export { VmControllerController };

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

@@ -9,14 +9,19 @@ 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 { AlarmService } from '../alarms/alarm.service.mjs';
+import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
 import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { provide } from 'inversify-binding-decorators';
 import { partialVmSnapshots, vmSnapshot, vmSnapshotIds } from '../open-api/oa-examples/vm-snapshot.oa-example.mjs';
 let VmSnapshotController = class VmSnapshotController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VM-snapshot', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      *
@@ -33,6 +38,20 @@ let VmSnapshotController = class VmSnapshotController extends XapiXoController {
     getVmSnapshot(id) {
         return this.getObject(id);
     }
+    /**
+     * @example id "d68fca2c-41e6-be87-d790-105c1642a090"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVmSnapshotAlarms(req, id, fields, ndjson, filter, limit) {
+        const vmSnapshot = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vmSnapshot.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vmSnapshotIds),
@@ -50,12 +69,25 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], VmSnapshotController.prototype, "getVmSnapshot", 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())
+], VmSnapshotController.prototype, "getVmSnapshotAlarms", null);
 VmSnapshotController = __decorate([
     Route('vm-snapshots'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('vms'),
     provide(VmSnapshotController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VmSnapshotController);
 export { VmSnapshotController };

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

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

package/dist/vms/vm.controller.mjs

@@ -11,16 +11,21 @@ import { Example, Get, Path, Post, Query, Request, Response, Route, Security, Ta
 import { inject } from 'inversify';
 import { incorrectState, invalidParameters } from 'xo-common/api-errors.js';
 import { provide } from 'inversify-binding-decorators';
+import { AlarmService } from '../alarms/alarm.service.mjs';
 import { asynchronousActionResp, createdResp, internalServerErrorResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { BASE_URL } from '../index.mjs';
+import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
+import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
 import { partialVms, vm, vmIds, vmStatsExample } from '../open-api/oa-examples/vm.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { taskLocation } from '../open-api/oa-examples/task.oa-example.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 const IGNORED_VDIS_TAG = '[NOSNAP]';
 let VmController = class VmController extends XapiXoController {
-    constructor(restApi) {
+    #alarmService;
+    constructor(restApi, alarmService) {
         super('VM', restApi);
+        this.#alarmService = alarmService;
     }
     /**
      *
@@ -294,6 +299,20 @@ let VmController = class VmController extends XapiXoController {
             },
         });
     }
+    /**
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     * @example fields "id,time"
+     * @example filter "time:>1747053793"
+     * @example limit 42
+     */
+    getVmAlarms(req, id, fields, ndjson, filter, limit) {
+        const vm = this.getObject(id);
+        const alarms = this.#alarmService.getAlarms({
+            filter: `${escapeUnsafeComplexMatcher(filter) ?? ''} object:uuid:${vm.uuid}`,
+            limit,
+        });
+        return this.sendObjects(Object.values(alarms), req, 'alarms');
+    }
 };
 __decorate([
     Example(vmIds),
@@ -433,6 +452,18 @@ __decorate([
     __param(1, Body()),
     __param(2, Query())
 ], VmController.prototype, "snapshotVm", 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())
+], VmController.prototype, "getVmAlarms", null);
 VmController = __decorate([
     Route('vms'),
     Security('*'),
@@ -442,6 +473,7 @@ VmController = __decorate([
     // It automatically bind the class to the IOC container that handles dependency injection
     ,
     provide(VmController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(AlarmService))
 ], VmController);
 export { VmController };

package/dist/vms/vm.service.mjs

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