ExecMoveTask.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.commandexec.utils.LocalExecResult;
import org.waarp.common.command.exception.CommandAbstractException;
import org.waarp.common.logging.WaarpLogger;
import org.waarp.common.logging.WaarpLoggerFactory;
import org.waarp.common.utility.ParametersChecker;
import org.waarp.openr66.context.ErrorCode;
import org.waarp.openr66.context.R66Result;
import org.waarp.openr66.context.R66Session;
import org.waarp.openr66.context.task.localexec.LocalExecClient;
import org.waarp.openr66.protocol.configuration.Configuration;
import java.io.File;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
/**
* Execute an external command and Rename the file (using the new name from the
* result).<br>
* <p>
* The move of the file (if any) should be done by the external command
* itself.<br>
* <br>
* <p>
* waitForValidation (#NOWAIT#) must not be set since it will prevent to have
* the MOVE TASK to occur normally.
* So even if set, the #NOWAIT# will be ignored.
*/
public class ExecMoveTask extends AbstractExecTask {
/**
* Internal Logger
*/
private static final WaarpLogger logger =
WaarpLoggerFactory.getLogger(ExecMoveTask.class);
/**
* @param argRule
* @param delay
* @param argTransfer
* @param session
*/
public ExecMoveTask(final String argRule, final int delay,
final String argTransfer, final R66Session session) {
super(TaskType.EXECMOVE, 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. The last line of stdout will be the new name given to the R66File in
* case of status 0. The previous file should be deleted by the script or will be deleted in case of status 0.
* If the status is 1, no change is made to the file.
*/
logger.info("ExecMove with {}:{} and {}", argRule, argTransfer, session);
final String finalname = applyTransferSubstitutions(argRule);
// Force the WaitForValidation
waitForValidation = true;
if (Configuration.configuration.isUseLocalExec() && useLocalExec) {
final LocalExecClient localExecClient = new LocalExecClient();
if (localExecClient.connect()) {
localExecClient.runOneCommand(finalname, delay, waitForValidation,
futureCompletion);
final LocalExecResult result = localExecClient.getLocalExecResult();
move(result.getStatus(), result.getResult(), finalname);
localExecClient.disconnect();
return;
} // else continue
}
final PrepareCommandExec prepareCommandExec =
new PrepareCommandExec(this, finalname, false,
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();
final LastLineReader lastLineReader = new LastLineReader(inputStream);
lastLineReader.setName(
"LastLineReader" + session.getRunner().getSpecialId());
lastLineReader.setDaemon(true);
Configuration.configuration.getExecutorService().execute(lastLineReader);
final ExecuteCommand executeCommand =
new ExecuteCommand(this, commandLine, defaultExecutor, inputStream,
outputStream, pumpStreamHandler,
lastLineReader).invoke();
if (executeCommand.isError()) {
return;
}
int status = executeCommand.getStatus();
final String newname;
if (defaultExecutor.isFailure(status) && watchdog != null &&
watchdog.killedProcess()) {
// kill by the watchdoc (time out)
status = -1;
newname = "TimeOut";
} else {
newname = lastLineReader.getLastLine();
if (status == 0 && ParametersChecker.isEmpty(newname)) {
status = 1;
}
}
move(status, newname, commandLine.toString());
}
private void move(final int status, final String newName,
final String commandLine) {
if (newName == null) {
logger.error("Status: " + status + " Exec in error with " + commandLine +
" returns no line");
futureCompletion.cancel();
return;
}
final String newname = newName.replace('\\', '/');
if (status == 0) {
if (newname.indexOf(' ') > 0) {
logger.warn("Exec returns a multiple string in final line: " + newname);
// XXX FIXME: should not split String[] args = newname.split(" ")
// newname = args[args.length - 1]
}
// now test if the previous file was deleted (should be)
final File file = new File(newname);
if (!file.exists()) {
logger.warn(
"New file does not exist at the end of the exec: " + newname);
}
// now replace the file with the new one
try {
session.getFile().replaceFilename(newname, true);
} catch (final CommandAbstractException e) {
logger.warn("Exec in warning with " + commandLine + " : {}",
e.getMessage());
}
session.getRunner().setFileMoved(newname, true);
final R66Result result =
new R66Result(session, true, ErrorCode.CompleteOk,
session.getRunner());
result.setOther(newname);
futureCompletion.setResult(result);
futureCompletion.setSuccess();
logger.info("Exec OK with {} returns {}", commandLine, newname);
} else if (status == 1) {
logger.warn(
"Exec in warning with " + commandLine + " returns " + newname);
session.getRunner().setErrorExecutionStatus(ErrorCode.Warning);
final R66Result result =
new R66Result(session, true, ErrorCode.Warning, session.getRunner());
result.setOther(newname);
futureCompletion.setResult(result);
futureCompletion.setSuccess();
} else {
logger.error("Status: " + status + " Exec in error with " + commandLine +
" returns " + newname);
futureCompletion.cancel();
}
}
}