Changeset 2887 for proto


Ignore:
Timestamp:
Feb 2, 2013, 11:34:57 PM (7 years ago)
Author:
ksherdy
Message:

Fixed timeout issue via additional timer thread.

Location:
proto/juncoTestHarness/src/commands
Files:
1 added
3 copied

Legend:

Unmodified
Added
Removed
  • proto/juncoTestHarness/src/commands/ASMEmuCommand.java

    r2883 r2887  
    1 package command;
     1package commands;
    22
    33import harness.TestSuiteDefinitions;
     
    66import java.util.concurrent.TimeoutException;
    77
     8
    89public class ASMEmuCommand extends Command {
    910       
    10         public int execute(String asmFilePath, long timeout) throws IOException, InterruptedException, TimeoutException {
     11        public ASMEmuCommand () {
     12                super();
     13        }
     14       
     15        public int execute(String asmFilePath, long timeout) throws IOException, TimeoutException {
    1116
    1217                String command = String.format("wine %s %s",
  • proto/juncoTestHarness/src/commands/Command.java

    r2884 r2887  
    1 package command;
     1package commands;
     2
    23
    34import java.io.BufferedReader;
     5import java.io.OutputStream;
     6import java.io.InputStream;
     7import java.io.InputStreamReader;
     8
     9
     10import java.util.concurrent.TimeoutException;
     11
    412import java.io.IOException;
    5 import java.io.InputStreamReader;
    6 import java.util.concurrent.TimeoutException;
     13import java.util.Timer;
     14import java.util.TimerTask;
    715
    816public class Command {
    9 
    10         private StringBuffer stdout;
    11         private StringBuffer stderr;
     17       
     18        private String stderr;
     19        private String stdout;
     20        //private String stdin;
    1221       
    1322        public Command() {
    14                 stdout = new StringBuffer();
    15                 stderr = new StringBuffer();
    16         }
    17        
    18         public int execute(final String commandLine, final long timeout) throws IOException, InterruptedException, TimeoutException {
    19 
    20                 stdout.delete(0, getStdout().length());
    21                 stderr.delete(0, getStderr().length());
    22                
    23                 Runtime runtime = Runtime.getRuntime();
    24                 Process process = runtime.exec(commandLine);
    25                
    26                
    27                 /* Set up process I/O. */
    28                
    29                 BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    30                 stdout.append(stdoutReader.readLine());
    31                
    32                 String stdoutLine;
    33         while ((stdoutLine = stdoutReader.readLine()) != null) {
    34             stdout.append(stdoutLine);
    35             stderr.append("\n");
     23                stderr = new String();
     24                stdout = new String();
     25        }
     26       
     27        public int execute(final String commandLine, final long timeout) throws IOException, TimeoutException {
     28
     29                int exit;
     30               
     31                // named in relation to the called thread, i.e. output stream of caller is the input stream of callee
     32                InputStream stderrStream        = null;
     33                InputStream stdoutStream        = null;
     34                OutputStream stdinStream        = null;
     35
     36                InputStreamGobbler stderrStreamGobbler = null;
     37                InputStreamGobbler stdoutStreamGobbler = null;
     38               
     39                Timer timer = null;
     40        Process process = null;
     41       
     42        try
     43        {
     44            timer = new Timer(true);
     45            InterruptTimerTask interrupter = new InterruptTimerTask(Thread.currentThread());
     46            timer.schedule(interrupter, timeout);
     47           
     48            Runtime runtime = Runtime.getRuntime();
     49            process = runtime.exec(commandLine);
     50       
     51                // buffer stderr
     52            stderrStream = process.getErrorStream();
     53            stderrStreamGobbler = new InputStreamGobbler(process, stderrStream);
     54            stderrStreamGobbler.start();
     55
     56            // buffer stdout
     57            stdoutStream = process.getInputStream();
     58            stdoutStreamGobbler = new InputStreamGobbler(process, stdoutStream);
     59            stdoutStreamGobbler.start();
     60           
     61            exit = process.waitFor();
     62           
     63                stdout = stdoutStreamGobbler.getBufferAsString();
     64                stderr = stderrStreamGobbler.getBufferAsString();
     65               
     66//              stdoutStreamGobbler.interrupt();
     67//              stderrStreamGobbler.interrupt();
     68           
     69        } catch(InterruptedException e) {
     70            // do something to handle the timeout here
     71               
     72                process.destroy();
     73               
     74                System.out.println("TIME OUT");
     75               
     76                throw new TimeoutException();
     77                           
     78        } finally {
     79               
     80                if(process != null) {
     81                        close(process.getErrorStream());
     82                        close(process.getInputStream());
     83                        close(process.getOutputStream());
     84                       
     85                        process.destroy();
     86                }
     87
     88                close(stderrStream);
     89                close(stdoutStream);
     90                close(stdinStream);
     91               
     92                System.out.println("FINALLY");
     93               
     94            timer.cancel();             // Process returns within the timeout period, stop the interrupter
     95                               
     96            Thread.interrupted();   // Clear the interrupt flag on the current thread.
     97           
     98            // ?                    // Oh, and there's also Sun bug 6420270 to worry about here.
    3699        }
    37                 stdoutReader.close();
    38                
    39                
    40                 /* Set up process I/O. */               
    41                 BufferedReader stderrReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    42                
    43                 String stderrLine;
    44                 while ((stderrLine = stderrReader.readLine()) != null) {
    45             stderr.append(stderrLine);
    46             stderr.append("\n");
    47         }
    48        
    49                 stderrReader.close();
    50                
    51                 Worker worker = new Worker(process);
    52                 worker.start();
    53                
    54                 try {
    55                         worker.join(timeout);
    56                         if (worker.exit != null) {
    57                                 return worker.exit;
    58                         } else {
    59                                 throw new TimeoutException();
    60                         }
    61                 } catch(InterruptedException exception) {
    62                         worker.interrupt();
    63                         Thread.currentThread().interrupt();
    64                         throw exception;
    65                 } finally {
    66                         process.destroy();
    67                 }
    68         }
    69 
     100               
     101               
     102                return exit;
     103        }
     104
     105
     106        class InterruptTimerTask extends TimerTask {
     107                private Thread thread;
     108               
     109                public InterruptTimerTask(Thread t) {
     110                    this.thread = t;
     111                }
     112               
     113                public void run() {
     114                    thread.interrupt();
     115                }
     116        }
     117       
     118        class InputStreamGobbler extends Thread {
     119
     120                private StringBuffer buffer;
     121                private InputStream inputStream;
     122               
     123                public InputStreamGobbler(Process process, InputStream inputStream ) {
     124                        this.buffer = new StringBuffer();
     125                        this.inputStream = inputStream;
     126                }
     127               
     128                public void run() {
     129                        try {
     130                               
     131                                BufferedReader stdinReader = new BufferedReader(new InputStreamReader(inputStream));
     132                               
     133                                String line;
     134                                while ((line = stdinReader.readLine()) != null) {
     135                                        buffer.append(line);
     136                                    buffer.append("\n");
     137                                }
     138                                                               
     139                        } catch (Exception anExc) {
     140                    anExc.printStackTrace();
     141                    }
     142                }
     143
     144                public String getBufferAsString() {
     145                        return buffer.toString();
     146                }
     147       
     148        }
     149               
     150        private static void close(InputStream inputStream) {
     151            try {
     152                if (inputStream != null) {
     153                    inputStream.close();
     154                }
     155            } catch (IOException anExc) {
     156                anExc.printStackTrace();
     157            }
     158        }
     159
     160        private static void close(OutputStream outputStream) {
     161            try {
     162                if (outputStream != null) {
     163                    outputStream.close();
     164                }
     165            } catch (IOException anExc) {
     166                anExc.printStackTrace();
     167            }
     168        }       
     169               
     170        public String getStdout() {
     171                return stdout.toString();
     172        }
     173
     174    public String getStderr() {
     175                return stderr.toString();
     176        }
     177}
     178
     179/*             
     180
     181InputStream in = null;
     182OutputStream out = null;
     183OutputStream err = null;
     184
     185Worker worker = new Worker(commandLine);
     186worker.start();
     187
     188try {
     189        worker.join(timeout);
     190        if (worker.exit != null) {
     191                System.out.println("Worker exited.");
     192               
     193               
     194                return worker.exit;
     195        } else {
     196                System.out.println("Worker time out.");
     197               
     198               
     199                throw new TimeoutException();
     200        }
     201} catch(InterruptedException exception) {
     202        worker.interrupt();
     203        Thread.currentThread().interrupt();
     204        throw exception;
     205} finally {
     206
     207        System.out.println("Finally");
     208       
     209        if(process != null) {
     210                close(process.getErrorStream());
     211                close(process.getInputStream());
     212                close(process.getOutputStream());
     213               
     214                process.destroy();
     215        }
     216
     217        close(err);
     218        close(in);
     219        close(out);
     220
     221}
     222*/
     223
     224/*     
    70225        private static class Worker extends Thread {
    71226                private final Process process;
    72227                private Integer exit;
    73228               
    74                 private Worker(Process process) {
    75                         this.process = process;
    76                 }
     229                private StringBuffer stdout;
     230                private StringBuffer stderr;
     231
     232                private String commandLine;
     233               
     234                public Worker(String commandLine) {
     235                        stdout = new StringBuffer();
     236                        stderr = new StringBuffer();
     237//                      this.process = process;
     238                        this.commandLine = commandLine;
     239                }               
    77240               
    78241                public void run() {
    79242                        try {
     243
     244                                Runtime runtime = Runtime.getRuntime();
     245                                final Process process = runtime.exec(commandLine, null);
     246
     247                               
     248                                // Set up process I/O for stderr.
     249                                new Thread () {
     250                                        public void run() {
     251                                               
     252                                                try {
     253                                                        InputStream err = process.getErrorStream();
     254                                                        BufferedReader stderrReader = new BufferedReader(new InputStreamReader(err));
     255                                                       
     256                                                        String stderrLine;
     257                                                        while ((stderrLine = stderrReader.readLine()) != null) {
     258                                                            stderr.append(stderrLine);
     259                                                            stderr.append("\n");
     260                                                        }
     261                                                       
     262                                                } catch (Exception anExc) {
     263                                            anExc.printStackTrace();
     264                                                } 
     265                                        }
     266                                }.run();
     267                               
     268                                // Set up process I/O for stdio.           
     269                                new Thread () {
     270                               
     271                                        public void run() {
     272                                       
     273                                                try {
     274                                                       
     275                                                        InputStream in = process.getInputStream();
     276                                                        BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(in));
     277                                                       
     278                                                        String stdoutLine;
     279                                                        while ((stdoutLine = stdoutReader.readLine()) != null) {
     280                                                            stderr.append(stdoutLine);
     281                                                            stderr.append("\n");
     282                                                        }
     283                                                                                       
     284                                                } catch (Exception anExc) {
     285                                            anExc.printStackTrace();
     286                                            }
     287                                        }
     288                                }.run();
     289                               
    80290                                exit = process.waitFor();
    81291                        } catch (InterruptedException ignore) {
    82292                                return;
     293                        } catch (IOException e) {
     294                                // TODO Auto-generated catch block
     295                                e.printStackTrace();
    83296                        }
    84297                } 
    85298        }
    86        
    87         public String getStdout() {
    88                 return stdout.toString();
    89         }
    90 
    91     public String getStderr() {
    92                 return stderr.toString();
    93         }
    94299}
     300*/
     301
     302/*
     303 * Canonical stream gobbler.
     304 */
     305/*
     306class StreamGobbler extends Thread
     307{
     308    InputStream is;
     309    String type;
     310   
     311    StreamGobbler(InputStream is, String type)
     312    {
     313        this.is = is;
     314        this.type = type;
     315    }
     316   
     317    public void run()
     318    {
     319        try
     320        {
     321            InputStreamReader isr = new InputStreamReader(is);
     322            BufferedReader br = new BufferedReader(isr);
     323            String line=null;
     324            while ( (line = br.readLine()) != null)
     325                System.out.println(type + ">" + line);   
     326        } catch (IOException ioe) {
     327            ioe.printStackTrace(); 
     328        }
     329    }
     330}       
     331*/
  • proto/juncoTestHarness/src/commands/CompilerCommand.java

    r2883 r2887  
    1 package command;
     1package commands;
    22
    33import java.io.IOException;
     
    77public class CompilerCommand extends Command {
    88       
     9        public CompilerCommand () {
     10                super();
     11        }
     12       
    913        public int execute(String classPath,
    1014                        String fQName,
    1115                        String testFilePath,
    1216                        String targetDirPath,
    13                         long timeout) throws IOException, InterruptedException, TimeoutException {
     17                        long timeout) throws IOException, TimeoutException {
    1418
    1519                String command = String.format("java -ea -cp %s %s %s %s",
Note: See TracChangeset for help on using the changeset viewer.