ExecTask.java

/*
 * This file is part of Waarp Project (named also Waarp or GG).
 *
 *  Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
 *  tags. See the COPYRIGHT.txt in the distribution for a full listing of
 * individual contributors.
 *
 *  All Waarp Project is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along with
 * Waarp . If not, see <http://www.gnu.org/licenses/>.
 */
package org.waarp.openr66.context.task;

import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.PumpStreamHandler;
import org.waarp.common.logging.WaarpLogger;
import org.waarp.common.logging.WaarpLoggerFactory;
import org.waarp.openr66.context.R66Session;
import org.waarp.openr66.context.task.localexec.LocalExecClient;
import org.waarp.openr66.protocol.configuration.Configuration;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/**
 * Execute an external command
 */
public class ExecTask extends AbstractExecTask {

  /**
   * Internal Logger
   */
  private static final WaarpLogger logger =
      WaarpLoggerFactory.getLogger(ExecTask.class);

  /**
   * @param argRule
   * @param delay
   * @param argTransfer
   * @param session
   */
  public ExecTask(final String argRule, final int delay,
                  final String argTransfer, final R66Session session) {
    super(TaskType.EXEC, delay, argRule, argTransfer, session);
  }

  @Override
  public final void run() {
    /*
     * First apply all replacements and format to argRule from context and argTransfer. Will call exec (from first
     * element of resulting string) with arguments as the following value from the replacements. Return 0 if OK,
     * else 1 for a warning else as an error. No change should be done in the FILENAME
     */
    logger.debug("Exec with " + argRule + ':' + argTransfer + " and {}",
                 session);
    final String finalname = applyTransferSubstitutions(argRule);

    // Check if the execution will be done through LocalExec daemon
    if (Configuration.configuration.isUseLocalExec() && useLocalExec) {
      final LocalExecClient localExecClient = new LocalExecClient();
      if (localExecClient.connect()) {
        localExecClient.runOneCommand(finalname, delay, waitForValidation,
                                      futureCompletion);
        localExecClient.disconnect();
        return;
      } // else continue
    }

    final PrepareCommandExec prepareCommandExec =
        new PrepareCommandExec(this, finalname, true,
                               waitForValidation).invoke();
    if (prepareCommandExec.isError()) {
      return;
    }
    final CommandLine commandLine = prepareCommandExec.getCommandLine();
    final DefaultExecutor defaultExecutor =
        prepareCommandExec.getDefaultExecutor();
    final PipedInputStream inputStream = prepareCommandExec.getInputStream();
    final PipedOutputStream outputStream = prepareCommandExec.getOutputStream();
    final PumpStreamHandler pumpStreamHandler =
        prepareCommandExec.getPumpStreamHandler();
    final ExecuteWatchdog watchdog = prepareCommandExec.getWatchdog();

    if (!waitForValidation) {
      // Do not wait for validation
      futureCompletion.setSuccess();
      logger.info("Exec will start but no WAIT with {}", commandLine);
    }

    final ExecuteCommand executeCommand =
        new ExecuteCommand(this, commandLine, defaultExecutor, inputStream,
                           outputStream, pumpStreamHandler, null).invoke();
    if (executeCommand.isError()) {
      return;
    }
    int status = executeCommand.getStatus();

    if (defaultExecutor.isFailure(status) && watchdog != null &&
        watchdog.killedProcess()) {
      // kill by the watchdoc (time out)
      logger.error("Exec is in Time Out");
      status = -1;
    }
    if (status == 0) {
      if (waitForValidation) {
        futureCompletion.setSuccess();
      }
      logger.info("Exec OK with {}", commandLine);
    } else if (status == 1) {
      logger.warn("Exec in warning with " + commandLine);
      if (waitForValidation) {
        futureCompletion.setSuccess();
      }
    } else {
      logger.error("Status: " + status + " Exec in error with " + commandLine);
      if (waitForValidation) {
        futureCompletion.cancel();
      }
    }
  }

  @Override
  final void finalizeFromError(final Runnable threadReader, final int status,
                               final CommandLine commandLine,
                               final Exception e) {
    logger.error("Status: " + status + " Exec in error with " + commandLine +
                 " returns " + e.getMessage());
    if (waitForValidation) {
      futureCompletion.setFailure(e);
    }
  }
}