util/Exec.java

   1
   2 package org.de.metux.util;
   3
   4 import java.util.Properties;
   5 import java.io.BufferedReader;
   6 import java.io.IOException;
   7 import java.io.InterruptedIOException;
   8 import java.io.InputStreamReader;
   9 import java.io.File;
  10
  11 import java.lang.IllegalThreadStateException;
  12
  13 public class Exec
  14 {
  15     public interface IExecCallback
  16     {
  17         public void OutputLine(String text);
  18         public void ErrorLine(String text);
  19         public void debug(String text);
  20         public void error(String text);
  21     }
  22
  23     class default_cb implements IExecCallback
  24     {
  25         public void OutputLine(String line)
  26         {
  27             System.out.println(">> "+line);
  28         }
  29         public void ErrorLine(String line)
  30         {
  31             System.out.println("!> "+line);
  32         }
  33         public void debug(String text)
  34         {
  35         }
  36         public void error(String text)
  37         {
  38             System.err.println("EXEC ERROR: "+text);
  39         }
  40     }
  41
  42     class collect_buf implements IExecCallback
  43     {
  44         public String buffer = "";
  45         boolean add_lf = false;
  46
  47         public void OutputLine(String line)
  48         {
  49             buffer += line+(add_lf ? "\n" : "");
  50         }
  51         public void ErrorLine(String line)
  52         {
  53             System.out.println("!> "+line);
  54         }
  55         public void debug(String text)
  56         {
  57         }
  58         public void error(String text)
  59         {
  60             System.err.println("EXEC ERROR: "+text);
  61         }
  62     }
  63
  64     IExecCallback       callback;
  65     boolean             running;
  66     BufferedReader      stdout;
  67     BufferedReader      stderr;
  68     Process             process;
  69
  70     public int exit_code = 0;
  71
  72     class FetchStdoutThread extends Thread
  73     {
  74         public void run()
  75         {
  76             try
  77             {
  78                 String line;
  79                 while ((line=stdout.readLine())!=null)
  80                 callback.OutputLine(line);
  81             }
  82             catch (IOException e)
  83             {
  84                 System.err.println("EXEC (read-stdout) IO EXCEPTION: "+e);
  85             }
  86         }
  87     }
  88
  89     class FetchStderrThread extends Thread
  90     {
  91         public void run()
  92         {
  93             try
  94             {
  95                 String line;
  96                 while ((line=stderr.readLine())!=null)
  97                 callback.OutputLine(line);
  98             }
  99             catch (IOException e)
 100             {
 101                 System.err.println("EXEC (read-stderr) IO EXCEPTION: "+e);
 102             }
 103         }
 104     }
 105
 106     public Exec()
 107     {
 108         callback = new default_cb();
 109     }
 110
 111     public Exec(IExecCallback cb)
 112     {
 113         callback = cb;
 114     }
 115
 116     // run the command and catch output
 117     // if it failed, return null
 118     public String run_catch(String cmdline)
 119     {
 120         return run_catch(cmdline,false);
 121     }
 122
 123     public String run_catch(String cmdline, boolean lf)
 124     {
 125         IExecCallback old_cb = callback;
 126         collect_buf cb = new collect_buf();
 127         cb.add_lf = lf;
 128         callback = cb;
 129
 130         boolean res = run(cmdline);
 131         callback = old_cb;
 132
 133         if (res)
 134             return cb.buffer;
 135         else
 136         {
 137             System.err.println("run_catch() error: \""+cb.buffer+"\"");
 138             return null;
 139         }
 140     }
 141
 142     private boolean is_interrupted(IOException e)
 143     {
 144         String except = e.toString();
 145         return (except.indexOf("Interrupted system call")!=-1);
 146     }
 147
 148     public boolean run(String cmdline)
 149     {
 150         return run(cmdline,(File)null);
 151     }
 152
 153     public boolean run(String cmdline, File dir)
 154     {
 155         String cmds[] = cmds = new String[3];
 156
 157         cmds[0] = "/bin/bash";
 158         cmds[1] = "-c";
 159         cmds[2] = cmdline + " 2>&1";
 160
 161         callback.debug("executing: \""+cmdline+"\"");
 162
 163         if (dir==null)
 164             dir = new File(System.getProperty("user.dir"));
 165
 166         try
 167         {
 168             if (dir==null)
 169                 process = Runtime.getRuntime().exec(cmds);
 170             else
 171                 process = Runtime.getRuntime().exec(cmds,null,dir);
 172         }
 173         catch (IOException e)
 174         {
 175             callback.error("Stage::exec() could not execute: "+cmdline+
 176                   " IOException "+e.toString());
 177
 178             return false;
 179         }
 180
 181         stdout = new BufferedReader(new InputStreamReader(process.getInputStream()));
 182         stderr = new BufferedReader(new InputStreamReader(process.getErrorStream()));
 183
 184         FetchStderrThread err = new FetchStderrThread();
 185         FetchStdoutThread out = new FetchStdoutThread();
 186
 187         err.start();
 188         out.start();
 189
 190         try
 191         {
 192             exit_code = process.waitFor();
 193             callback.debug("subprocess exited with: "+exit_code);
 194             return (exit_code==0);
 195         }
 196         catch (InterruptedException e)
 197         {
 198             callback.error("InterruptedException in Stage::exec()"+e);
 199             return false;
 200         }
 201     }
 202
 203     public void abort()
 204     {
 205         running = false;
 206         try { stdout.close(); }
 207         catch (IOException e) { }
 208         try { stderr.close(); }
 209         catch (IOException e) { }
 210     }
 211
 212     public static String exec_catch(String cmd)
 213     {
 214         return new Exec().run_catch(cmd);
 215     }
 216
 217     public static boolean exec_command(String cmd)
 218     {
 219         return new Exec().run(cmd);
 220     }
 221
 222     public static boolean exec_command(String cmd, IExecCallback cb)
 223     {
 224         return new Exec(cb).run(cmd);
 225     }
 226 }