|
1
4 package com.tc.simulator.crasher;
5
6 import org.apache.commons.io.FileUtils;
7
8 import com.tc.exception.TCRuntimeException;
9
10 import java.io.File  ;
11 import java.io.IOException ;
12 import java.text.DateFormat ;
13 import java.text.SimpleDateFormat ;
14 import java.util.ArrayList ;
15 import java.util.Arrays ;
16 import java.util.Iterator ;
17 import java.util.LinkedList ;
18 import java.util.List ;
19 import java.util.Random ;
20
21 public class Crasher implements Runnable {
22
23 private static final DateFormat dateFormat = new SimpleDateFormat ("M/d/y:H:m:s,S (Z)");
24
25 private final Arguments args;
26
27 public Crasher(Arguments args) {
28 this.args = args;
29 }
30
31 public void run() {
32 System.out.println("instance count: " + args.getInstanceCount());
33 System.out.println("classname: " + args.getClassname());
34 System.out.println("crash freq: " + args.getCrashFrequency());
35 System.out.println("args: " + args.getMainClassArgs());
36 System.out.println("server args: " + args.getServerArgs());
37
38 File outputDirectory = new File (args.getOutputDirectoryname());
39 if (!outputDirectory.exists()) {
40 System.out.println("output directory doesn't exist. attempting to create: " + outputDirectory);
41 try {
42 FileUtils.forceMkdir(outputDirectory);
43 } catch (IOException e) {
44 throw new TCRuntimeException(e);
45 }
46 } else {
47 System.out.println("output directory: " + outputDirectory);
48 }
49
50 System.out.println("output prefix: " + args.getOutputPrefix());
51
52 ProcessContainer[] processes = new ProcessContainer[args.getInstanceCount()];
53 for (int i = 0; i < processes.length; i++) {
54 try {
55 processes[i] = new ProcessContainer(new ProcessContainerConfig(i + "", dateFormat, args.getServerArgs(), args.getClassname(),
56 args.getMainClassArgs(), outputDirectory, args
57 .getOutputPrefix()));
58 } catch (IOException e) {
59 throw new TCRuntimeException(e);
60 }
61 }
62
63 try {
64 doStuff(processes);
65 } catch (Exception e) {
66 throw new TCRuntimeException(e);
67 }
68 }
69
70 private void doStuff(ProcessContainer[] processes) throws IOException , InterruptedException {
71 Random random = new Random ();
72 while (true) {
73 for (int i = 0; i < processes.length; i++) {
74 ProcessContainer process = processes[i];
75 if (process.isStopped()) {
76 System.out.println("Starting process " + i + "...");
77 process.start();
78 } else if (random.nextInt(100) <= (args.crashFrequency * 100)) {
79 System.out.println("Stopping process " + i + "...");
80 process.stop();
81 System.out.println("Starting process " + i + "...");
82 process.start();
83 }
84 }
85 Thread.sleep(10 * 1000);
86 }
87
88 }
89
90 public static class Arguments {
91 private static final String CLASSNAME_ARG = "--crasher:classname";
92 private static final String INSTANCE_COUNT_ARG = "--crasher:instance-count";
93 private static final String CRASH_FREQUENCY_ARG = "--crasher:crash-frequency";
94 private static final String SERVER_ARGS_PREFIX = "--crasher:server-arg";
95 private static final String OUTPUT_DIRECTORYNAME_ARG = "--crasher:output-directory";
96 private static final String OUTPUT_PREFIX_ARG = "--crasher:output-prefix";
97
98 private final List args;
99 private List serverArgs;
100 private int instanceCount;
101 private String classname;
102 private double crashFrequency;
103 private String outputDirectoryname;
104 private String outputPrefix;
105
106 public Arguments(String [] args) {
107 this.args = new LinkedList (Arrays.asList(args));
108 }
109
110 public List getServerArgs() {
111 return new ArrayList (this.serverArgs);
112 }
113
114 public List getMainClassArgs() {
115 return new ArrayList (args);
116 }
117
118 public double getCrashFrequency() {
119 return this.crashFrequency;
120 }
121
122 public int getInstanceCount() {
123 return this.instanceCount;
124 }
125
126 public String getClassname() {
127 return this.classname;
128 }
129
130 public String getOutputDirectoryname() {
131 return this.outputDirectoryname;
132 }
133
134 public String getOutputPrefix() {
135 return this.outputPrefix;
136 }
137
138 public synchronized boolean parse() {
139 try {
140 this.instanceCount = parseInstanceCount();
141 this.classname = parseClassname();
142 this.crashFrequency = parseCrashFrequency();
143 this.serverArgs = parseServerArgs();
144 this.outputDirectoryname = parseOutputDirectoryname();
145 this.outputPrefix = parseOutputPrefix();
146 addClasspath();
147
148 } catch (Exception e) {
149 e.printStackTrace();
150 return false;
151 }
152 return true;
153 }
154
155 private void addClasspath() {
156 this.serverArgs.add("-classpath");
157 this.serverArgs.add(System.getProperty("java.class.path"));
158 }
159
160 private String parseOutputPrefix() {
161 String rv = getArgumentValueAndPruneArgsArray(OUTPUT_PREFIX_ARG);
162 if (rv == null) { throw new RuntimeException ("No such argument: " + OUTPUT_PREFIX_ARG); }
163 return rv;
164 }
165
166 private String parseOutputDirectoryname() {
167 String rv = getArgumentValueAndPruneArgsArray(OUTPUT_DIRECTORYNAME_ARG);
168 if (rv == null) { throw new RuntimeException ("No such argument: " + OUTPUT_DIRECTORYNAME_ARG); }
169 return rv;
170 }
171
172 private List parseServerArgs() {
173 return getArgumentValuesAndPruneArgsArray(new ArrayList (), SERVER_ARGS_PREFIX);
174 }
175
176 private int parseInstanceCount() throws Exception {
177 return Integer.parseInt(getArgumentValueAndPruneArgsArray(INSTANCE_COUNT_ARG));
178 }
179
180 private String parseClassname() throws Exception {
181 String rv = getArgumentValueAndPruneArgsArray(CLASSNAME_ARG);
182 if (rv == null) { throw new RuntimeException ("No such argument: " + CLASSNAME_ARG); }
183 return rv;
184 }
185
186 private double parseCrashFrequency() throws Exception {
187 return Double.parseDouble(getArgumentValueAndPruneArgsArray(CRASH_FREQUENCY_ARG));
188 }
189
190 private String getArgumentValueAndPruneArgsArray(String argumentPattern) {
191 List values = getArgumentValuesAndPruneArgsArray(new ArrayList (), argumentPattern);
192 return (String ) ((values.size() > 0) ? values.get(0) : null);
193 }
194
195 private List getArgumentValuesAndPruneArgsArray(List list, String argumentPattern) {
196 List tmp = getArgumentsAndPruneArgsArray(new ArrayList (), argumentPattern);
197 for (Iterator i = tmp.iterator(); i.hasNext();) {
198 String arg = (String ) i.next();
199 list.add(arg.substring(arg.indexOf('=') + 1, arg.length()));
200 }
201 return list;
202 }
203
204 private List getArgumentsAndPruneArgsArray(List list, String argumentPattern) {
205 for (Iterator i = args.iterator(); i.hasNext();) {
206 String arg = (String ) i.next();
207 if (arg.startsWith(argumentPattern)) {
208 i.remove();
209 list.add(arg);
210 }
211 }
212 return list;
213 }
214
215 public StringBuffer usage(StringBuffer buf) {
216 buf.append("Crasher -- starts, crashes, and restarts Container instances.\n");
217 buf.append("Usage:\n");
218 buf.append("\tjava " + Crasher.class.getName() + " " + INSTANCE_COUNT_ARG + "=<instance count> "
219 + CRASH_FREQUENCY_ARG + "=<crash frequency [0-1]> " + "[[" + SERVER_ARGS_PREFIX
220 + "=<server arg>],...] " + OUTPUT_DIRECTORYNAME_ARG + "=<output directory> " + OUTPUT_PREFIX_ARG
221 + "=<output prefix> " + CLASSNAME_ARG + "=<main class> <main class args>\n\n");
222 return buf;
223 }
224
225 }
226
227 public static void main(String [] args) throws Exception {
228 Arguments arguments = new Arguments(args);
229 if (!arguments.parse()) {
230 System.out.println(arguments.usage(new StringBuffer ()));
231 return;
232 }
233 new Crasher(arguments).run();
234 }
235
236 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.