Examples with DefaultBatchedCommand org.jboss.as.cli.batch.impl.DefaultBatchedCommand used on opensource projects

Example 1 with DefaultBatchedCommand

use of org.jboss.as.cli.batch.impl.DefaultBatchedCommand in project wildfly-core by wildfly.

the class CommandContextImpl method handleCommand.

private void handleCommand(ParsedCommandLine parsed) throws CommandFormatException, CommandLineException {
    String line = parsed.getOriginalLine();
    try {
        List<CLIExecution> executions = aeshCommands.newExecutions(parsed);
        for (CLIExecution exec : executions) {
            CLICommandInvocation invContext = exec.getInvocation();
            this.invocationContext = invContext;
            String opLine = exec.getLine();
            // implies a split of the main command)
            if (opLine != null && !opLine.equals(line)) {
                resetArgs(opLine);
            }
            Throwable originalException = null;
            try {
                // Could be an operation.
                if (exec.isOperation()) {
                    handleOperation(parsedCmd);
                    continue;
                }
                // Could be a legacy command.
                CommandHandler handler = exec.getLegacyHandler();
                if (handler != null) {
                    handleLegacyCommand(exec.getLine(), handler, false);
                    continue;
                }
            } catch (Throwable ex) {
                if (ex instanceof InterruptedException) {
                    Thread.currentThread().interrupt();
                }
                originalException = ex;
            } finally {
                // OK to be null
                Throwable suppressed = originalException;
                // when calling exec.execute something that we are not doing here.
                if (invContext.getConfiguration().getOutputRedirection() != null) {
                    try {
                        invContext.getConfiguration().getOutputRedirection().close();
                    } catch (IOException ex) {
                        // Message must contain the Exception and the localized message.
                        if (ex instanceof AccessDeniedException) {
                            String message = ex.getMessage();
                            suppressed = new CommandLineException((message != null ? message : line) + " (Access denied)");
                        } else {
                            suppressed = new CommandLineException(ex.toString());
                        }
                        if (originalException != null) {
                            originalException.addSuppressed(suppressed);
                            suppressed = originalException;
                        }
                    }
                }
                if (suppressed != null) {
                    if (suppressed instanceof RuntimeException) {
                        throw (RuntimeException) suppressed;
                    }
                    if (suppressed instanceof Error) {
                        throw (Error) suppressed;
                    }
                    if (suppressed instanceof CommandLineException) {
                        throw (CommandLineException) suppressed;
                    }
                    if (suppressed instanceof CommandLineParserException) {
                        throw (CommandLineParserException) suppressed;
                    }
                    if (suppressed instanceof OptionValidatorException) {
                        throw (OptionValidatorException) suppressed;
                    }
                }
            }
            // child command. This is caused by aesh 2.0 behavior.
            if (isBatchMode()) {
                exec.populateCommand();
            }
            BatchCompliantCommand bc = exec.getBatchCompliant();
            if (isBatchMode() && bc != null) {
                try {
                    Batch batch = getBatchManager().getActiveBatch();
                    BatchCompliantCommand.BatchResponseHandler request = bc.buildBatchResponseHandler(this, batch.getAttachments());
                    // Wrap into legacy API.
                    ResponseHandler rh = null;
                    if (request != null) {
                        rh = (ModelNode step, OperationResponse response) -> {
                            request.handleResponse(step, response);
                        };
                    }
                    BatchedCommand batchedCmd = new DefaultBatchedCommand(this, line, bc.buildRequest(this, batch.getAttachments()), rh);
                    batch.add(batchedCmd);
                } catch (CommandFormatException e) {
                    throw new CommandFormatException("Failed to add to batch '" + line + "'", e);
                }
            } else {
                execute(() -> {
                    executor.execute(aeshCommands.newExecutableBuilder(exec), timeout, TimeUnit.SECONDS);
                    return null;
                }, line);
            }
        }
    } catch (CommandNotFoundException ex) {
        // Commands that are not exposed in completion.
        if (parsedCmd.getFormat() != OperationFormat.INSTANCE) {
            CommandHandler h = cmdRegistry.getCommandHandler(ex.getCommandName().toLowerCase());
            if (h != null) {
                handleLegacyCommand(line, h, false);
                return;
            }
        }
        throw new CommandLineException("Unexpected command '" + line + "'. Type 'help --commands' for the list of supported commands.");
    } catch (IOException ex) {
        throw new CommandLineException(ex);
    } catch (CommandLineParserException | OptionValidatorException ex) {
        throw new CommandFormatException(ex);
    }
}

Example 2 with DefaultBatchedCommand

use of org.jboss.as.cli.batch.impl.DefaultBatchedCommand in project wildfly-core by wildfly.

the class CommandContextImpl method handleOperation.

private void handleOperation(ParsedCommandLine parsedLine) throws CommandFormatException, CommandLineException {
    if (isBatchMode()) {
        String line = parsedLine.getOriginalLine();
        Batch batch = getBatchManager().getActiveBatch();
        final ModelNode request = Util.toOperationRequest(this, parsedLine, batch.getAttachments());
        StringBuilder op = new StringBuilder();
        op.append(getNodePathFormatter().format(parsedLine.getAddress()));
        op.append(line.substring(line.indexOf(':')));
        DefaultBatchedCommand batchedCmd = new DefaultBatchedCommand(this, op.toString(), request, null);
        batch.add(batchedCmd);
    } else {
        Attachments attachments = new Attachments();
        final ModelNode op = Util.toOperationRequest(CommandContextImpl.this, parsedLine, attachments);
        RequestWithAttachments req = new RequestWithAttachments(op, attachments);
        set(Scope.REQUEST, "OP_REQ", req);
        operationHandler.handle(this);
    }
}

Example 3 with DefaultBatchedCommand

use of org.jboss.as.cli.batch.impl.DefaultBatchedCommand in project wildfly-core by wildfly.

the class CommandContextImpl method handleLegacyCommand.

private void handleLegacyCommand(String opLine, CommandHandler handler, boolean direct) throws CommandLineException {
    if (isBatchMode() && handler.isBatchMode(this)) {
        if (!(handler instanceof OperationCommand)) {
            throw new CommandLineException("The command is not allowed in a batch.");
        } else {
            try {
                Batch batch = getBatchManager().getActiveBatch();
                HandledRequest request = ((OperationCommand) handler).buildHandledRequest(this, batch.getAttachments());
                BatchedCommand batchedCmd = new DefaultBatchedCommand(this, opLine, request.getRequest(), request.getResponseHandler());
                batch.add(batchedCmd);
            } catch (CommandFormatException e) {
                throw new CommandFormatException("Failed to add to batch '" + opLine + "'", e);
            }
        }
    } else if (direct) {
        handler.handle(CommandContextImpl.this);
    } else {
        execute(() -> {
            executor.execute(handler, timeout, TimeUnit.SECONDS);
            return null;
        }, opLine);
    }
}