1 /* Copyright (c) 2009 Peter Troshin
\r
3 * JAva Bioinformatics Analysis Web Services (JABAWS) @version: 1.0
\r
5 * This library is free software; you can redistribute it and/or modify it under the terms of the
\r
6 * Apache License version 2 as published by the Apache Software Foundation
\r
8 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
\r
9 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Apache
\r
10 * License for more details.
\r
12 * A copy of the license is in apache_license.txt. It is also available here:
\r
13 * @see: http://www.apache.org/licenses/LICENSE-2.0.txt
\r
15 * Any republication or derived work distributed in source code form
\r
16 * must include this copyright and license notice.
\r
19 package compbio.engine.local;
\r
21 import static org.testng.Assert.assertEquals;
\r
22 import static org.testng.Assert.assertFalse;
\r
23 import static org.testng.Assert.assertNotNull;
\r
24 import static org.testng.Assert.assertNotSame;
\r
25 import static org.testng.Assert.assertTrue;
\r
26 import static org.testng.Assert.fail;
\r
28 import java.io.File;
\r
29 import java.util.concurrent.CancellationException;
\r
31 import org.testng.annotations.Test;
\r
33 import compbio.data.sequence.Alignment;
\r
34 import compbio.engine.AsyncExecutor;
\r
35 import compbio.engine.Configurator;
\r
36 import compbio.engine.client.ConfiguredExecutable;
\r
37 import compbio.engine.client.Executable;
\r
38 import compbio.engine.client.Util;
\r
39 import compbio.metadata.AllTestSuit;
\r
40 import compbio.metadata.JobStatus;
\r
41 import compbio.metadata.JobSubmissionException;
\r
42 import compbio.metadata.ResultNotAvailableException;
\r
43 import compbio.runner.msa.ClustalW;
\r
44 import compbio.runner.msa.Muscle;
\r
45 import compbio.util.SysPrefs;
\r
47 public class AsyncLocalRunnerTester {
\r
49 // Input path must be absolute to avoid coping input in working directory
\r
50 public static String unix_test_input = AllTestSuit.CURRENT_DIRECTORY
\r
51 + File.separator + AllTestSuit.TEST_DATA_PATH + "TO1381.fasta";
\r
53 public static String unix_test_AVG_input = AllTestSuit.CURRENT_DIRECTORY
\r
54 + File.separator + AllTestSuit.TEST_DATA_PATH
\r
55 + "50x500Protein.fasta";
\r
57 public static String unix_test_LARGE_input = AllTestSuit.CURRENT_DIRECTORY
\r
58 + File.separator + AllTestSuit.TEST_DATA_PATH
\r
59 + "200x500Protein.fasta";
\r
61 // Output file will be located in the task working directory, thus only name
\r
63 public static String unix_test_outfile = "TO1381.alignment.out";
\r
64 public static String cluster_test_outfile = "TO1381.alignment.cluster.out";
\r
66 // Input path must be absolute to avoid coping input in working directory
\r
67 public static String win_test_input = AllTestSuit.CURRENT_DIRECTORY
\r
68 + File.separator + AllTestSuit.TEST_DATA_PATH + "TO1381.fasta";
\r
70 public static String win_test_LARGE_input = AllTestSuit.CURRENT_DIRECTORY
\r
71 + File.separator + AllTestSuit.TEST_DATA_PATH
\r
72 + "200x500Protein.fasta";
\r
74 public static String win_test_AVG_input = AllTestSuit.CURRENT_DIRECTORY
\r
75 + File.separator + AllTestSuit.TEST_DATA_PATH
\r
76 + "50x500Protein.fasta";
\r
78 // Output file will be located in the task working directory, thus only name
\r
80 public static String win_test_outfile = "TO1381.alignment.out";
\r
82 @Test(expectedExceptions = { CancellationException.class,
\r
83 ResultNotAvailableException.class }, groups = { AllTestSuit.test_group_engine })
\r
84 public void testCancelLocally() throws ResultNotAvailableException {
\r
85 System.out.println("Running testCancelLocally");
\r
86 ClustalW clustal = new ClustalW();
\r
88 if (SysPrefs.isWindows) {
\r
89 System.out.println("Working in WINDOWS environment");
\r
90 clustal.setInput(win_test_input).setOutput(win_test_outfile);
\r
92 System.out.println("Working in UNIX environment");
\r
93 clustal.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
95 AsyncExecutor lr = new AsyncLocalRunner();
\r
97 ConfiguredExecutable<ClustalW> confClust = Configurator
\r
98 .configureExecutable(clustal);
\r
99 String jobId = lr.submitJob(confClust);
\r
100 // Thread.sleep(10); //wait for 100ms
\r
101 assertNotSame(lr.getJobStatus(jobId), JobStatus.FINISHED,
\r
102 "Job has finished already. Too late to test cancel!");
\r
103 lr.cancelJob(jobId);
\r
104 // This call causes CancellationException to be thrown
\r
105 Executable<?> clustalr = lr.getResults(jobId);
\r
106 // @see AsyncLocalRunner.cleanup documents
\r
107 // assertTrue(lr.cleanup(jobId));
\r
108 } catch (JobSubmissionException e) {
\r
109 e.printStackTrace();
\r
110 fail(e.getLocalizedMessage());
\r
114 @Test(invocationCount = 5, threadPoolSize = 4, groups = { AllTestSuit.test_group_engine })
\r
115 public void testSubmitLocally() {
\r
116 System.out.println("Running testSubmitLocally()");
\r
117 Muscle muscle = new Muscle();
\r
119 if (SysPrefs.isWindows) {
\r
120 System.out.println("Working in WINDOWS environment");
\r
121 muscle.setInput(win_test_input).setOutput(win_test_outfile);
\r
123 System.out.println("Working in UNIX environment");
\r
124 muscle.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
126 AsyncExecutor lr = new AsyncLocalRunner();
\r
128 ConfiguredExecutable<Muscle> confMuscle = Configurator
\r
129 .configureExecutable(muscle);
\r
130 String jobId = lr.submitJob(confMuscle);
\r
131 // Thread.sleep(10); //wait for 100ms
\r
132 // assertNotSame("Job has finished already. Too late to test cancel!",
\r
133 // JobStatus.FINISHED, lr.getJobStatus(jobId));
\r
134 // This call causes CancellationException to be thrown
\r
135 Executable<?> muscler = lr.getResults(jobId);
\r
136 Alignment al = confMuscle.getResults();
\r
138 } catch (JobSubmissionException e) {
\r
139 e.printStackTrace();
\r
140 fail(e.getLocalizedMessage());
\r
141 } catch (ResultNotAvailableException e) {
\r
142 e.printStackTrace();
\r
143 fail(e.getMessage());
\r
147 @Test(invocationCount = 5, threadPoolSize = 4, groups = { AllTestSuit.test_group_engine })
\r
148 public void testGetStatus() {
\r
149 System.out.println("Running testGetStatus");
\r
150 Muscle muscle = new Muscle();
\r
152 if (SysPrefs.isWindows) {
\r
153 System.out.println("Working in WINDOWS environment");
\r
154 muscle.setInput(win_test_AVG_input).setOutput(win_test_outfile);
\r
156 System.out.println("Working in UNIX environment");
\r
157 muscle.setInput(unix_test_AVG_input).setOutput(unix_test_outfile);
\r
159 AsyncExecutor lr = new AsyncLocalRunner();
\r
161 ConfiguredExecutable<Muscle> confMuscle = Configurator
\r
162 .configureExecutable(muscle);
\r
163 String jobId = lr.submitJob(confMuscle);
\r
164 // Thread.sleep(10); //wait for 100ms
\r
165 JobStatus status = lr.getJobStatus(jobId);
\r
166 while (status == JobStatus.UNDEFINED) {
\r
167 assertTrue(status == JobStatus.UNDEFINED);
\r
169 status = lr.getJobStatus(jobId);
\r
171 while (status != JobStatus.FINISHED) {
\r
173 assertTrue(status == JobStatus.RUNNING);
\r
174 status = lr.getJobStatus(jobId);
\r
176 // assert that we get here, means that the job reached FINISHED
\r
178 // This call causes CancellationException to be thrown
\r
179 Executable<?> muscler = lr.getResults(jobId);
\r
181 * After results were obtained the task were removed for the queue,
\r
182 * and it status could not be determined
\r
184 // Make sure list has been updated
\r
186 status = lr.getJobStatus(jobId);
\r
187 assertTrue(status == JobStatus.FINISHED);
\r
189 Alignment al = confMuscle.getResults();
\r
193 } catch (JobSubmissionException e) {
\r
194 e.printStackTrace();
\r
195 fail(e.getLocalizedMessage());
\r
196 } catch (InterruptedException e) {
\r
197 e.printStackTrace();
\r
198 fail(e.getLocalizedMessage());
\r
199 } catch (ResultNotAvailableException e) {
\r
200 e.printStackTrace();
\r
201 fail(e.getMessage());
\r
205 @Test(expectedExceptions = CancellationException.class, groups = { AllTestSuit.test_group_engine })
\r
206 public void testMultipleCancelLocally() {
\r
207 System.out.println("Running testMultipleCancelLocally()");
\r
208 ClustalW clustal = new ClustalW();
\r
209 ClustalW clustal2 = new ClustalW();
\r
210 if (SysPrefs.isWindows) {
\r
211 System.out.println("Working in WINDOWS environment");
\r
212 clustal.setInput(win_test_input).setOutput(win_test_outfile);
\r
213 clustal2.setInput(win_test_input).setOutput(win_test_outfile);
\r
215 System.out.println("Working in UNIX environment");
\r
216 clustal.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
217 clustal2.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
220 ConfiguredExecutable<ClustalW> confClustal1 = Configurator
\r
221 .configureExecutable(clustal);
\r
222 ConfiguredExecutable<ClustalW> confClustal2 = Configurator
\r
223 .configureExecutable(clustal2);
\r
224 AsyncLocalRunner lr = new AsyncLocalRunner();
\r
225 AsyncLocalRunner lr2 = new AsyncLocalRunner();
\r
227 String jobId1 = lr.submitJob(confClustal1);
\r
228 String jobId2 = lr2.submitJob(confClustal2);
\r
230 // Thread.sleep(10); //wait for 100ms
\r
231 assertNotSame(lr.getJobStatus(jobId1), JobStatus.FINISHED,
\r
232 "Job has finished already. Too late to test cancel!");
\r
233 lr.cancelJob(jobId1);
\r
234 // Thread.sleep(10);
\r
235 assertNotSame(lr2.getJobStatus(jobId2), JobStatus.FINISHED,
\r
236 "Job has finished already. Too late to test cancel!");
\r
237 lr2.cancelJob(jobId2);
\r
238 // This call causes CancellationException to be thrown
\r
239 Executable<?> clustalr = lr.getResults(jobId1);
\r
240 Executable<?> clustalr2 = lr2.getResults(jobId2);
\r
242 assertTrue(lr.cleanup(jobId1));
\r
243 assertTrue(lr2.cleanup(jobId2));
\r
245 } catch (JobSubmissionException e) {
\r
246 e.printStackTrace();
\r
247 fail(e.getLocalizedMessage());
\r
248 } catch (ResultNotAvailableException e) {
\r
249 e.printStackTrace();
\r
250 fail(e.getLocalizedMessage());
\r
254 @Test(groups = { AllTestSuit.test_group_engine })
\r
255 public void testCancelCompletedTaskLocally() {
\r
256 System.out.println("Running testCancelCompletedTaskLocally");
\r
257 ClustalW clustal = new ClustalW();
\r
258 if (SysPrefs.isWindows) {
\r
259 System.out.println("Working in WINDOWS environment");
\r
260 clustal.setInput(win_test_input).setOutput(win_test_outfile);
\r
262 System.out.println("Working in UNIX environment");
\r
263 clustal.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
266 ConfiguredExecutable<ClustalW> confClustal1 = Configurator
\r
267 .configureExecutable(clustal);
\r
268 AsyncLocalRunner lr = new AsyncLocalRunner();
\r
269 String jobId = lr.submitJob(confClustal1);
\r
270 Thread.currentThread();
\r
271 Thread.sleep(3000); // wait for 100ms
\r
272 assertEquals(lr.getJobStatus(jobId), JobStatus.FINISHED,
\r
273 "Job has not finished!");
\r
274 lr.cancelJob(jobId);
\r
275 // This call causes CancellationException to be thrown
\r
276 Executable<?> clustalr = lr.getResults(jobId);
\r
277 assertNotNull(clustalr);
\r
279 assertTrue(Util.isMarked(confClustal1.getWorkDirectory(),
\r
280 JobStatus.CANCELLED));
\r
281 assertTrue(Util.isMarked(confClustal1.getWorkDirectory(),
\r
282 JobStatus.STARTED));
\r
283 assertTrue(Util.isMarked(confClustal1.getWorkDirectory(),
\r
284 JobStatus.COLLECTED));
\r
285 assertTrue(Util.isMarked(confClustal1.getWorkDirectory(),
\r
286 JobStatus.FINISHED));
\r
287 assertFalse(Util.isMarked(confClustal1.getWorkDirectory(),
\r
288 JobStatus.SUBMITTED));
\r
289 } catch (JobSubmissionException e) {
\r
290 e.printStackTrace();
\r
291 fail(e.getLocalizedMessage());
\r
292 } catch (InterruptedException e) {
\r
293 e.printStackTrace();
\r
294 fail(e.getLocalizedMessage());
\r
295 } catch (ResultNotAvailableException e) {
\r
296 e.printStackTrace();
\r
297 fail(e.getLocalizedMessage());
\r
301 @Test(groups = { AllTestSuit.test_group_engine })
\r
302 public void testAsyncRetrievOperation() {
\r
303 System.out.println("Running testAsyncOperation()");
\r
304 Muscle muscle = new Muscle();
\r
306 if (SysPrefs.isWindows) {
\r
307 System.out.println("Working in WINDOWS environment");
\r
308 muscle.setInput(win_test_input).setOutput(win_test_outfile);
\r
310 System.out.println("Working in UNIX environment");
\r
311 muscle.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
315 ConfiguredExecutable<Muscle> confMuscle = Configurator
\r
316 .configureExecutable(muscle);
\r
317 AsyncExecutor lr = new AsyncLocalRunner();
\r
318 String jobId = lr.submitJob(confMuscle);
\r
319 AsyncLocalRunner as = new AsyncLocalRunner();
\r
320 ConfiguredExecutable<Muscle> muscler = (ConfiguredExecutable<Muscle>) as
\r
321 .getResults(jobId);
\r
322 assertNotNull(muscler);
\r
323 Alignment al1 = muscler.getResults();
\r
325 assertTrue(Util.isMarked(muscler.getWorkDirectory(),
\r
326 JobStatus.STARTED));
\r
327 assertTrue(Util.isMarked(muscler.getWorkDirectory(),
\r
328 JobStatus.COLLECTED));
\r
329 assertTrue(Util.isMarked(muscler.getWorkDirectory(),
\r
330 JobStatus.FINISHED));
\r
331 assertFalse(Util.isMarked(muscler.getWorkDirectory(),
\r
332 JobStatus.CANCELLED));
\r
333 assertFalse(Util.isMarked(muscler.getWorkDirectory(),
\r
334 JobStatus.SUBMITTED));
\r
335 Alignment al2 = confMuscle.getResults();
\r
336 assertNotNull(al1);
\r
337 assertNotNull(al2);
\r
338 assertTrue(al1.equals(al2));
\r
339 } catch (JobSubmissionException e) {
\r
340 e.printStackTrace();
\r
341 fail(e.getLocalizedMessage());
\r
342 } catch (ResultNotAvailableException e) {
\r
343 e.printStackTrace();
\r
344 fail(e.getMessage());
\r
348 @Test(groups = { AllTestSuit.test_group_engine })
\r
349 public void testAsyncCancelOperation() {
\r
350 System.out.println("Running testAsyncOperation()");
\r
351 Muscle muscle = new Muscle();
\r
353 if (SysPrefs.isWindows) {
\r
354 System.out.println("Working in WINDOWS environment");
\r
355 muscle.setInput(win_test_input).setOutput(win_test_outfile);
\r
357 System.out.println("Working in UNIX environment");
\r
358 muscle.setInput(unix_test_input).setOutput(unix_test_outfile);
\r
362 ConfiguredExecutable<Muscle> confMuscle = Configurator
\r
363 .configureExecutable(muscle);
\r
364 AsyncExecutor lr = new AsyncLocalRunner();
\r
365 String jobId = lr.submitJob(confMuscle);
\r
366 // This call causes CancellationException to be thrown
\r
367 AsyncLocalRunner as = new AsyncLocalRunner();
\r
368 assertTrue(as.getJobStatus(jobId) != JobStatus.FINISHED);
\r
369 as.cancelJob(jobId);
\r
370 assertTrue(as.getJobStatus(jobId) == JobStatus.CANCELLED);
\r
372 assertTrue(Util.isMarked(confMuscle.getWorkDirectory(),
\r
373 JobStatus.CANCELLED));
\r
375 // assertFalse(Util.isMarked(confMuscle.getWorkDirectory(),
\r
376 // Util.StatFileType.STARTED));
\r
377 assertFalse(Util.isMarked(confMuscle.getWorkDirectory(),
\r
378 JobStatus.COLLECTED));
\r
379 assertFalse(Util.isMarked(confMuscle.getWorkDirectory(),
\r
380 JobStatus.FINISHED));
\r
381 assertFalse(Util.isMarked(confMuscle.getWorkDirectory(),
\r
382 JobStatus.SUBMITTED));
\r
383 // Executable<?> muscler = as.getResult(jobId);
\r
384 // assertNotNull(muscler);
\r
385 // Alignment al = muscle.getResults();
\r
386 // assertNotNull(al);
\r
387 } catch (JobSubmissionException e) {
\r
388 e.printStackTrace();
\r
389 fail(e.getLocalizedMessage());
\r