Coverage Report - org.apache.camel.component.quartz.QuartzEndpoint
 
Classes in this File Line Coverage Branch Coverage Complexity
QuartzEndpoint
68% 
85% 
0
 
 1  
 /*
 2  
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3  
  * contributor license agreements.  See the NOTICE file distributed with
 4  
  * this work for additional information regarding copyright ownership.
 5  
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6  
  * (the "License"); you may not use this file except in compliance with
 7  
  * the License.  You may obtain a copy of the License at
 8  
  *
 9  
  *      http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 package org.apache.camel.component.quartz;
 18  
 
 19  
 import org.apache.camel.Processor;
 20  
 import org.apache.camel.Producer;
 21  
 import org.apache.camel.impl.DefaultEndpoint;
 22  
 import org.apache.camel.processor.loadbalancer.LoadBalancer;
 23  
 import org.apache.camel.processor.loadbalancer.RoundRobinLoadBalancer;
 24  
 import org.apache.camel.util.ObjectHelper;
 25  
 import org.apache.commons.logging.Log;
 26  
 import org.apache.commons.logging.LogFactory;
 27  
 import org.quartz.JobDetail;
 28  
 import org.quartz.JobExecutionContext;
 29  
 import org.quartz.JobExecutionException;
 30  
 import org.quartz.Scheduler;
 31  
 import org.quartz.SchedulerException;
 32  
 import org.quartz.Trigger;
 33  
 import org.quartz.SimpleTrigger;
 34  
 
 35  
 import java.util.Date;
 36  
 import java.util.Map;
 37  
 import java.util.Set;
 38  
 
 39  
 /**
 40  
  * A <a href="http://activemq.apache.org/quartz.html">Quartz Endpoint</a>
 41  
  *
 42  
  * @version $Revision:520964 $
 43  
  */
 44  1
 public class QuartzEndpoint extends DefaultEndpoint<QuartzExchange> {
 45  
     public static final String ENDPOINT_KEY = "org.apache.camel.quartz";
 46  1
     private static final transient Log log = LogFactory.getLog(QuartzEndpoint.class);
 47  
     private Scheduler scheduler;
 48  
     private LoadBalancer loadBalancer;
 49  
     private Trigger trigger;
 50  
     private JobDetail jobDetail;
 51  
     private boolean started;
 52  
 
 53  
     public QuartzEndpoint(String endpointUri, QuartzComponent component, Scheduler scheduler) {
 54  4
         super(endpointUri, component);
 55  4
         this.scheduler = scheduler;
 56  4
     }
 57  
 
 58  
     public void addTriggers(Map<Trigger, JobDetail> triggerMap) throws SchedulerException {
 59  0
         if (triggerMap != null) {
 60  0
             Set<Map.Entry<Trigger, JobDetail>> entries = triggerMap.entrySet();
 61  0
             for (Map.Entry<Trigger, JobDetail> entry : entries) {
 62  0
                 Trigger key = entry.getKey();
 63  0
                 JobDetail value = entry.getValue();
 64  0
                 ObjectHelper.notNull(key, "key");
 65  0
                 ObjectHelper.notNull(value, "value");
 66  
 
 67  0
                 addTrigger(key, value);
 68  0
             }
 69  
         }
 70  0
     }
 71  
 
 72  
     public void addTrigger(Trigger trigger, JobDetail detail) throws SchedulerException {
 73  
         // lets default the trigger name to the job name
 74  1
         if (trigger.getName() == null) {
 75  0
             trigger.setName(detail.getName());
 76  
         }
 77  
         // lets default the trigger group to the job group
 78  1
         if (trigger.getGroup() == null) {
 79  0
             trigger.setGroup(detail.getGroup());
 80  
         }
 81  
         // default start time to now if not specified
 82  1
         if (trigger.getStartTime() == null) {
 83  1
             trigger.setStartTime(new Date());
 84  
         }
 85  1
         detail.getJobDataMap().put(ENDPOINT_KEY, this);
 86  1
         Class jobClass = detail.getJobClass();
 87  1
         if (jobClass == null) {
 88  1
             detail.setJobClass(CamelJob.class);
 89  
         }
 90  1
         if (detail.getName() == null) {
 91  1
             detail.setName(getEndpointUri());
 92  
         }
 93  1
         getScheduler().scheduleJob(detail, trigger);
 94  1
     }
 95  
 
 96  
     public void removeTrigger(Trigger trigger, JobDetail jobDetail) throws SchedulerException {
 97  1
         getScheduler().unscheduleJob(trigger.getName(), trigger.getGroup());
 98  1
     }
 99  
 
 100  
     /**
 101  
      * This method is invoked when a Quartz job is fired.
 102  
      *
 103  
      * @param jobExecutionContext the Quartz Job context
 104  
      */
 105  
     public void onJobExecute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
 106  2
         if (log.isDebugEnabled()) {
 107  0
             log.debug("Firing Quartz Job with context: " + jobExecutionContext);
 108  
         }
 109  2
         QuartzExchange exchange = createExchange(jobExecutionContext);
 110  
         try {
 111  2
             getLoadBalancer().process(exchange);
 112  
         }
 113  0
         catch (JobExecutionException e) {
 114  0
             throw e;
 115  
         }
 116  0
         catch (Exception e) {
 117  0
             throw new JobExecutionException(e);
 118  2
         }
 119  2
     }
 120  
 
 121  
     public QuartzExchange createExchange() {
 122  0
         return new QuartzExchange(getContext(), null);
 123  
     }
 124  
 
 125  
     public QuartzExchange createExchange(JobExecutionContext jobExecutionContext) {
 126  2
         return new QuartzExchange(getContext(), jobExecutionContext);
 127  
     }
 128  
 
 129  
     public Producer<QuartzExchange> createProducer() throws Exception {
 130  0
         throw new UnsupportedOperationException("You cannot send messages to this endpoint");
 131  
     }
 132  
 
 133  
     public QuartzConsumer createConsumer(Processor processor) throws Exception {
 134  1
         return new QuartzConsumer(this, processor);
 135  
     }
 136  
 
 137  
     // Properties
 138  
     //-------------------------------------------------------------------------
 139  
 
 140  
     @Override
 141  
     public QuartzComponent getComponent() {
 142  0
         return (QuartzComponent) super.getComponent();
 143  
     }
 144  
 
 145  
     public boolean isSingleton() {
 146  4
         return true;
 147  
     }
 148  
 
 149  
     public Scheduler getScheduler() {
 150  2
         return scheduler;
 151  
     }
 152  
 
 153  
     public LoadBalancer getLoadBalancer() {
 154  5
         if (loadBalancer == null) {
 155  1
             loadBalancer = createLoadBalancer();
 156  
         }
 157  5
         return loadBalancer;
 158  
     }
 159  
 
 160  
     public void setLoadBalancer(LoadBalancer loadBalancer) {
 161  0
         this.loadBalancer = loadBalancer;
 162  0
     }
 163  
 
 164  
     public JobDetail getJobDetail() {
 165  6
         if (jobDetail == null) {
 166  4
             jobDetail = createJobDetail();
 167  
         }
 168  6
         return jobDetail;
 169  
     }
 170  
 
 171  
     public void setJobDetail(JobDetail jobDetail) {
 172  0
         this.jobDetail = jobDetail;
 173  0
     }
 174  
 
 175  
     public Trigger getTrigger() {
 176  8
         if (trigger == null) {
 177  3
             trigger = createTrigger();
 178  
         }
 179  8
         return trigger;
 180  
     }
 181  
 
 182  
     public void setTrigger(Trigger trigger) {
 183  1
         this.trigger = trigger;
 184  1
     }
 185  
 
 186  
     // Implementation methods
 187  
     //-------------------------------------------------------------------------
 188  
     public synchronized void consumerStarted(QuartzConsumer consumer) throws SchedulerException {
 189  1
         getLoadBalancer().addProcessor(consumer.getProcessor());
 190  
 
 191  
         // if we have not yet added our default trigger, then lets do it
 192  1
         if (!started) {
 193  1
             addTrigger(getTrigger(), getJobDetail());
 194  1
             started = true;
 195  
         }
 196  1
     }
 197  
 
 198  
     public synchronized void consumerStopped(QuartzConsumer consumer) throws SchedulerException {
 199  1
         getLoadBalancer().removeProcessor(consumer.getProcessor());
 200  1
         if (getLoadBalancer().getProcessors().isEmpty() && started) {
 201  1
             removeTrigger(getTrigger(), getJobDetail());
 202  1
             started = false;
 203  
         }
 204  1
     }
 205  
 
 206  
     protected LoadBalancer createLoadBalancer() {
 207  1
         return new RoundRobinLoadBalancer();
 208  
     }
 209  
 
 210  
     protected JobDetail createJobDetail() {
 211  4
         return new JobDetail();
 212  
     }
 213  
 
 214  
     protected Trigger createTrigger() {
 215  3
         return new SimpleTrigger();
 216  
     }
 217  
 }