testsrc/compbio/engine/local/AsyncLocalRunnerTester.java

   1 /* Copyright (c) 2009 Peter Troshin\r
   2  *  \r
   3  *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 1.0     \r
   4  * \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
   7  * \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
  11  * \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
  14  * \r
  15  * Any republication or derived work distributed in source code form\r
  16  * must include this copyright and license notice.\r
  17  */\r
  18 \r
  19 package compbio.engine.local;\r
  20 \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
  27 \r
  28 import java.io.File;\r
  29 import java.util.concurrent.CancellationException;\r
  30 \r
  31 import org.testng.annotations.Test;\r
  32 \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
  46 \r
  47 public class AsyncLocalRunnerTester {\r
  48 \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
  52 \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
  56 \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
  60 \r
  61         // Output file will be located in the task working directory, thus only name\r
  62         // is required\r
  63         public static String unix_test_outfile = "TO1381.alignment.out";\r
  64         public static String cluster_test_outfile = "TO1381.alignment.cluster.out";\r
  65 \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
  69 \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
  73 \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
  77 \r
  78         // Output file will be located in the task working directory, thus only name\r
  79         // is required\r
  80         public static String win_test_outfile = "TO1381.alignment.out";\r
  81 \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
  87 \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
  91                 } else {\r
  92                         System.out.println("Working in UNIX environment");\r
  93                         clustal.setInput(unix_test_input).setOutput(unix_test_outfile);\r
  94                 }\r
  95                 AsyncExecutor lr = new AsyncLocalRunner();\r
  96                 try {\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
 111                 }\r
 112         }\r
 113 \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
 118 \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
 122                 } else {\r
 123                         System.out.println("Working in UNIX environment");\r
 124                         muscle.setInput(unix_test_input).setOutput(unix_test_outfile);\r
 125                 }\r
 126                 AsyncExecutor lr = new AsyncLocalRunner();\r
 127                 try {\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
 137                         assertNotNull(al);\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
 144                 }\r
 145         }\r
 146 \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
 151 \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
 155                 } else {\r
 156                         System.out.println("Working in UNIX environment");\r
 157                         muscle.setInput(unix_test_AVG_input).setOutput(unix_test_outfile);\r
 158                 }\r
 159                 AsyncExecutor lr = new AsyncLocalRunner();\r
 160                 try {\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
 168                                 Thread.sleep(100);\r
 169                                 status = lr.getJobStatus(jobId);\r
 170                         }\r
 171                         while (status != JobStatus.FINISHED) {\r
 172                                 Thread.sleep(500);\r
 173                                 assertTrue(status == JobStatus.RUNNING);\r
 174                                 status = lr.getJobStatus(jobId);\r
 175                         }\r
 176                         // assert that we get here, means that the job reached FINISHED\r
 177                         // status\r
 178                         // This call causes CancellationException to be thrown\r
 179                         Executable<?> muscler = lr.getResults(jobId);\r
 180                         /*\r
 181                          * After results were obtained the task were removed for the queue,\r
 182                          * and it status could not be determined\r
 183                          */\r
 184                         // Make sure list has been updated\r
 185                         Thread.sleep(200);\r
 186                         status = lr.getJobStatus(jobId);\r
 187                         assertTrue(status == JobStatus.FINISHED);\r
 188 \r
 189                         Alignment al = confMuscle.getResults();\r
 190 \r
 191                         assertNotNull(al);\r
 192 \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
 202                 }\r
 203         }\r
 204 \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
 214                 } else {\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
 218                 }\r
 219                 try {\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
 226 \r
 227                         String jobId1 = lr.submitJob(confClustal1);\r
 228                         String jobId2 = lr2.submitJob(confClustal2);\r
 229 \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
 241 \r
 242                         assertTrue(lr.cleanup(jobId1));\r
 243                         assertTrue(lr2.cleanup(jobId2));\r
 244 \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
 251                 }\r
 252         }\r
 253 \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
 261                 } else {\r
 262                         System.out.println("Working in UNIX environment");\r
 263                         clustal.setInput(unix_test_input).setOutput(unix_test_outfile);\r
 264                 }\r
 265                 try {\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
 278 \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
 298                 }\r
 299         }\r
 300 \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
 305 \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
 309                 } else {\r
 310                         System.out.println("Working in UNIX environment");\r
 311                         muscle.setInput(unix_test_input).setOutput(unix_test_outfile);\r
 312                 }\r
 313 \r
 314                 try {\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
 324 \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
 345                 }\r
 346         }\r
 347 \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
 352 \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
 356                 } else {\r
 357                         System.out.println("Working in UNIX environment");\r
 358                         muscle.setInput(unix_test_input).setOutput(unix_test_outfile);\r
 359                 }\r
 360 \r
 361                 try {\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
 371 \r
 372                         assertTrue(Util.isMarked(confMuscle.getWorkDirectory(),\r
 373                                         JobStatus.CANCELLED));\r
 374                         // could be both\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
 390                 }\r
 391         }\r
 392 }\r