@typexs/base/commands/TaskCommand.js

"use strict";
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 __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const commons_config_1 = require("commons-config");
const typedi_1 = require("typedi");
const Invoker_1 = require("../base/Invoker");
const Tasks_1 = require("../libs/tasks/Tasks");
const Console_1 = require("../libs/logging/Console");
const Tasks_api_1 = require("../api/Tasks.api");
const System_1 = require("../libs/system/System");
const TasksHelper_1 = require("../libs/tasks/TasksHelper");
const Log_1 = require("../libs/logging/Log");
/**
 * Starts a task direct or in a running worker
 * Command: typexs task test [--targetId abc] [--outputMode worker|local]
 *
 * outputMode is per default 'worker' if one exists  else startup local
 *
 */
class TaskCommand {
    constructor() {
        this.command = 'task';
        this.aliases = 't';
        this.describe = 'Start task';
    }
    beforeStartup() {
        System_1.System.enableDistribution(false);
    }
    builder(yargs) {
        return yargs;
    }
    handler(argv) {
        return __awaiter(this, void 0, void 0, function* () {
            const targetId = commons_config_1.Config.get('argv.targetId', null);
            let isLocal = true; // Config.get('argv.local', false);
            const isRemote = commons_config_1.Config.get('argv.remote', false);
            if (targetId === null && !isRemote) {
                isLocal = true;
                // wait moment for
            }
            else {
                isLocal = false;
            }
            // filter task names from request
            const taskNames = [];
            let start = false;
            let notask = false;
            for (let i = 0; i < process.argv.length; i++) {
                if (process.argv[i] === 'task') {
                    start = true;
                    continue;
                }
                if (!start) {
                    continue;
                }
                if (process.argv[i].match(/^\-\-/)) {
                    // parameter
                    notask = true;
                }
                else {
                    if (!notask) {
                        taskNames.push(process.argv[i]);
                    }
                }
            }
            yield this.init();
            if (taskNames.length > 0) {
                const args = commons_config_1.Config.get('argv');
                try {
                    const results = yield TasksHelper_1.TasksHelper.exec(taskNames, Object.assign({ isLocal: isLocal, remote: isRemote, targetId: targetId, skipTargetCheck: true }, args));
                    Console_1.Console.log(JSON.stringify(results, null, 2));
                }
                catch (e) {
                    Log_1.Log.error(e);
                }
            }
            else {
                const res = this.tasks.names();
                Console_1.Console.log('List of supported tasks:');
                Console_1.Console.log('\t- ' + res.join('\n\t') + '\n');
            }
            yield this.shutdown();
        });
    }
    init() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.invoker.use(Tasks_api_1.TasksApi).onInit();
        });
    }
    shutdown() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.invoker.use(Tasks_api_1.TasksApi).onShutdown();
        });
    }
}
__decorate([
    typedi_1.Inject(Tasks_1.Tasks.NAME),
    __metadata("design:type", Tasks_1.Tasks)
], TaskCommand.prototype, "tasks", void 0);
__decorate([
    typedi_1.Inject(Invoker_1.Invoker.NAME),
    __metadata("design:type", Invoker_1.Invoker)
], TaskCommand.prototype, "invoker", void 0);
__decorate([
    typedi_1.Inject(System_1.System.NAME),
    __metadata("design:type", System_1.System)
], TaskCommand.prototype, "system", void 0);
exports.TaskCommand = TaskCommand;

//# sourceMappingURL=TaskCommand.js.map