@xen-orchestra/rest-api 0.26.0 → 0.28.0

package/dist/hosts/host.controller.mjs

@@ -8,6 +8,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Body, Delete, Example, Get, Middlewares, Path, Post, Put, Query, Request, Response, Route, Security, SuccessResponse, Tags, } from 'tsoa';
+import { asyncEach } from '@vates/async-each';
+import { defer } from 'golike-defer';
 import { json } from 'express';
 import { inject } from 'inversify';
 import { invalidParameters } from 'xo-common/api-errors.js';
@@ -182,7 +184,71 @@ let HostController = class HostController extends XapiXoController {
             taskProperties: {
                 name: 'reconfigure host management interface',
                 objectId: hostId,
-                args: body,
+                params: body,
+            },
+        });
+    }
+    /**
+     * Disable a host.
+     *
+     * Set `evacuate` to `true` to also evacuate all running VMs to other hosts in the pool.
+     *
+     * Use `vmIdsToForceMigrate` to unblock VMs whose migration is currently blocked (e.g. by `pool_migrate` or `migrate_send` blocked operations).
+     *
+     * Use `force` to ignore evacuation errors.
+     *
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     * @example body { "evacuate": true, "vmIdsToForceMigrate": ["f07ab729-c0e8-721c-45ec-f11276377030"] }
+     */
+    disable(id, body, sync) {
+        const hostId = id;
+        const action = defer(async ($defer) => {
+            const xapiHost = this.getXapiObject(hostId);
+            const xapi = xapiHost.$xapi;
+            if (body?.evacuate !== true) {
+                await xapi.call('host.disable', xapiHost.$ref);
+                return;
+            }
+            if (body.vmIdsToForceMigrate !== undefined) {
+                await asyncEach(body.vmIdsToForceMigrate, async (vmId) => {
+                    const xoVm = this.restApi.getObject(vmId, 'VM');
+                    for (const operation of ['pool_migrate', 'migrate_send']) {
+                        const reason = xoVm.blockedOperations[operation];
+                        if (reason !== undefined) {
+                            await xapi.call('VM.remove_from_blocked_operations', xoVm._xapiRef, operation);
+                            $defer(() => xapi.call('VM.add_to_blocked_operations', xoVm._xapiRef, operation, reason));
+                        }
+                    }
+                });
+            }
+            await xapi.clearHost(xapiHost, body.force);
+        });
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: body?.evacuate === true ? 'disable and evacuate host' : 'disable host',
+                objectId: hostId,
+                params: body,
+            },
+        });
+    }
+    /**
+     * Enable a host, taking it out of disabled state.
+     *
+     * @example id "b61a5c92-700e-4966-a13b-00633f03eea8"
+     */
+    enable(id, sync) {
+        const hostId = id;
+        const action = async () => {
+            await this.getXapiObject(hostId).$xapi.enableHost(hostId);
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'enable host',
+                objectId: hostId,
             },
         });
     }
@@ -308,6 +374,29 @@ __decorate([
     __param(1, Body()),
     __param(2, Query())
 ], HostController.prototype, "managementReconfigure", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/disable'),
+    Middlewares(json()),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(invalidParametersResp.status, invalidParametersResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Body()),
+    __param(2, Query())
+], HostController.prototype, "disable", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/enable'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(internalServerErrorResp.status, internalServerErrorResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], HostController.prototype, "enable", null);
 HostController = __decorate([
     Route('hosts'),
     Security('*'),

package/dist/ioc/ioc.mjs

@@ -12,6 +12,7 @@ import { UserService } from '../users/user.service.mjs';
 import { BackupJobService } from '../backup-jobs/backup-job.service.mjs';
 import { BackupLogService } from '../backup-logs/backup-log.service.mjs';
 import { EventService } from '../events/event.service.mjs';
+import { NetworkService } from '../networks/network.service.mjs';
 const iocContainer = new Container();
 decorate(injectable(), Controller);
 iocContainer.load(buildProviderModule());
@@ -92,5 +93,12 @@ export function setupContainer(xoApp) {
         return new EventService(restApi);
     })
         .inSingletonScope();
+    iocContainer
+        .bind(NetworkService)
+        .toDynamicValue(ctx => {
+        const restApi = ctx.container.get(RestApi);
+        return new NetworkService(restApi);
+    })
+        .inSingletonScope();
 }
 export { iocContainer };

package/dist/middlewares/generic-error-handler.middleware.mjs

@@ -6,7 +6,7 @@ const log = createLogger('xo:rest-api:error-handler');
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export default function genericErrorHandler(error, req, res, _next) {
     if (!(error instanceof Error)) {
-        log.error(error);
+        log.error(JSON.stringify(error));
         res.status(500).json({ error });
         return;
     }

package/dist/networks/network.service.mjs

@@ -0,0 +1,23 @@
+export class NetworkService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    async create(poolId, body) {
+        const xapiPool = this.#restApi.getXapiObject(poolId, 'pool');
+        const xapi = xapiPool.$xapi;
+        let xapiNetwork;
+        const { nbd, ...rest } = body;
+        const createParams = rest;
+        if ('pifIds' in createParams) {
+            xapiNetwork = await xapi.createBondedNetwork(createParams);
+        }
+        else {
+            xapiNetwork = await xapi.createNetwork(createParams);
+        }
+        if (nbd) {
+            await xapiNetwork.$call('add_purpose', 'nbd');
+        }
+        return xapiNetwork.uuid;
+    }
+}