@xen-orchestra/rest-api 0.9.0 → 0.10.0

package/dist/pools/pool.controller.mjs

@@ -14,12 +14,16 @@ 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 { partialPools, pool, poolIds } from '../open-api/oa-examples/pool.oa-example.mjs';
+import { createVm, importVm, partialPools, pool, poolIds } 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';
 let PoolController = class PoolController extends XapiXoController {
-    constructor(restApi) {
+    #vmService;
+    constructor(restApi, vmService) {
         super('pool', restApi);
+        this.#vmService = vmService;
     }
     /**
      *
@@ -120,6 +124,52 @@ let PoolController = class PoolController extends XapiXoController {
             },
         });
     }
+    // For this endpoint, the requestBody type is written directly to `tsoa.json` because TSOA does not provide a decorator for "octet-stream" file uploads
+    /**
+     *  Import an XVA VM into a pool
+     *
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629677"
+     * @example sr "c787b75c-3e0d-70fa-d0c3-cbfd382d7e33"
+     *
+     */
+    async importVm(req, id, sr) {
+        const pool = this.getXapiObject(id);
+        const xapi = pool.$xapi;
+        let srRef;
+        if (sr !== undefined) {
+            srRef = this.restApi.getXapiObject(sr, 'SR').$ref;
+        }
+        const vmRef = await xapi.VM_import(req, srRef);
+        const vmId = await xapi.getField('VM', vmRef, 'uuid');
+        this.setHeader('Location', `${BASE_URL}/vms/${vmId}`);
+        return { id: vmId };
+    }
+    /**
+     * @example id "355ee47d-ff4c-4924-3db2-fd86ae629677"
+     * @example body {
+     * "name_label": "new VM from REST API",
+     * "template": "9bbcc5d1-ad4b-06f1-18f6-03125e809c38",
+     * "boot": true
+     * }
+     */
+    async createVm(id, body, sync) {
+        const poolId = id;
+        const action = async () => {
+            const { affinity, template, ...rest } = body;
+            const params = { affinityHost: affinity, ...rest };
+            const vmId = await this.#vmService.create({ pool: poolId, template, ...params });
+            return { id: vmId };
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: createdResp.status,
+            taskProperties: {
+                args: body,
+                name: 'create VM',
+                objectId: poolId,
+            },
+        });
+    }
 };
 __decorate([
     Example(poolIds),
@@ -181,12 +231,38 @@ __decorate([
     __param(0, Path()),
     __param(1, Query())
 ], PoolController.prototype, "rollingUpdate", null);
+__decorate([
+    Example(importVm),
+    Post('{id}/vms'),
+    Tags('vms'),
+    SuccessResponse(createdResp.status, 'VM imported'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query())
+], PoolController.prototype, "importVm", null);
+__decorate([
+    Example(taskLocation),
+    Example(createVm),
+    Post('{id}/actions/create_vm'),
+    Middlewares(json()),
+    Tags('vms'),
+    SuccessResponse(createdResp.status, createdResp.description),
+    Response(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Body()),
+    __param(2, Query())
+], PoolController.prototype, "createVm", null);
 PoolController = __decorate([
     Route('pools'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('pools'),
     provide(PoolController),
-    __param(0, inject(RestApi))
+    __param(0, inject(RestApi)),
+    __param(1, inject(VmService))
 ], PoolController);
 export { PoolController };

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

@@ -12,6 +12,9 @@ export class RestApi {
     authenticateUser(...args) {
         return this.#xoApp.authenticateUser(...args);
     }
+    getCurrentUser() {
+        return this.#xoApp.apiContext.user;
+    }
     getObject(id, type) {
         return this.#xoApp.getObject(id, type);
     }

package/dist/sms/sm.controller.mjs

@@ -0,0 +1,60 @@
+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 { inject } from 'inversify';
+import { provide } from 'inversify-binding-decorators';
+import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { partialSms, sm, smIds } from '../open-api/oa-examples/sm.oa-example.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
+let SmController = class SmController extends XapiXoController {
+    constructor(restApi) {
+        super('SM', restApi);
+    }
+    /**
+     * @example fields "uuid,name_label,SM_type"
+     * @example filter "SM_type:ext"
+     * @example limit 42
+     */
+    getSrs(req, fields, ndjson, filter, limit) {
+        return this.sendObjects(Object.values(this.getObjects({ filter, limit })), req);
+    }
+    /**
+     * @example id "c4284e12-37c9-7967-b9e8-83ef229c3e03"
+     */
+    getSr(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(smIds),
+    Example(partialSms),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], SmController.prototype, "getSrs", null);
+__decorate([
+    Example(sm),
+    Get('{id}'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], SmController.prototype, "getSr", null);
+SmController = __decorate([
+    Route('sms'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('sms'),
+    provide(SmController),
+    __param(0, inject(RestApi))
+], SmController);
+export { SmController };

package/dist/vms/vm.controller.mjs

@@ -104,15 +104,21 @@ let VmController = class VmController extends XapiXoController {
         await this.getXapiObject(id).$call('forget_data_source_archives', dataSource);
     }
     /**
+     * The VM must be halted
+     *
      * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     * @example body { "hostId": "b61a5c92-700e-4966-a13b-00633f03eea8" }
      */
-    async startVm(id, sync) {
+    async startVm(id, body, sync) {
         const vmId = id;
-        const action = () => this.getXapiObject(vmId).$callAsync('start', false, false);
+        const action = async () => {
+            await this.getXapi(vmId).startVm(vmId, { startOnly: true, hostId: body?.hostId });
+        };
         return this.createAction(action, {
             sync,
             statusCode: noContentResp.status,
             taskProperties: {
+                args: body,
                 name: 'start VM',
                 objectId: vmId,
             },
@@ -188,6 +194,82 @@ let VmController = class VmController extends XapiXoController {
             },
         });
     }
+    /**
+     * The VM must be running
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     */
+    async pauseVm(id, sync) {
+        const vmId = id;
+        const action = async () => {
+            await this.getXapiObject(vmId).$callAsync('pause');
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'pause VM',
+                objectId: vmId,
+            },
+        });
+    }
+    /**
+     * The VM must be running
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     */
+    async suspendVm(id, sync) {
+        const vmId = id;
+        const action = async () => {
+            await this.getXapiObject(vmId).$callAsync('suspend');
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'suspend VM',
+                objectId: vmId,
+            },
+        });
+    }
+    /**
+     * The VM must be suspended
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     */
+    async resumeVm(id, sync) {
+        const vmId = id;
+        const action = async () => {
+            await this.getXapi(vmId).resumeVm(vmId);
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'resume VM',
+                objectId: vmId,
+            },
+        });
+    }
+    /**
+     * The VM must be paused
+     *
+     * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
+     */
+    async unpauseVm(id, sync) {
+        const vmId = id;
+        const action = async () => {
+            await this.getXapi(vmId).unpauseVm(vmId);
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'unpause VM',
+                objectId: vmId,
+            },
+        });
+    }
     /**
      * @example id "f07ab729-c0e8-721c-45ec-f11276377030"
      * @example body { "name_label": "my_awesome_snapshot" }
@@ -261,7 +343,8 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     Response(internalServerErrorResp.status, internalServerErrorResp.description),
     __param(0, Path()),
-    __param(1, Query())
+    __param(1, Body()),
+    __param(2, Query())
 ], VmController.prototype, "startVm", null);
 __decorate([
     Example(taskLocation),
@@ -299,6 +382,46 @@ __decorate([
     __param(0, Path()),
     __param(1, Query())
 ], VmController.prototype, "hardRebootVm", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/pause'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], VmController.prototype, "pauseVm", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/suspend'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], VmController.prototype, "suspendVm", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/resume'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], VmController.prototype, "resumeVm", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/unpause'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], VmController.prototype, "unpauseVm", null);
 __decorate([
     Example(taskLocation),
     Post('{id}/actions/snapshot'),

package/dist/vms/vm.service.mjs

@@ -0,0 +1,47 @@
+import { createLogger } from '@xen-orchestra/log';
+import { defer } from 'golike-defer';
+import { Task } from '@vates/task';
+const log = createLogger('xo:rest-api:vm-service');
+export class VmService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    async #create($defer, params) {
+        const { pool, template, cloud_config, boot, destroy_cloud_config_vdi, network_config, ...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');
+        let cloudConfigVdi;
+        if (cloud_config !== undefined) {
+            const cloudConfigVdiUuid = await xapi.VM_createCloudInitConfig(xapiVm.$ref, cloud_config, {
+                networkConfig: network_config,
+            });
+            cloudConfigVdi = xoApp.getXapiObject(cloudConfigVdiUuid, 'VDI');
+        }
+        let timeLimit;
+        if (boot) {
+            timeLimit = Date.now() + 10 * 60 * 1000;
+            await xapiVm.$callAsync('start', false, false);
+        }
+        if (destroy_cloud_config_vdi && cloudConfigVdi !== undefined && boot) {
+            Task.info('Destruction of the cloud config VDI is planned and will be done as soon as possible');
+            xapi.VDI_destroyCloudInitConfig(cloudConfigVdi.$ref, { timeLimit }).catch(error => {
+                log.error('destroy cloud init config VDI failed', {
+                    error,
+                    vdi: {
+                        uuid: cloudConfigVdi.uuid,
+                    },
+                    vm: {
+                        uuid: xoVm.uuid,
+                    },
+                });
+            });
+        }
+        return xoVm.id;
+    }
+    create = defer(this.#create);
+}

package/dist/xoa/xoa.controller.mjs

@@ -7,26 +7,42 @@ 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 { Controller, Example, Get, Response, Route, Security, Tags } from 'tsoa';
+import { Controller, Example, Get, Query, Request, Response, Route, Security, Tags } from 'tsoa';
 import { inject } from 'inversify';
+import { PassThrough } from 'node:stream';
 import { provide } from 'inversify-binding-decorators';
 import { unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { xoaDashboard } from '../open-api/oa-examples/xoa.oa-example.mjs';
 import { XoaService } from './xoa.service.mjs';
+import { NDJSON_CONTENT_TYPE } from '../helpers/utils.helper.mjs';
 let XoaController = class XoaController extends Controller {
     #xoaService;
     constructor(xoaService) {
         super();
         this.#xoaService = xoaService;
     }
-    async getDashboard() {
-        const dashboard = await this.#xoaService.getDashboard();
-        return dashboard;
+    async getDashboard(req, ndjson) {
+        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.#xoaService.getDashboard({ stream });
+        if (isStream) {
+            stream.end();
+        }
+        else {
+            return dashboard;
+        }
     }
 };
 __decorate([
     Example(xoaDashboard),
-    Get('dashboard')
+    Get('dashboard'),
+    __param(0, Request()),
+    __param(1, Query())
 ], XoaController.prototype, "getDashboard", null);
 XoaController = __decorate([
     Route(''),

package/dist/xoa/xoa.service.mjs

@@ -1,10 +1,11 @@
 import groupBy from 'lodash/groupBy.js';
 import semver from 'semver';
-import { BACKUP_TYPE, } from '@vates/types';
+import { BACKUP_TYPE, HOST_POWER_STATE, VM_POWER_STATE, } from '@vates/types';
 import { asyncEach } from '@vates/async-each';
 import { createLogger } from '@xen-orchestra/log';
 import { createPredicate } from 'value-matcher';
 import { extractIdsFromSimplePattern } from '@xen-orchestra/backups/extractIdsFromSimplePattern.mjs';
+import { isPromise } from 'node:util/types';
 import { noSuchObject } from 'xo-common/api-errors.js';
 import { parse } from 'xo-remote-parser';
 import { getFromAsyncCache } from '../helpers/cache.helper.mjs';
@@ -17,7 +18,7 @@ export class XoaService {
     constructor(restApi) {
         this.#restApi = restApi;
         this.#dashboardCacheOpts = {
-            timeout: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheTimeout'),
+            timeout: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheTimeout') ?? 60000,
             expiresIn: this.#restApi.xoApp.config.getOptionalDuration('rest-api.dashboardCacheExpiresIn'),
         };
     }
@@ -372,26 +373,104 @@ export class XoaService {
             return { ...backupsResult.value, isExpired: backupsResult.isExpired };
         }
     }
-    async getDashboard() {
-        const nPools = this.#getNumberOfPools();
-        const nHosts = this.#getNumberOfHosts();
-        const resourcesOverview = this.#getResourcesOverview();
-        const storageRepositories = this.#getStorageRepositoriesSizeInfo();
-        const poolsStatus = await this.#getPoolsStatus();
-        const missingPatches = await this.#getMissingPatchesInfo();
-        const backupRepositories = await this.#getBackupRepositoriesSizeInfo().catch(err => {
-            log.error('#getBackupRepositoriesSizeInfo failed', err);
-            // explicitly return undefined because typescript understand it as void instead of undefined
-            return undefined;
-        });
-        const nHostsEol = await this.#getNumberOfEolHosts().catch(err => {
-            log.err('#getNumberOfEolHosts failed', err);
-            return undefined;
-        });
-        const backups = await this.#getbackupsInfo().catch(err => {
-            log.error('#getbackupsInfo failed', err);
-            return undefined;
-        });
+    #getHostsStatus() {
+        const hosts = this.#restApi.getObjectsByType('host');
+        let nRunning = 0;
+        let nHalted = 0;
+        let nUnknown = 0;
+        let total = 0;
+        for (const id in hosts) {
+            total++;
+            const host = hosts[id];
+            switch (host.power_state) {
+                case HOST_POWER_STATE.RUNNING:
+                    nRunning++;
+                    break;
+                case HOST_POWER_STATE.HALTED:
+                    nHalted++;
+                    break;
+                default:
+                    nUnknown++;
+                    break;
+            }
+        }
+        return {
+            running: nRunning,
+            halted: nHalted,
+            unknown: nUnknown,
+            total,
+        };
+    }
+    #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,
+        };
+    }
+    async getDashboard({ stream } = {}) {
+        async function promiseWriteInStream(maybePromise, key) {
+            let data;
+            if (isPromise(maybePromise)) {
+                data = await maybePromise;
+            }
+            else {
+                data = maybePromise;
+            }
+            if (stream !== undefined) {
+                if (stream.writableNeedDrain) {
+                    await new Promise(resolve => stream.once('drain', resolve));
+                }
+                stream.write(JSON.stringify({ [key]: data }) + '\n');
+            }
+            return data;
+        }
+        const [nPools, nHosts, hostsStatus, resourcesOverview, vmsStatus, storageRepositories, poolsStatus, missingPatches, backupRepositories, nHostsEol, backups,] = await Promise.all([
+            promiseWriteInStream(this.#getNumberOfPools(), 'nPools'),
+            promiseWriteInStream(this.#getNumberOfHosts(), 'nHosts'),
+            promiseWriteInStream(this.#getHostsStatus(), 'hostsStatus'),
+            promiseWriteInStream(this.#getResourcesOverview(), 'resourcesOverview'),
+            promiseWriteInStream(this.#getVmsStatus(), 'vmsStatus'),
+            promiseWriteInStream(this.#getStorageRepositoriesSizeInfo(), 'storageRepositories'),
+            promiseWriteInStream(this.#getPoolsStatus(), 'poolsStatus'),
+            promiseWriteInStream(this.#getMissingPatchesInfo(), 'missingPatches'),
+            promiseWriteInStream(this.#getBackupRepositoriesSizeInfo().catch(err => {
+                log.error('#getBackupRepositoriesSizeInfo failed', err);
+                // explicitly return undefined because typescript understand it as void instead of undefined
+                return undefined;
+            }), 'backupRepositories'),
+            promiseWriteInStream(this.#getNumberOfEolHosts().catch(err => {
+                log.error('#getNumberOfEolHosts failed', err);
+                return undefined;
+            }), 'nHostsEol'),
+            promiseWriteInStream(this.#getbackupsInfo().catch(err => {
+                log.error('#getbackupsInfo failed', err);
+                return undefined;
+            }), 'backups'),
+        ]);
         return {
             nPools,
             nHosts,
@@ -402,6 +481,8 @@ export class XoaService {
             missingPatches,
             storageRepositories,
             backups,
+            hostsStatus,
+            vmsStatus,
         };
     }
 }