adapted to new storage location
[feisty_meow.git] / kona / src / org / feistymeow / process / ThreadSpawnerAndWatcher.java
1 package org.feistymeow.process;
2
3 //////////////
4 //Name   : ThreadSpawnerAndWatcher
5 //Author : Chris Koeritz
6 //Rights : Copyright (c) 2012-$now By University of Virginia
7 //////////////
8 //This file is free software; you can modify/redistribute it under the terms
9 //of the Apache License v2.0: http://www.apache.org/licenses/LICENSE-2.0
10 //Feel free to send updates to: [ koeritz@virginia.edu ]
11 //////////////
12
13
14 // test app by Chris Koeritz.
15
16 import java.io.IOException;
17 import java.lang.ProcessBuilder;
18 import java.lang.Process;
19 import java.util.Vector;
20
21 import org.apache.commons.logging.Log;
22 import org.apache.commons.logging.LogFactory;
23 import org.apache.log4j.PropertyConfigurator;
24
25 class Defaults
26 {
27   public static int CONCURRENT_LAUNCHES = 1000;
28 };
29
30 // will be spawned multiply and each one will check its one process.
31 class ThreadSpawnerAndWatcher implements Runnable
32 {
33   private static Log c_logger = LogFactory.getLog(ThreadSpawnerAndWatcher.class);
34
35   private volatile Thread myThread;
36
37   private Vector<String> cmdline;
38
39   private ProcessBuilder procbuild;
40
41   @SuppressWarnings("unchecked")
42   public ThreadSpawnerAndWatcher(Vector<String> command_line)
43   {
44     cmdline = (Vector<String>) command_line.clone();
45     procbuild = new ProcessBuilder(cmdline);
46   }
47
48   /**
49    * Launches the thread and waits for its results.
50    */
51   public void start()
52   {
53     if (null == this.myThread) {
54       this.myThread = new Thread(this);
55       this.myThread.start();
56     }
57   }
58
59   /**
60    * Stops the execution of the ProcessWatchingThread - or tries to.
61    */
62   public void stop()
63   {
64     Thread goAway = myThread;
65     myThread = null;
66     if (null != goAway) {
67       goAway.interrupt();
68     }
69   }
70
71   /**
72    * Returns true if the thread isn't null, i.e. it is still running.
73    */
74   public boolean threadRunning()
75   {
76     return (null != this.myThread);
77   }
78
79   public void run()
80   {
81     if (false == threadRunning()) {
82       return; // stopped before it ever started
83     }
84
85     try {
86       // c_logger.info("about to start process: " + cmdline);
87       Process p = procbuild.start();
88       p.waitFor();
89       // c_logger.info("returned from awaiting process: " + cmdline);
90     } catch (IOException e) {
91       c_logger.debug("thread caught io exception on: " + cmdline);
92     } catch (InterruptedException ie) {
93       c_logger.debug("thread interrupted for: " + cmdline);
94     } finally {
95       this.myThread = null; // thread is exiting
96     }
97   }
98
99   static public void main(String[] args) throws Throwable
100   {
101     PropertyConfigurator.configure("log4j.properties"); // hard-coded for
102                                                         // eclipse based run.
103
104     Vector<String> cmds = new Vector<String>();
105
106     cmds.add("/bin/echo");
107     cmds.add("hello jupiter");
108
109     // cmds.add("/bin/sleep");
110     // cmds.add("10");
111
112     Vector<ThreadSpawnerAndWatcher> watchers = new Vector<ThreadSpawnerAndWatcher>();
113
114     c_logger.info("revving up the process launching test.");
115
116     // create all the threads and get them ready to go.
117     for (int i = 0; i < Defaults.CONCURRENT_LAUNCHES; i++) {
118       ThreadSpawnerAndWatcher newby = new ThreadSpawnerAndWatcher(cmds);
119       watchers.add(newby);
120     }
121
122     // randomize start order?
123     // now start all the threads, which will cause all our process launches.
124     for (int i = 0; i < Defaults.CONCURRENT_LAUNCHES; i++) {
125       ThreadSpawnerAndWatcher curr = watchers.get(i);
126       curr.start();
127     }
128
129     // now wait for them all to finish. if we never get out, then there's a bug
130     // someplace.
131     for (int i = 0; i < Defaults.CONCURRENT_LAUNCHES; i++) {
132       ThreadSpawnerAndWatcher curr = watchers.get(i);
133       while (curr.threadRunning()) {
134         try {
135           Thread.sleep(100);
136         } catch (InterruptedException e) {
137           // ignore for now.
138         }
139       }
140     }
141
142     // currently test will never come back out to finish, if there's a failure
143     // seen.
144     c_logger.info("Test Succeeded: all spawned processes came back as expected.");
145     System.exit(0);
146   }
147 }