FCL/sftools/dev/build: comparison buildframework/helium/sf/java/core/src/com/nokia/helium/core/plexus/CommandBase.java

equal deleted inserted replaced

-:c7c26511138f
+:7c4a911dc066
 /*
 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
 package com.nokia.helium.core.plexus;
 import java.io.File;
 import java.util.Map;
 import java.util.Vector;
 import org.apache.log4j.Logger;
-import org.codehaus.plexus.util.Os;
+import org.apache.tools.ant.taskdefs.condition.Os;
 import org.codehaus.plexus.util.cli.CommandLineException;
 import org.codehaus.plexus.util.cli.CommandLineUtils;
 import org.codehaus.plexus.util.cli.Commandline;
 import org.codehaus.plexus.util.cli.StreamConsumer;
 /**
-* This abstract class implements some basic support to execute commands and
+* This abstract class implements some basic support to execute commands and redirect outputs to
-* redirect outputs to StreamConsumer. You can have common stream consumers or
+* StreamConsumer. You can have common stream consumers or execution base streamconsumers. The
-* execution base streamconsumers. The exception type raised
+* exception type raised can be controlled by the implementing class.
-* can be controlled by the implementing class.
+*
-*
 * @param <T>
 */
 public abstract class CommandBase<T extends Exception> {
 private final Logger log = Logger.getLogger(getClass());
 private Vector<StreamConsumer> outputHandlers = new Vector<StreamConsumer>();
 private Vector<StreamConsumer> errorHandlers = new Vector<StreamConsumer>();
 /**
 * Get the executable name.
+*
 * @return
 */
 protected abstract String getExecutable();
 /**
 * Throw an exception with message and cause.
+*
 * @param message
 * @param t
 * @throws T
 */
 protected abstract void throwException(String message, Throwable t) throws T;
 /**
 * Throw an exception with message only.
+*
 * @param message
 * @throws T
 */
 protected void throwException(String message) throws T {
 throwException(message, null);
 }
 /**
-* Location where to execute the command. The default location
+* Location where to execute the command. The default location is the current directory.
-* is the current directory.
+*
 * @return a File object pointing to a directory.
 */
 public File getWorkingDir() {
 return new File(".");
 }
 /**
-* Add a LineHandler to the CommandBase instance.
+* Add a LineHandler to the CommandBase instance. LineHandlers could be used to record/log the
-* LineHandlers could be used to record/log the output stream
+* output stream command invocation.
-* command invocation.
+*
 * @param lineHandler a lineHandle instance
 */
 public void addOutputLineHandler(StreamConsumer lineHandler) {
 if (lineHandler != null) {
 outputHandlers.add(lineHandler);
 }
 }
 /**
-* Add a LineHandler to the CommandBase instance.
+* Add a LineHandler to the CommandBase instance. LineHandlers could be used to record/log the
-* LineHandlers could be used to record/log the output error stream
+* output error stream command invocation.
-* command invocation.
+*
 * @param lineHandler a lineHandle instance
 */
 public void addErrorLineHandler(StreamConsumer lineHandler) {
 if (lineHandler != null) {
 errorHandlers.add(lineHandler);
 public void execute(String[] args) throws T {
 execute(args, null);
 }
 /**
-* Execute the command given by getExecutable with args as list of arguments and custom StreamConsumer.
+* Execute the command given by getExecutable with args as list of arguments and custom
-*
+* StreamConsumer.
-* @param args
+*
-*            an array representing blocks arguments
+* @param args an array representing blocks arguments
-* @param output
+* @param output the StreamConsumer to analyze the output with. If null it is ignored.
-*            the StreamConsumer to analyze the output with. If null it is
-*            ignored.
 * @throws T
 */
 public void execute(String[] args, StreamConsumer output) throws T {
 execute(args, null, output);
 }
 /**
-* Execute the command given by getExecutable with args as list of arguments and custom StreamConsumer.
+* Execute the command given by getExecutable with args as list of arguments and custom
-* Also env content will be added to the environment.
+* StreamConsumer. Also env content will be added to the environment.
 *
-* @param args
+* @param args an array representing blocks arguments
-*            an array representing blocks arguments
+* @param env additional key to add the environment
-* @param env
+* @param output the StreamConsumer to analyze the output with. If null it is ignored.
-*            additional key to add the environment
-* @param output
-*            the StreamConsumer to analyze the output with. If null it is
-*            ignored.
 * @throws T
 */
 public void executeCmdLine(String argLine, Map<String, String> env, StreamConsumer output)
 throws T {
 Commandline cmdLine = new Commandline();
 cmdLine.createArg().setValue(getExecutable());
 if (argLine != null) {
 cmdLine.createArg().setLine(argLine);
 }
 executeCmd(cmdLine, env, output);
 }
-private void executeCmd(Commandline cmdLine, Map<String, String> env, StreamConsumer output)     throws T  {
+private void executeCmd(Commandline cmdLine, Map<String, String> env, StreamConsumer output)
+throws T {
 if (env != null) {
 for (Map.Entry<String, String> entry : env.entrySet()) {
 cmdLine.addEnvironment(entry.getKey(), entry.getValue());
 }
 }
 cmdLine.setWorkingDirectory(getWorkingDir());
 // This is only needed on windows.
 if (Os.isFamily(Os.FAMILY_WINDOWS)) {
 cmdLine.createArg().setLine("&& exit %%ERRORLEVEL%%");
 }
 StreamMultiplexer inputMux = new StreamMultiplexer();
 if (output != null) {
 inputMux.addHandler(output);
 }
 for (StreamConsumer lh : errorHandlers) {
 errorMux.addHandler(lh);
 }
 try {
-int err = CommandLineUtils.executeCommandLine(cmdLine, inputMux,
+int err = CommandLineUtils.executeCommandLine(cmdLine, inputMux, errorMux);
-errorMux);
 // check its exit value
 log.debug("Execution of " + getExecutable() + " returned: " + err);
 if (err != 0) {
-throwException(errorRecorder.getBuffer() + " (return code: " + err
+throwException(errorRecorder.getBuffer() + " (return code: " + err + ")");
-+ ")");
 }
-} catch (CommandLineException e) {
+}
-throwException(
+catch (CommandLineException e) {
-"Error executing " + getExecutable() + ": "
+throwException("Error executing " + getExecutable() + ": " + e.toString());
-+ e.toString());
+}
 }
-}
+/**
-/**
+* Execute the command given by getExecutable with args as list of arguments and custom
-* Execute the command given by getExecutable with args as list of arguments and custom StreamConsumer.
+* StreamConsumer. Also env content will be added to the environment.
-* Also env content will be added to the environment.
+*
-*
+* @param args an array representing blocks arguments
-* @param args
+* @param env additional key to add the environment
-*            an array representing blocks arguments
+* @param output the StreamConsumer to analyze the output with. If null it is ignored.
-* @param env
+* @throws T
-*            additional key to add the environment
+*/
-* @param output
+public void execute(String[] args, Map<String, String> env, StreamConsumer output) throws T {
-*            the StreamConsumer to analyze the output with. If null it is
-*            ignored.
-* @throws T
-*/
-public void execute(String[] args, Map<String, String> env, StreamConsumer output)
-throws T {
 Commandline cmdLine = new Commandline();
 cmdLine.createArg().setValue(getExecutable());
 if (args != null) {
 cmdLine.addArguments(args);
 }
 executeCmd(cmdLine, env, output);
 }
 }

changeset 628	7c4a911dc066
parent 587	85df38eb4012