TestCmsScheduler


1   /*
2    * File   : $Source: /usr/local/cvs/opencms/test/org/opencms/scheduler/TestCmsScheduler.java,v $
3    * Date   : $Date: 2006/03/27 14:53:06 $
4    * Version: $Revision: 1.17 $
5    *
6    * This library is part of OpenCms -
7    * the Open Source Content Mananagement System
8    *
9    * Copyright (c) 2005 Alkacon Software GmbH (http://www.alkacon.com)
10   *
11   * This library is free software; you can redistribute it and/or
12   * modify it under the terms of the GNU Lesser General Public
13   * License as published by the Free Software Foundation; either
14   * version 2.1 of the License, or (at your option) any later version.
15   *
16   * This library is distributed in the hope that it will be useful,
17   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19   * Lesser General Public License for more details.
20   *
21   * For further information about Alkacon Software GmbH, please see the
22   * company website: http://www.alkacon.com
23   *
24   * For further information about OpenCms, please see the
25   * project website: http://www.opencms.org
26   * 
27   * You should have received a copy of the GNU Lesser General Public
28   * License along with this library; if not, write to the Free Software
29   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
30   */
31  
32  package org.opencms.scheduler;
33  
34  import org.opencms.main.CmsContextInfo;
35  import org.opencms.main.OpenCms;
36  import org.opencms.util.CmsStringUtil;
37  import org.opencms.util.CmsUUID;
38  
39  import java.util.ArrayList  ;
40  import java.util.Date  ;
41  import java.util.List  ;
42  import java.util.Properties  ;
43  
44  import junit.framework.TestCase;
45  
46  import org.quartz.CronTrigger;
47  import org.quartz.JobDataMap;
48  import org.quartz.JobDetail;
49  import org.quartz.Scheduler;
50  import org.quartz.SchedulerFactory;
51  import org.quartz.SimpleTrigger;
52  import org.quartz.impl.StdSchedulerFactory;
53  
54  /** 
55   * Test cases for the OpenCms scheduler thread pool.<p>
56   * 
57   * @author Alexander Kandzior 
58   * 
59   * @version $Revision: 1.17 $
60   * 
61   * @since 6.0.0
62   */
63  public class TestCmsScheduler extends TestCase {
64  
65      /** Number of seconds to wait. */
66      public static final int SECONDS_TO_WAIT = 30;
67  
68      /** Number of threads to run. */
69      public static final int THREADS_TO_RUN = 20;
70      
71      /**
72       * Default JUnit constructor.<p>
73       * 
74       * @param arg0 JUnit parameters
75       */
76      public TestCmsScheduler(String   arg0) {
77  
78          super(arg0);
79      }
80      
81      /**
82       * Tests activating and deactivating of scheduled jobs.<p>
83       *  
84       * @throws Exception if something goes wrong
85       */
86      public void testActivateAndDeactivateJob() throws Exception   {
87  
88          System.out.println("Trying to activate and deactivate an OpenCms job from the OpenCms scheduler.");
89          TestScheduledJob.m_runCount = 0;
90          // also make sure CmsUUID is initialized
91          CmsUUID.init(CmsUUID.getDummyEthernetAddress());
92          
93          CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
94          CmsContextInfo contextInfo = new CmsContextInfo();
95          contextInfo.setUserName(OpenCms.getDefaultUsers().getUserAdmin());
96          jobInfo.setContextInfo(contextInfo);
97          jobInfo.setClassName(TestScheduledJob.class.getName());          
98          jobInfo.setCronExpression("0/2 * * * * ?");
99          
100         // set this job as "not active"
101         jobInfo.setActive(false);
102                 
103         List   jobs = new ArrayList  ();
104         jobs.add(jobInfo);
105         // create the scheduler with the test job
106         CmsScheduleManager scheduler = new CmsScheduleManager(jobs);
107         
108         // initialize the manager, this will start the scheduled jobs
109         scheduler.initialize(null);
110         
111         int seconds = 0;
112         do {
113             try {
114                 Thread.sleep(1000);
115             } catch (InterruptedException   e) {
116                 fail("Something caused the waiting test thread to interrupt!");
117             }
118             seconds++;
119         } while (seconds < 5);
120 
121         // make sure the job was not run but still exists in the OpenCms scheduler
122         if (TestScheduledJob.m_runCount > 0) {
123             fail("Test job was incorrectly run '" + TestScheduledJob.m_runCount + "' times in OpenCms scheduler.");
124         }
125         assertEquals(1, scheduler.getJobs().size());
126         CmsScheduledJobInfo info = (CmsScheduledJobInfo)scheduler.getJobs().get(0);
127         assertEquals(jobInfo.getId(), info.getId());
128         assertEquals(jobInfo.getClassName(), info.getClassName());
129         assertEquals(false, info.isActive());
130         assertNull(info.getExecutionTimeNext());
131         
132         // no set the job active and re-schedule it
133         info = (CmsScheduledJobInfo)info.clone();
134         info.setActive(true);
135         scheduler.scheduleJob(null, info);
136         
137         seconds = 0;
138         do {
139             try {
140                 Thread.sleep(1000);
141             } catch (InterruptedException   e) {
142                 fail("Something caused the waiting test thread to interrupt!");
143             }
144             seconds++;
145         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 3));
146 
147         if (TestScheduledJob.m_runCount == 3) {
148             System.out.println("Test job was correctly run 3 times in OpenCms scheduler.");
149         } else {
150             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
151         }                        
152         
153         assertEquals(1, scheduler.getJobs().size());
154         info = (CmsScheduledJobInfo)scheduler.getJobs().get(0);
155         assertEquals(jobInfo.getId(), info.getId());
156         assertEquals(jobInfo.getClassName(), info.getClassName());
157         assertEquals(true, info.isActive());
158         assertNotNull(info.getExecutionTimeNext());
159         
160         // reset the count
161         TestScheduledJob.m_runCount = 0;
162 
163         // deactivate the job again and re-schedule it
164         info = (CmsScheduledJobInfo)info.clone();
165         info.setActive(false);
166         scheduler.scheduleJob(null, info);        
167         
168         seconds = 0;
169         do {
170             try {
171                 Thread.sleep(1000);
172             } catch (InterruptedException   e) {
173                 fail("Something caused the waiting test thread to interrupt!");
174             }
175             seconds++;
176         } while (seconds < 5);
177 
178         // make sure the job was not run but still exists in the OpenCms scheduler
179         if (TestScheduledJob.m_runCount > 0) {
180             fail("Test job was incorrectly run '" + TestScheduledJob.m_runCount + "' times in OpenCms scheduler.");
181         }
182         assertEquals(1, scheduler.getJobs().size());
183         info = (CmsScheduledJobInfo)scheduler.getJobs().get(0);
184         assertEquals(jobInfo.getId(), info.getId());
185         assertEquals(jobInfo.getClassName(), info.getClassName());
186         assertEquals(false, info.isActive());
187         assertNull(info.getExecutionTimeNext());
188         
189         // shutdown the scheduler
190         scheduler.shutDown();        
191     }   
192 
193     /**
194      * Tests adding and removing a job to the OpenCms schedule manager.<p>
195      *  
196      * @throws Exception if something goes wrong
197      */
198     public void testAddAndRemoveJobFromScheduler() throws Exception   {
199 
200         System.out.println("Trying to add and remove an OpenCms job from the OpenCms scheduler.");
201         TestScheduledJob.m_runCount = 0;
202         // also make sure CmsUUID is initialized
203         CmsUUID.init(CmsUUID.getDummyEthernetAddress());
204         
205         CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
206         CmsContextInfo contextInfo = new CmsContextInfo();
207         contextInfo.setUserName(OpenCms.getDefaultUsers().getUserAdmin());
208         jobInfo.setContextInfo(contextInfo);
209         jobInfo.setClassName(TestScheduledJob.class.getName());  
210         
211         jobInfo.setCronExpression("0/2 * * * * ?");
212                 
213         List   jobs = new ArrayList  ();
214         jobs.add(jobInfo);
215         // create the scheduler with the test job
216         CmsScheduleManager scheduler = new CmsScheduleManager(jobs);
217         
218         // initialize the manager, this will start the scheduled jobs
219         scheduler.initialize(null);
220         
221         int seconds = 0;
222         do {
223             try {
224                 Thread.sleep(1000);
225             } catch (InterruptedException   e) {
226                 fail("Something caused the waiting test thread to interrupt!");
227             }
228             seconds++;
229         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 3));
230 
231         if (TestScheduledJob.m_runCount == 3) {
232             System.out.println("Test job was correctly run 3 times in OpenCms scheduler.");
233         } else {
234             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
235         }
236         
237         CmsScheduledJobInfo result;
238         assertEquals(1, scheduler.getJobs().size());
239         result = scheduler.unscheduleJob(null, jobInfo.getId());
240         assertNotNull(result);
241         assertEquals(0, scheduler.getJobs().size());
242 
243         result = scheduler.unscheduleJob(null, "iDontExist");
244         assertNull(result);
245         
246         // shutdown the scheduler
247         scheduler.shutDown();        
248     }    
249     
250     /**
251      * Tests adding an existing job again to the OpenCms scheduler.<p>
252      *  
253      * @throws Exception if something goes wrong
254      */
255     public void testAddExistingJobAgainToScheduler() throws Exception   {
256 
257         System.out.println("Trying to schedule an existing job again with the OpenCms scheduler.");
258         TestScheduledJob.m_runCount = 0;
259         // also make sure CmsUUID is initialized
260         CmsUUID.init(CmsUUID.getDummyEthernetAddress());
261         
262         CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
263         CmsContextInfo contextInfo = new CmsContextInfo();
264         contextInfo.setUserName(OpenCms.getDefaultUsers().getUserAdmin());
265         jobInfo.setContextInfo(contextInfo);
266         jobInfo.setJobName("My job");
267         jobInfo.setClassName(TestScheduledJob.class.getName());  
268         
269         jobInfo.setCronExpression("0/2 * * * * ?");
270                 
271         List   jobs = new ArrayList  ();
272         jobs.add(jobInfo);
273         // create the scheduler with the test job
274         CmsScheduleManager scheduler = new CmsScheduleManager(jobs);
275         
276         // initialize the manager, this will start the scheduled jobs
277         scheduler.initialize(null);
278         
279         int seconds = 0;
280         do {
281             try {
282                 Thread.sleep(1000);
283             } catch (InterruptedException   e) {
284                 fail("Something caused the waiting test thread to interrupt!");
285             }
286             seconds++;
287         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 3));
288 
289         if (TestScheduledJob.m_runCount == 3) {
290             System.out.println("Test job was correctly run 3 times in OpenCms scheduler.");
291         } else {
292             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
293         }
294         
295         jobInfo = scheduler.getJob(jobInfo.getId());
296         assertEquals("My job", jobInfo.getJobName());
297         
298         CmsScheduledJobInfo newInfo = (CmsScheduledJobInfo)jobInfo.clone();
299         newInfo.setJobName("My CHANGED name");
300         newInfo.setActive(true);
301         assertEquals(1, scheduler.getJobs().size());
302         
303         // re-schedule the job with a different name
304         scheduler.scheduleJob(null, newInfo);
305         // size must still be the same
306         assertEquals(jobInfo.getId(), newInfo.getId());
307         assertEquals(1, scheduler.getJobs().size());        
308         jobInfo = scheduler.getJob(newInfo.getId());
309         assertEquals("My CHANGED name", jobInfo.getJobName());
310         
311         // change cron expression to something invalid
312         newInfo = (CmsScheduledJobInfo)jobInfo.clone();
313         newInfo.setActive(true);
314         newInfo.setCronExpression("* * * * * *");
315         assertEquals(1, scheduler.getJobs().size());
316         
317         CmsSchedulerException error = null;
318         try {
319             // re-schedule the job with a different name
320             scheduler.scheduleJob(null, newInfo); 
321         } catch (CmsSchedulerException e) {
322             error = e;
323         }
324         assertNotNull(error);
325         // ensure the job is still scheduled
326         assertEquals(1, scheduler.getJobs().size());        
327         
328         // shutdown the scheduler
329         scheduler.shutDown();        
330     }
331 
332     /**
333      * Tests execution of jobs using CmsSchedulerThreadPool.<p>
334      * 
335      * @throws Exception if something goes wrong
336      */
337     public void testBasicJobExecution() throws Exception   {
338 
339         System.out.println("Testing the OpenCms tread pool.");
340         Scheduler scheduler = initOpenCmsScheduler();        
341         
342         JobDetail[] jobDetail = new JobDetail[THREADS_TO_RUN];
343         SimpleTrigger[] trigger = new SimpleTrigger[THREADS_TO_RUN];
344 
345         for (int i = 0; i < jobDetail.length; i++) {
346             jobDetail[i] = new JobDetail(
347                 "myJob" + i, 
348                 Scheduler.DEFAULT_GROUP, 
349                 TestCmsJob.class);
350 
351             trigger[i] = new SimpleTrigger(
352                 "myTrigger" + i, 
353                 Scheduler.DEFAULT_GROUP, 
354                 new Date  (), 
355                 null, 
356                 0,
357                 0L);
358         }
359 
360         for (int i = 0; i < THREADS_TO_RUN; i++) {
361             scheduler.scheduleJob(jobDetail[i], trigger[i]);
362         }
363 
364         int seconds = 0;
365         do {
366             try {
367                 Thread.sleep(1000);
368             } catch (InterruptedException   e) {
369                 fail("Something caused the waiting test thread to interrupt!");
370             }
371             seconds++;
372         } while ((seconds < SECONDS_TO_WAIT) && (TestCmsJob.m_running > 0));
373 
374 
375         if (TestCmsJob.m_running <= 0) {
376             System.out.println("Success: All threads are finished.");
377         } else {
378             fail("Some threads in the pool are still running after " + SECONDS_TO_WAIT + " seconds.");
379         }
380         
381         scheduler.shutdown();        
382     }
383     
384     /**
385      * Tests launching of an OpenCms job.<p>
386      *  
387      * @throws Exception if something goes wrong
388      */
389     public void testCmsJobLaunch() throws Exception   {
390 
391         System.out.println("Trying to run an OpenCms job 5x.");
392         TestScheduledJob.m_runCount = 0;
393         
394         Scheduler scheduler = initOpenCmsScheduler();
395         
396         JobDetail jobDetail = new JobDetail(
397             "cmsLaunch",
398             Scheduler.DEFAULT_GROUP, 
399             CmsScheduleManager.class);
400         
401         CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
402         CmsContextInfo contextInfo = new CmsContextInfo(OpenCms.getDefaultUsers().getUserAdmin());
403         jobInfo.setContextInfo(contextInfo);
404         jobInfo.setClassName(TestScheduledJob.class.getName());  
405         
406         JobDataMap jobData = new JobDataMap();      
407         jobData.put(CmsScheduleManager.SCHEDULER_JOB_INFO, jobInfo);
408         
409         jobDetail.setJobDataMap(jobData);
410         
411         CronTrigger trigger = new CronTrigger("cmsLaunchTrigger", Scheduler.DEFAULT_GROUP);
412         
413         trigger.setCronExpression("0/2 * * * * ?");
414         
415         scheduler.scheduleJob(jobDetail, trigger);
416         
417         int seconds = 0;
418         do {
419             try {
420                 Thread.sleep(1000);
421             } catch (InterruptedException   e) {
422                 fail("Something caused the waiting test thread to interrupt!");
423             }
424             seconds++;
425         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 5));
426 
427 
428         if (TestScheduledJob.m_runCount == 5) {
429             System.out.println("Success: Test job was run 5 times.");
430         } else {
431             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
432         }
433        
434         scheduler.shutdown();        
435     }
436     
437     /**
438      * Tests launching of an OpenCms job with the OpenCms schedule manager.<p>
439      *  
440      * @throws Exception if something goes wrong
441      */
442     public void testJobInOpenCmsScheduler() throws Exception   {
443 
444         System.out.println("Trying to run an OpenCms job 5x with the OpenCms scheduler.");
445         TestScheduledJob.m_runCount = 0;
446         
447         CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
448         CmsContextInfo contextInfo = new CmsContextInfo();
449         contextInfo.setUserName(OpenCms.getDefaultUsers().getUserAdmin());
450         jobInfo.setContextInfo(contextInfo);
451         jobInfo.setClassName(TestScheduledJob.class.getName());  
452         
453         jobInfo.setCronExpression("0/2 * * * * ?");
454                 
455         List   jobs = new ArrayList  ();
456         jobs.add(jobInfo);
457         // create the scheduler with the test job
458         CmsScheduleManager scheduler = new CmsScheduleManager(jobs);
459         
460         // initialize the manager, this will start the scheduled jobs
461         scheduler.initialize(null);
462         
463         int seconds = 0;
464         do {
465             try {
466                 Thread.sleep(1000);
467             } catch (InterruptedException   e) {
468                 fail("Something caused the waiting test thread to interrupt!");
469             }
470             seconds++;
471         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 5));
472 
473         if (TestScheduledJob.m_runCount == 5) {
474             System.out.println("Test job was correctly run 5 times in OpenCms scheduler.");
475         } else {
476             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
477         }
478         
479         if (TestScheduledJob.m_instanceCountCopy == 1) {
480             System.out.println("Instance counter has correct value of 1.");
481         } else {
482             fail("Instance counter value of " + TestScheduledJob.m_instanceCountCopy + " invalid!");
483         }             
484        
485         // shutdown the scheduler
486         scheduler.shutDown();        
487     }         
488     
489     /**
490      * Tests launching of a persistent OpenCms job with the OpenCms schedule manager.<p>
491      *  
492      * @throws Exception if something goes wrong
493      */
494     public void testPersitentJobInOpenCmsScheduler() throws Exception   {
495 
496         System.out.println("Trying to run a persistent OpenCms job 5x with the OpenCms scheduler.");
497         TestScheduledJob.m_runCount = 0;
498         
499         CmsScheduledJobInfo jobInfo = new CmsScheduledJobInfo();
500         CmsContextInfo contextInfo = new CmsContextInfo(OpenCms.getDefaultUsers().getUserAdmin());
501         jobInfo.setContextInfo(contextInfo);
502         jobInfo.setClassName(TestScheduledJob.class.getName());
503         jobInfo.setReuseInstance(true);
504         jobInfo.setCronExpression("0/2 * * * * ?");
505         
506         List   jobs = new ArrayList  ();
507         jobs.add(jobInfo);
508         // create the scheduler with the test job
509         CmsScheduleManager scheduler = new CmsScheduleManager(jobs);
510         
511         // initialize the manager, this will start the scheduled jobs
512         scheduler.initialize(null);
513         
514         int seconds = 0;
515         do {
516             try {
517                 Thread.sleep(1000);
518             } catch (InterruptedException   e) {
519                 fail("Something caused the waiting test thread to interrupt!");
520             }
521             seconds++;
522         } while ((seconds < SECONDS_TO_WAIT) && (TestScheduledJob.m_runCount < 5));
523 
524 
525         if (TestScheduledJob.m_runCount == 5) {
526             System.out.println("Test job was correctly run 5 times in OpenCms scheduler.");
527         } else {
528             fail("Test class not run after " + SECONDS_TO_WAIT + " seconds.");
529         }
530         
531         if (TestScheduledJob.m_instanceCountCopy == 5) {
532             System.out.println("Instance counter was correctly incremented 5 times.");
533         } else {
534             fail("Instance counter was not incremented!");
535         }        
536        
537         // shutdown the scheduler
538         scheduler.shutDown();        
539     }
540     
541     /**
542      * Initializes a Quartz scheduler.<p>
543      * 
544      * @return the initialized scheduler
545      * @throws Exception in case something goes wrong
546      */
547     private Scheduler initOpenCmsScheduler() throws Exception    {
548         
549         Properties   properties = new Properties  ();
550         properties.put("org.quartz.scheduler.instanceName", "OpenCmsScheduler");
551         properties.put("org.quartz.scheduler.threadName", "OpenCms: Scheduler");
552         properties.put("org.quartz.scheduler.rmi.export", CmsStringUtil.FALSE);
553         properties.put("org.quartz.scheduler.rmi.proxy", CmsStringUtil.FALSE);
554         properties.put("org.quartz.scheduler.xaTransacted", CmsStringUtil.FALSE);
555         properties.put("org.quartz.threadPool.class", "org.opencms.scheduler.CmsSchedulerThreadPool");
556         properties.put("org.quartz.jobStore.misfireThreshold", "60000");
557         properties.put("org.quartz.jobStore.class", "org.quartz.simpl.RAMJobStore");
558 
559         SchedulerFactory schedulerFactory = new StdSchedulerFactory(properties);
560         Scheduler scheduler = schedulerFactory.getScheduler();
561 
562         scheduler.getMetaData();
563         scheduler.start();
564         
565         // also make sure CmsUUID is initialized
566         CmsUUID.init(CmsUUID.getDummyEthernetAddress());
567         
568         return scheduler;
569     }
570 }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags