Size limit on BufferedReader exceeded?

In a java 6 webapp, I am attempting to retrieve a large amount of output from an executed command. I've "borrowed/stolen/based" it on the javaworld article. The problem I am facing is that the length appears to exceed a size limit since the output is lopped off. I've output the data to a file so I can see the size of what is returned, and that is exactly 32K (32768). I've experimented with changing the default size of the buffer (see BufferedReader constructor), but I have not observed any change to the length of the data returned no matter what value I have for the buffered-size (very small to very large).

Any advice would be very much appreciated!

public class StreamGobbler extends Thread {

private InputStream is;
private String type;
private List<String> output;

public StreamGobbler(InputStream is, String type) {
    this.is = is;
    this.type = type;
}

@Override
public void run() {
    try {
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        String line = null;
        this.output = new ArrayList<String>();
        while ((line = br.readLine()) != null) {
            this.getOutput().add(line + "\n");
            System.out.println(type + ">" + line);
        }
        br.close();
    } catch (IOException ioe) {
        System.err.println("ERROR: " + ioe.getMessage());
    }
}

/**
 * @return the output
 */
public List<String> getOutput() {
    return output;
}

}

public class JobClassAds {

private String CONDOR_HISTORY = "condor_history";
private String CONDOR_HISTORY_XML = CONDOR_HISTORY + " -xml";
private String CONDOR_HISTORY_LONG = CONDOR_HISTORY + " -long";

public String getHistory() {
    try {
        Runtime runtime = Runtime.getRuntime();
        String exec = CONDOR_HISTORY_LONG;
        Process process = runtime.exec(exec);
        System.out.println("Running " + exec + " ...");

        // Error message
        StreamGobbler errGobbler = new StreamGobbler(process.getErrorStream(), "ERROR");

        // Output
        StreamGobbler outGobbler = new StreamGobbler(process.getInputStream(), "OUTPUT");

        Thread outThread = new Thread(outGobbler);
        Thread errThread = new Thread(errGobbler);

        outThread.start();
        errThread.start();

        outThread.join();
        errThread.join();

        /*
        String line = null;

        wh开发者_如何学JAVAile ((line = input.readLine()) != null) {
            System.out.println(line);
            content.append(line);
        }

         *
         */

        int exitVal = process.waitFor();

        List<String> output = outGobbler.getOutput();
        String inputString = "";
        for (String o : output) {
            inputString += o;
        }

        System.out.println(exec + " Exited with error code " + exitVal);

        BufferedWriter out = new BufferedWriter(new FileWriter("/tmp/history_result.xml"));
        out.write(inputString);
        out.close();
        return inputString;

    } catch (Exception e) {
        System.err.println(e.getMessage());
        return null;
    }
}

The problem is not with the BufferedReader's buffer size.

I think that the real cause is something that the external command is doing. I suspect that it is bailing out without flushing its stdout stream. Note that you are "gobbling" but not outputting the command's stderr stream. That's where you may find the evidence pointing to the real cause of the problem.

By the way, you are using the StreamGobbler class in a suboptimal fashion. It extends Thread so the intended way to use is:

    SteamGobbler sg = new StreamGobbler(...);
    sg.start();
    sg.join();

but you are effectively doing this:

    SteamGobbler sg = new StreamGobbler(...);
    Thread th = new Thread(sg);
    th.start();
    th.join();

It works ... but only because a Thread is-a Runnable.