Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.commons.exec;
import org.apache.commons.exec.util.DebugUtils;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Copies standard output and error of subprocesses to standard output and error
* of the parent process. If output or error stream are set to null, any feedback
* from that stream will be lost.
*/
public class PumpStreamHandler implements ExecuteStreamHandler {
private Thread outputThread;
private Thread errorThread;
private Thread inputThread;
private final OutputStream out;
private final OutputStream err;
private final InputStream input;
private InputStreamPumper inputStreamPumper;
/**
* Construct a new PumpStreamHandler.
*
* @param out
* the output OutputStream.
* @param err
* the error OutputStream.
* @param input
* the input InputStream.
*/
public PumpStreamHandler(final OutputStream out, final OutputStream err,
final InputStream input) {
this.out = out;
this.err = err;
this.input = input;
}
/**
* Construct a new PumpStreamHandler.
*
* @param out
* the output OutputStream.
* @param err
* the error OutputStream.
*/
public PumpStreamHandler(final OutputStream out, final OutputStream err) {
this(out, err, null);
}
/**
* Construct a new PumpStreamHandler.
*
* @param outAndErr
* the output/error OutputStream.
*/
public PumpStreamHandler(final OutputStream outAndErr) {
this(outAndErr, outAndErr);
}
/**
* Construct a new PumpStreamHandler.
*/
public PumpStreamHandler() {
this(System.out, System.err);
}
/**
* Set the InputStream from which to read the standard output
* of the process.
*
* @param is
* the InputStream.
*/
public void setProcessOutputStream(final InputStream is) {
if (out != null) {
createProcessOutputPump(is, out);
}
}
/**
* Set the InputStream from which to read the standard error
* of the process.
*
* @param is
* the InputStream.
*/
public void setProcessErrorStream(final InputStream is) {
if (err != null) {
createProcessErrorPump(is, err);
}
}
/**
* Set the OutputStream by means of which input can be sent
* to the process.
*
* @param os
* the OutputStream.
*/
public void setProcessInputStream(final OutputStream os) {
if (input != null) {
if (input == System.in) {
inputThread = createSystemInPump(input, os);
} else {
inputThread = createPump(input, os, true);
} } else {
try {
os.close();
} catch (IOException e) {
String msg = "Got exception while closing output stream";
DebugUtils.handleException(msg ,e);
}
}
}
/**
* Start the Threads.
*/
public void start() {
if (outputThread != null) {
outputThread.start();
}
if (errorThread != null) {
errorThread.start();
}
if (inputThread != null) {
inputThread.start();
}
}
/**
* Stop pumping the streams.
*/
public void stop() {
if (outputThread != null) {
try {
outputThread.join();
outputThread = null;
} catch (InterruptedException e) {
// ignore
}
}
if (errorThread != null) {
try {
errorThread.join();
errorThread = null;
} catch (InterruptedException e) {
// ignore
}
}
if (inputStreamPumper != null) {
inputStreamPumper.stopProcessing();
}
if (inputThread != null) {
try {
inputThread.join();
inputThread = null;
} catch (InterruptedException e) {
// ignore
}
}
if (err != null && err != out) {
try {
err.flush();
} catch (IOException e) {
String msg = "Got exception while flushing the error stream";
DebugUtils.handleException(msg ,e);
}
}
if (out != null) {
try {
out.flush();
} catch (IOException e) {
String msg = "Got exception while flushing the output stream";
DebugUtils.handleException(msg ,e);
}
}
}
/**
* Get the error stream.
*
* @return OutputStream.
*/
protected OutputStream getErr() {
return err;
}
/**
* Get the output stream.
*
* @return OutputStream.
*/
protected OutputStream getOut() {
return out;
}
/**
* Create the pump to handle process output.
*
* @param is
* the InputStream.
* @param os
* the OutputStream.
*/
protected void createProcessOutputPump(final InputStream is,
final OutputStream os) {
outputThread = createPump(is, os);
}
/**
* Create the pump to handle error output.
*
* @param is
* the InputStream.
* @param os
* the OutputStream.
*/
protected void createProcessErrorPump(final InputStream is,
final OutputStream os) {
errorThread = createPump(is, os);
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream.
*
* @param is the input stream to copy from
* @param os the output stream to copy into
* @return the stream pumper thread
*/
protected Thread createPump(final InputStream is, final OutputStream os) {
return createPump(is, os, false);
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream.
*
* @param is the input stream to copy from
* @param os the output stream to copy into
* @param closeWhenExhausted close the output stream when the input stream is exhausted
* @return the stream pumper thread
*/
protected Thread createPump(final InputStream is, final OutputStream os,
final boolean closeWhenExhausted) {
final Thread result = new Thread(new StreamPumper(is, os,
closeWhenExhausted));
result.setDaemon(true);
return result;
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream.
*
* @param is the System.in input stream to copy from
* @param os the output stream to copy into
* @return the stream pumper thread
*/
private Thread createSystemInPump(InputStream is, OutputStream os) {
inputStreamPumper = new InputStreamPumper(is, os);
final Thread result = new Thread(inputStreamPumper);
result.setDaemon(true);
return result;
}
}
