Name: boT120536 Date: 05/13/2001


java version "1.3.0_02"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0_02)
Java HotSpot(TM) Client VM (build 1.3.0_02, mixed mode)



The following program illustrates that on linux, a different thread than the
one that creates a Process cannot read from that process's stdin. Probably
other file descriptors too, I haven't tried. On linux the second read returns
EOF, where on windows the second read returns 'b'.

import java.io.*;

public class Test {

    static Reader in;
    static Writer out;

    public static void main( String[] args ) throws Exception {

        Runtime rt = Runtime.getRuntime();
        Process p = rt.exec( System.getProperty("os.name").equals("Linux") ? "./ctest" : "ctest.exe" );
        in = new InputStreamReader( p.getInputStream() );
        out = new OutputStreamWriter( p.getOutputStream() );

        out.write( 'a' );
        out.flush();
        System.out.println( "wrote a" );
        System.out.println( "read " + getc() );

        Thread t = new MyThread();
        t.start();

    }

    static String getc() throws IOException {
        int c = in.read();
        if( c == -1 )
            return "EOF";
        return new String( new char[] { (char) c } );
    }

    static class MyThread extends Thread {
        public void run() {
            try {
                out.write( 'b' );
                out.flush();
                System.out.println( "wrote b" );
                /************************************************************
                 * This read should return 'b', but on linux returns EOF.
                 *************************************************************/
                System.out.println( "read " + getc() );
            } catch( IOException e ) {
                System.out.println( "IOException in thread: " + e );
            }
        }
    }

}

/*
 * Corresponding c program "ctest", just echos whatever it gets:

#include <stdio.h>

main() {
    int c;
    for(;;) {
        c = getchar();
        putchar( c );
        fflush( stdout );
    }
}

 */
(Review ID: 123262)
======================================================================

Name: boT120536 Date: 05/13/2001


java version "1.3.0_02"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0_02)
Java HotSpot(TM) Client VM (build 1.3.0_02, mixed mode)

Sometimes, output of a subprocess (java.lang.Runtime.exec) is lost. This race
condition seems to occur only if the subprocess begins to produce its output
very fast, before there is a read pending.

This bug is probably related to bug # 4422496. That bug description mentions
only quickly exiting programs. I experience the problem also if the subprocess
produces some output very fast after some input.

It is quite difficult to reproduce this intermittent bug with a trivial
example. The code below is therefore rather long. It is supposed to generate,
among its verbose output, either 'FINAL CHECK: OK' or 'ERROR'.

Note that changing the command to sleep 1 second instead of 0 seconds makes the
test succeed (at least, most of the time). Also, removing the 'RunPro' wrapper
thread from the performInteraction() method makes it succeed.

I tested on this machine:
uname: Linux 2.4.3 #1 SMP i686 unknown
hardware: AMD Athlon 900, 512 MB RAM.

*** FILE PipingBugSimpleDemo.java ***
import java.util.*;
import java.io.*;

public class PipingBugSimpleDemo {
    
    private Process process;
    private BufferedWriter processInput;
    private BufferedReader processOutput;
    private BufferedReader processErrors;
    
    private static final String TOKEN_END = "#$#END";
    
    public static void main(String[] args) {
        PipingBugSimpleDemo demo = new PipingBugSimpleDemo();
        
        String command = "sleep 0\necho -e SomeEcho\\\\n2ndEcho\\\\n#\\$#END";
        
        int check = 2;
        for (int i = 0; (i<( 1000 )) && (check == 2); i++) {
            check = 0;
            IncrementalInteraction interaction = new IncrementalInteraction(command);
            Runnable r = new RunPro(demo, interaction);
            Thread t = new Thread(r,"RunPro");
            t.start();
            Iterator iter = interaction.iterator();
            while (iter.hasNext()) {
                System.out.println(" ITERation " + i + " said: " + (String)iter.next());
                check++;
            }
            System.out.println(" ITERation " + i + " check: " + (check==2));
        }
        if (check == 2) {
            System.out.println(" FINAL CHECK: OK" );
        } else {
            System.out.println(" ERROR: number of lines " +
check);
        }
        demo.halt();
    }
    
    /** Creates new PipingBugDemo */
    public PipingBugSimpleDemo() {
        try {
            process = Runtime.getRuntime().exec("/bin/bash");
            
            processInput = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
            processOutput = new BufferedReader(new InputStreamReader(process.getInputStream()));
            processErrors = new BufferedReader(new InputStreamReader(process.getErrorStream()));
            
            Thread pet = new Thread(new ProcessErrorsRunnable(), "Errors");
            pet.start();
        } catch (SecurityException se) {
            System.out.println("Could not start a new Prolog engine due to security limitations.");
            se.printStackTrace();
        } catch (IOException ioe) {
            System.out.println("Could not start a new Prolog engine due to an I/O problem.");
            ioe.printStackTrace();
        }
    }
    
    public synchronized void performInteraction(Interaction pInteraction) {
        System.out.println("Starting commands thread.");
        
        Thread commands = new Thread(new OutputRunnable(pInteraction), "Commands");
        commands.start();
        
        try {
            String s;
            while (((s = processOutput.readLine()) != null) && (!s.equals(TOKEN_END)) ) {
                pInteraction.readLineFromProcess(s);
            }
            // We are done, notify the interaction.
            pInteraction.readLineFromProcess(null);
            if (s == null) {
                System.out.println(" Process returned null string.");
            } else if (s.equals(TOKEN_END)) {
                System.out.println(" Job success.");
            }
        } catch (IOException ioe) {
            System.out.println(" I/O Error during process interaction: " + ioe.getMessage());
            ioe.printStackTrace();
        }
    }
    
    public synchronized void halt() {
        try {
            processInput.close();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
    
    private class ProcessErrorsRunnable implements Runnable {
        public ProcessErrorsRunnable() {
        }
        public void run() {
            String s;
            try {
                while ((s = processErrors.readLine()) != null) {
                    System.err.println(" PROCESS MESSAGE: " + s);
                }
                System.err.println(" NO MORE PROCESS MESSAGES.");
            } catch (IOException ioe) {
                System.out.println(" IO ERROR WHILE GETTING MESSAGES");
                ioe.printStackTrace();
            }
        }
    }
    
    private class OutputRunnable implements Runnable {
        Interaction pInteraction;
        public OutputRunnable(Interaction pInteraction) {
            this.pInteraction = pInteraction;
        }
        public void run() {
            String s;
            try {
                
                while ((s = pInteraction.writeLineToProcess()) != null) {
                    processInput.write(s);
                    processInput.newLine();
                    processInput.flush();
                }
                System.out.println(" NO MORE COMMANDS");
            } catch (IOException ioe) {
                System.out.println(" IO ERROR WHILE PIPING COMMAND OR DATA: " + ioe.getMessage());
                ioe.printStackTrace();
            }
        }
    }
    
    protected static class RunPro implements Runnable {
        private PipingBugSimpleDemo pMachine;
        private Interaction pi;
        public RunPro(PipingBugSimpleDemo pMachine, Interaction pi) {
            this.pMachine = pMachine;
            this.pi = pi;
        }
        public void run() {
            pMachine.performInteraction(pi);
        }
    }
    
}
*** FILE Interaction.java ***
public interface Interaction {
        /**
         * Produces the commands/data for the Process.
         * returns null iff no more commands/data are needed for the job.
         */
    public String writeLineToProcess();
        /**
         * Process a line that was written by the Process.
         * This is called once with a null line when the Process has done its work.
         */
    public void readLineFromProcess(String line);
}

*** FILE IncrementalInteraction.java ***
import java.util.*;
import java.io.*;

/**
 * An adapter for the Interaction interface.
 */
public class IncrementalInteraction implements Interaction {
    private String[] commands;
    private int nextCommand = 0;
    private char[] cBuf = new char[60];
    private boolean done = false;
    private PipedWriter pipedWriter;
    private PipedReader pipedReader;
    private int totalWritten = 0;
    public IncrementalInteraction(String command) {
        this.commands = new String[1];
        this.commands[0] = command;
        initPipes();
    }
    public IncrementalInteraction(String[] commands) {
        this.commands = commands;
        initPipes();
    }
    public IncrementalInteraction(Vector commands) {
        this.commands = new String[commands.size()];
        commands.copyInto(this.commands);
        initPipes();
    }
    
    private void initPipes() {
        try {
            pipedWriter = new PipedWriter();
            pipedReader = new PipedReader(pipedWriter);
        } catch(IOException ioe) {
            System.out.println("ERROR while initializing pipes.
****************");
        }
    }
    public void readLineFromProcess(String line) {
        if (line == null) {
            done = true;
            try {
                System.out.println("Closing write side of pipe. Written: " +
totalWritten + " ****************");
                pipedWriter.flush();
                pipedWriter.close();
            } catch (IOException ioe) {
                System.out.println("ERROR while closing write side of pipe.
****************");
            }
        } else {
            totalWritten += line.length();
            if (line.length() + 1 > cBuf.length) {
                cBuf = new char[line.length() + 1];
            }
            line.getChars(0, line.length(), cBuf, 0);
            cBuf[line.length()] = '\n';
            try {
                pipedWriter.write(cBuf, 0, line.length() + 1);
            } catch (IOException ioe) {
                System.out.println("ERROR while writing to pipe.
****************");
            }
        }
    }
    public String writeLineToProcess() {
        if (nextCommand < commands.length) {
            System.out.println(" IncrementalInteraction: COMMANDING: " +
commands[nextCommand]);
            return commands[nextCommand++];
        } else {
            return null;
        }
    }
    /**
     * @pre only to be called once per instance
     */
    public Iterator iterator() {
        return new ResultsIterator();
    }
    
    private class ResultsIterator implements Iterator {
        private BufferedReader bReader = new BufferedReader(pipedReader);
        private String bufferLine;
        private int totalRead = 0;
        public ResultsIterator() {
            tryReadLine();
        }
        private void tryReadLine() {
            try {
                bufferLine = bReader.readLine();
                if (bufferLine != null) {
                    totalRead += bufferLine.length();
                } else {
                    System.out.println("Done reading from pipe. Read: " +
totalRead);
                }
            } catch (IOException ioe) {
                System.out.println("Error during piping of interaction results:
" + ioe.getMessage());
                System.out.println("Read: " + totalRead);
                ioe.printStackTrace();
                bufferLine = null;
            }
        }
        public boolean hasNext() {
            return bufferLine != null;
        }
        public Object next() {
            String nextLine = bufferLine;
            if (bufferLine != null) {
                tryReadLine();
            }
            return nextLine;
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}
(Review ID: 124009)
======================================================================