Task


1   /******************************************************************************
2    * The contents of this file are subject to the   Compiere License  Version 1.1
3    * ("License"); You may not use this file except in compliance with the License
4    * You may obtain a copy of the License at http://www.compiere.org/license.html
5    * Software distributed under the License is distributed on an  "AS IS"  basis,
6    * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
7    * the specific language governing rights and limitations under the License.
8    * The Original Code is                  Compiere  ERP & CRM  Business Solution
9    * The Initial Developer of the Original Code is Jorg Janke  and ComPiere, Inc.
10   * Portions created by Jorg Janke are Copyright (C) 1999-2001 Jorg Janke, parts
11   * created by ComPiere are Copyright (C) ComPiere, Inc.;   All Rights Reserved.
12   * Contributor(s): ______________________________________.
13   *****************************************************************************/
14  package org.compiere.util;
15  
16  import java.util.*;
17  import java.io.*;
18  
19  /**
20   *  Execute OS Task
21   *
22   *  @author     Jorg Janke
23   *  @version    $Id: Task.java,v 1.4 2003/07/21 04:41:49 jjanke Exp $
24   */
25  public class Task extends Thread  
26  {
27      /**
28       *  Create Process with cmd
29       *  @param cmd o/s command
30       */
31      public Task (String   cmd)
32      {
33          m_cmd = cmd;
34      }   //  Task
35  
36      private String            m_cmd;
37      private Process           m_child = null;
38  
39      private StringBuffer      m_out = new StringBuffer  ();
40      private StringBuffer      m_err = new StringBuffer  ();
41  
42      /** The Output Stream of process        */
43      private InputStream     m_outStream;
44      /** The Error Output Stream of process  */
45      private InputStream     m_errStream;
46      /** The Input Stream of process         */
47      private OutputStream    m_inStream;
48  
49      /** Read Out                            */
50      private Thread            m_outReader = new Thread  ()
51      {
52          public void run()
53          {
54              Log.trace(Log.l5_DData, "Task.outReader.run");
55              try
56              {
57                  int c;
58                  while ((c = m_outStream.read()) != -1 && !isInterrupted())
59                  {
60              //      System.out.print((char)c);
61                      m_out.append((char)c);
62                  }
63                  m_outStream.close();
64              }
65              catch (IOException ioe)
66              {
67                  Log.error("Task.outReader", ioe);
68              }
69              Log.trace(Log.l5_DData, "Task.outReader.run - done");
70          }   //  run
71      };   //  m_outReader
72  
73      /** Read Out                            */
74      private Thread            m_errReader = new Thread  ()
75      {
76          public void run()
77          {
78              Log.trace(Log.l5_DData, "Task.errReader.run");
79              try
80              {
81                  int c;
82                  while ((c = m_errStream.read()) != -1 && !isInterrupted())
83                  {
84              //      System.err.print((char)c);
85                      m_err.append((char)c);
86                  }
87                  m_errStream.close();
88              }
89              catch (IOException ioe)
90              {
91                  Log.error("Task.errReader", ioe);
92              }
93              Log.trace(Log.l5_DData, "Task.errReader.run - done");
94          }   //  run
95      };   //  m_errReader
96  
97  
98      /**
99       *  Execute it
100      */
101     public void run()
102     {
103         Log.trace(Log.l4_Data, "Task.run");
104         try
105         {
106             m_child = Runtime.getRuntime().exec(m_cmd);
107             //
108             m_outStream = m_child.getInputStream();
109             m_errStream = m_child.getErrorStream();
110             m_inStream = m_child.getOutputStream();
111             //
112             if (checkInterrupted())
113                 return;
114             m_outReader.start();
115             m_errReader.start();
116             //
117             try
118             {
119                 if (checkInterrupted())
120                     return;
121                 m_errReader.join();
122                 if (checkInterrupted())
123                     return;
124                 m_outReader.join();
125                 if (checkInterrupted())
126                     return;
127                 m_child.waitFor();
128             }
129             catch (InterruptedException   ie)
130             {
131             //  Log.error("Task.run (ie)", ie);
132             }
133             //  ExitValue
134             try
135             {
136                 if (m_child != null)
137                     Log.trace(Log.l5_DData, "Task.run - ExitValue=" + m_child.exitValue());
138             }
139             catch (Exception   e) {}
140             Log.trace(Log.l4_Data, "Task.run - done");
141         }
142         catch (IOException ioe)
143         {
144             Log.error("Task.run (ioe)", ioe);
145         }
146     }   //  run
147 
148     /**
149      *  Check if interrupted
150      *  @return true if interrupted
151      */
152     private boolean checkInterrupted()
153     {
154         if (isInterrupted())
155         {
156             Log.trace(Log.l3_Util, "Task.checkInterrupted - true");
157             //  interrupt child processes
158             if (m_child != null)
159                 m_child.destroy();
160             m_child = null;
161             if (m_outReader != null && m_outReader.isAlive())
162                 m_outReader.interrupt();
163             m_outReader = null;
164             if (m_errReader != null && m_errReader.isAlive())
165                 m_errReader.interrupt();
166             m_errReader = null;
167             //  close Streams
168             if (m_inStream != null)
169                 try {   m_inStream.close();     } catch (Exception   e) {}
170             m_inStream = null;
171             if (m_outStream != null)
172                 try {   m_outStream.close();    } catch (Exception   e) {}
173             m_outStream = null;
174             if (m_errStream != null)
175                 try {   m_errStream.close();    } catch (Exception   e) {}
176             m_errStream = null;
177             //
178             return true;
179         }
180         return false;
181     }   //  checkInterrupted
182 
183     /**
184      *  Get Out Info
185      *  @return StringBuffer
186      */
187     public StringBuffer   getOut()
188     {
189         return m_out;
190     }   //  getOut
191 
192     /**
193      *  Get Err Info
194      *  @return StringBuffer
195      */
196     public StringBuffer   getErr()
197     {
198         return m_err;
199     }   //  getErr
200 
201     /**
202      *  Get The process input stream - i.e. we output to it
203      *  @return OutputStream
204      */
205     public OutputStream getInStream()
206     {
207         return m_inStream;
208     }   //  getInStream
209 }   //  Task
210
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags