@xen-orchestra/rest-api 0.14.0 → 0.15.0

package/dist/tasks/task.controller.mjs

@@ -0,0 +1,121 @@
+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 * as CM from 'complex-matcher';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+import { Get, Path, Query, Request, Route, Security, Tags, Response, Example } from 'tsoa';
+import { badRequestResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { provide } from 'inversify-binding-decorators';
+import { partialTasks, task, taskIds } from '../open-api/oa-examples/task.oa-example.mjs';
+import pDefer from 'promise-toolbox/defer';
+import { ApiError } from '../helpers/error.helper.mjs';
+import { Transform } from 'node:stream';
+import { makeObjectMapper } from '../helpers/object-wrapper.helper.mjs';
+let TaskController = class TaskController extends XoController {
+    async getAllCollectionObjects() {
+        const result = [];
+        for await (const task of this.restApi.tasks.list()) {
+            result.push(task);
+        }
+        return result;
+    }
+    getCollectionObject(id) {
+        return this.restApi.tasks.get(id);
+    }
+    /**
+     *
+     * If watch is true, ndjson must also be true
+     *
+     * @example fields "status,id,properties"
+     * @example filter "status:failure"
+     * @example limit 42
+     */
+    async getTasks(req, fields, ndjson, watch, filter, limit) {
+        if (watch) {
+            if (!ndjson) {
+                throw new ApiError('watch=true requires ndjson=true', 400);
+            }
+            const userFilter = filter === undefined ? undefined : CM.parse(filter).createPredicate();
+            const stream = new Transform({
+                objectMode: true,
+                transform([event, object], encoding, callback) {
+                    const mapper = makeObjectMapper(req);
+                    callback(null, JSON.stringify([event, mapper(object)]) + '\n');
+                },
+            });
+            stream.on('close', () => {
+                this.restApi.tasks.off('update', update).off('remove', remove);
+            });
+            req.on('close', () => {
+                stream.destroy();
+            });
+            process.on('SIGTERM', () => {
+                req.destroy();
+            });
+            function update(task) {
+                if (userFilter === undefined || userFilter(task)) {
+                    stream.write(['update', task]);
+                }
+            }
+            function remove(taskId) {
+                stream.write(['remove', { id: taskId }]);
+            }
+            this.restApi.tasks.on('update', update).on('remove', remove);
+            return stream;
+        }
+        const tasks = Object.values(await this.getObjects({ filter, limit }));
+        return this.sendObjects(tasks, req);
+    }
+    /**
+     * @example id "0mdd1basu"
+     */
+    async getTask(req, id, wait) {
+        const taskId = id;
+        if (wait) {
+            const { promise, resolve } = pDefer();
+            const stopWatch = await this.restApi.tasks.watch(taskId, task => {
+                if (task.status !== 'pending') {
+                    stopWatch();
+                    resolve(task);
+                }
+            });
+            req.on('close', stopWatch);
+            return promise;
+        }
+        return this.getObject(taskId);
+    }
+};
+__decorate([
+    Example(taskIds),
+    Example(partialTasks),
+    Get(''),
+    Response(badRequestResp.status, badRequestResp.description),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query()),
+    __param(5, Query())
+], TaskController.prototype, "getTasks", null);
+__decorate([
+    Example(task),
+    Get('{id}'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query())
+], TaskController.prototype, "getTask", null);
+TaskController = __decorate([
+    Route('tasks'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('tasks'),
+    provide(TaskController)
+], TaskController);
+export { TaskController };

package/dist/xoa/xoa.service.mjs

@@ -1,4 +1,5 @@
 import groupBy from 'lodash/groupBy.js';
+import { featureUnauthorized } from 'xo-common/api-errors.js';
 import semver from 'semver';
 import { BACKUP_TYPE, VM_POWER_STATE, } from '@vates/types';
 import { createLogger } from '@xen-orchestra/log';
@@ -167,11 +168,11 @@ export class XoaService {
         }
         return nHostsEol;
     }
+    /**
+     * Throw if no authorization
+     */
     async #getMissingPatchesInfo() {
         const missingPatchesInfo = await this.#hostService.getMissingPatchesInfo();
-        if (!missingPatchesInfo.hasAuthorization) {
-            return { hasAuthorization: false };
-        }
         const { hasAuthorization, nHostsFailed, nHostsWithMissingPatches, nPoolsWithMissingPatches } = missingPatchesInfo;
         return {
             hasAuthorization,
@@ -437,7 +438,16 @@ export class XoaService {
                 handleError: true,
             }),
             promiseWriteInStream({ maybePromise: this.#getPoolsStatus(), path: 'poolsStatus', stream }),
-            promiseWriteInStream({ maybePromise: this.#getMissingPatchesInfo(), path: 'missingPatches', stream }),
+            promiseWriteInStream({
+                maybePromise: this.#getMissingPatchesInfo().catch(err => {
+                    if (featureUnauthorized.is(err)) {
+                        return { hasAuthorization: false };
+                    }
+                    throw err;
+                }),
+                path: 'missingPatches',
+                stream,
+            }),
             promiseWriteInStream({
                 maybePromise: this.#getBackupRepositoriesSizeInfo(),
                 path: 'backupRepositories',