| package org.apache.openejb.quartz.core; |
| |
| import static org.apache.openejb.quartz.JobKey.jobKey; |
| import static org.apache.openejb.quartz.TriggerKey.triggerKey; |
| |
| import java.beans.BeanInfo; |
| import java.beans.IntrospectionException; |
| import java.beans.Introspector; |
| import java.beans.MethodDescriptor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicLong; |
| |
| import javax.management.ListenerNotFoundException; |
| import javax.management.MBeanNotificationInfo; |
| import javax.management.NotCompliantMBeanException; |
| import javax.management.Notification; |
| import javax.management.NotificationBroadcasterSupport; |
| import javax.management.NotificationEmitter; |
| import javax.management.NotificationFilter; |
| import javax.management.NotificationListener; |
| import javax.management.StandardMBean; |
| import javax.management.openmbean.CompositeData; |
| import javax.management.openmbean.TabularData; |
| |
| import org.apache.openejb.quartz.JobDataMap; |
| import org.apache.openejb.quartz.JobDetail; |
| import org.apache.openejb.quartz.JobExecutionContext; |
| import org.apache.openejb.quartz.JobExecutionException; |
| import org.apache.openejb.quartz.JobKey; |
| import org.apache.openejb.quartz.JobListener; |
| import org.apache.openejb.quartz.SchedulerException; |
| import org.apache.openejb.quartz.SchedulerListener; |
| import org.apache.openejb.quartz.Trigger; |
| import org.apache.openejb.quartz.Trigger.TriggerState; |
| import org.apache.openejb.quartz.TriggerKey; |
| import org.apache.openejb.quartz.core.jmx.JobDetailSupport; |
| import org.apache.openejb.quartz.core.jmx.JobExecutionContextSupport; |
| import org.apache.openejb.quartz.core.jmx.QuartzSchedulerMBean; |
| import org.apache.openejb.quartz.core.jmx.TriggerSupport; |
| import org.apache.openejb.quartz.impl.matchers.GroupMatcher; |
| import org.apache.openejb.quartz.impl.triggers.AbstractTrigger; |
| import org.apache.openejb.quartz.spi.OperableTrigger; |
| |
| public class QuartzSchedulerMBeanImpl extends StandardMBean implements |
| NotificationEmitter, QuartzSchedulerMBean, JobListener, |
| SchedulerListener { |
| private static final MBeanNotificationInfo[] NOTIFICATION_INFO; |
| |
| private final QuartzScheduler scheduler; |
| private boolean sampledStatisticsEnabled; |
| private SampledStatistics sampledStatistics; |
| |
| private final static SampledStatistics NULL_SAMPLED_STATISTICS = new NullSampledStatisticsImpl(); |
| |
| static { |
| final String[] notifTypes = new String[] { SCHEDULER_STARTED, |
| SCHEDULER_PAUSED, SCHEDULER_SHUTDOWN, }; |
| final String name = Notification.class.getName(); |
| final String description = "QuartzScheduler JMX Event"; |
| NOTIFICATION_INFO = new MBeanNotificationInfo[] { new MBeanNotificationInfo( |
| notifTypes, name, description), }; |
| } |
| |
| /** |
| * emitter |
| */ |
| protected final Emitter emitter = new Emitter(); |
| |
| /** |
| * sequenceNumber |
| */ |
| protected final AtomicLong sequenceNumber = new AtomicLong(); |
| |
| /** |
| * QuartzSchedulerMBeanImpl |
| * |
| * @throws NotCompliantMBeanException |
| */ |
| protected QuartzSchedulerMBeanImpl(QuartzScheduler scheduler) |
| throws NotCompliantMBeanException { |
| super(QuartzSchedulerMBean.class); |
| this.scheduler = scheduler; |
| this.scheduler.addInternalJobListener(this); |
| this.scheduler.addInternalSchedulerListener(this); |
| this.sampledStatistics = NULL_SAMPLED_STATISTICS; |
| this.sampledStatisticsEnabled = false; |
| } |
| |
| public TabularData getCurrentlyExecutingJobs() throws Exception { |
| try { |
| List<JobExecutionContext> currentlyExecutingJobs = scheduler.getCurrentlyExecutingJobs(); |
| return JobExecutionContextSupport.toTabularData(currentlyExecutingJobs); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public TabularData getAllJobDetails() throws Exception { |
| try { |
| List<JobDetail> detailList = new ArrayList<JobDetail>(); |
| for (String jobGroupName : scheduler.getJobGroupNames()) { |
| for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(jobGroupName))) { |
| detailList.add(scheduler.getJobDetail(jobKey)); |
| } |
| } |
| return JobDetailSupport.toTabularData(detailList.toArray(new JobDetail[detailList.size()])); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<CompositeData> getAllTriggers() throws Exception { |
| try { |
| List<Trigger> triggerList = new ArrayList<Trigger>(); |
| for (String triggerGroupName : scheduler.getTriggerGroupNames()) { |
| for (TriggerKey triggerKey : scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(triggerGroupName))) { |
| triggerList.add(scheduler.getTrigger(triggerKey)); |
| } |
| } |
| return TriggerSupport.toCompositeList(triggerList); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void addJob(CompositeData jobDetail, boolean replace) throws Exception { |
| try { |
| scheduler.addJob(JobDetailSupport.newJobDetail(jobDetail), replace); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| private static void invokeSetter(Object target, String attribute, Object value) throws Exception { |
| String setterName = "set" + Character.toUpperCase(attribute.charAt(0)) + attribute.substring(1); |
| Class<?>[] argTypes = {value.getClass()}; |
| Method setter = findMethod(target.getClass(), setterName, argTypes); |
| if(setter != null) { |
| setter.invoke(target, value); |
| } else { |
| throw new Exception("Unable to find setter for attribute '" + attribute |
| + "' and value '" + value + "'"); |
| } |
| } |
| |
| private static Class<?> getWrapperIfPrimitive(Class<?> c) { |
| Class<?> result = c; |
| try { |
| Field f = c.getField("TYPE"); |
| f.setAccessible(true); |
| result = (Class<?>) f.get(null); |
| } catch (Exception e) { |
| /**/ |
| } |
| return result; |
| } |
| |
| private static Method findMethod(Class<?> targetType, String methodName, |
| Class<?>[] argTypes) throws IntrospectionException { |
| BeanInfo beanInfo = Introspector.getBeanInfo(targetType); |
| if (beanInfo != null) { |
| for(MethodDescriptor methodDesc: beanInfo.getMethodDescriptors()) { |
| Method method = methodDesc.getMethod(); |
| Class<?>[] parameterTypes = method.getParameterTypes(); |
| if (methodName.equals(method.getName()) && argTypes.length == parameterTypes.length) { |
| boolean matchedArgTypes = true; |
| for (int i = 0; i < argTypes.length; i++) { |
| if (getWrapperIfPrimitive(argTypes[i]) != parameterTypes[i]) { |
| matchedArgTypes = false; |
| break; |
| } |
| } |
| if (matchedArgTypes) { |
| return method; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| public void scheduleBasicJob(Map<String, Object> jobDetailInfo, |
| Map<String, Object> triggerInfo) throws Exception { |
| try { |
| JobDetail jobDetail = JobDetailSupport.newJobDetail(jobDetailInfo); |
| OperableTrigger trigger = TriggerSupport.newTrigger(triggerInfo); |
| scheduler.deleteJob(jobDetail.getKey()); |
| scheduler.scheduleJob(jobDetail, trigger); |
| } catch (ParseException pe) { |
| throw pe; |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void scheduleJob(Map<String, Object> abstractJobInfo, |
| Map<String, Object> abstractTriggerInfo) throws Exception { |
| try { |
| String triggerClassName = (String) abstractTriggerInfo.remove("triggerClass"); |
| if(triggerClassName == null) { |
| throw new IllegalArgumentException("No triggerClass specified"); |
| } |
| Class<?> triggerClass = Class.forName(triggerClassName); |
| Trigger trigger = (Trigger) triggerClass.newInstance(); |
| |
| String jobDetailClassName = (String) abstractJobInfo.remove("jobDetailClass"); |
| if(jobDetailClassName == null) { |
| throw new IllegalArgumentException("No jobDetailClass specified"); |
| } |
| Class<?> jobDetailClass = Class.forName(jobDetailClassName); |
| JobDetail jobDetail = (JobDetail) jobDetailClass.newInstance(); |
| |
| String jobClassName = (String) abstractJobInfo.remove("jobClass"); |
| if(jobClassName == null) { |
| throw new IllegalArgumentException("No jobClass specified"); |
| } |
| Class<?> jobClass = Class.forName(jobClassName); |
| abstractJobInfo.put("jobClass", jobClass); |
| |
| for(Map.Entry<String, Object> entry : abstractTriggerInfo.entrySet()) { |
| String key = entry.getKey(); |
| Object value = entry.getValue(); |
| if("jobDataMap".equals(key)) { |
| value = new JobDataMap((Map<?, ?>)value); |
| } |
| invokeSetter(trigger, key, value); |
| } |
| |
| for(Map.Entry<String, Object> entry : abstractJobInfo.entrySet()) { |
| String key = entry.getKey(); |
| Object value = entry.getValue(); |
| if("jobDataMap".equals(key)) { |
| value = new JobDataMap((Map<?, ?>)value); |
| } |
| invokeSetter(jobDetail, key, value); |
| } |
| |
| AbstractTrigger<?> at = (AbstractTrigger<?>)trigger; |
| at.setKey(new TriggerKey(at.getName(), at.getGroup())); |
| |
| Date startDate = at.getStartTime(); |
| if(startDate == null || startDate.before(new Date())) { |
| at.setStartTime(new Date()); |
| } |
| |
| scheduler.deleteJob(jobDetail.getKey()); |
| scheduler.scheduleJob(jobDetail, trigger); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void scheduleJob(String jobName, String jobGroup, |
| Map<String, Object> abstractTriggerInfo) throws Exception { |
| try { |
| JobKey jobKey = new JobKey(jobName, jobGroup); |
| JobDetail jobDetail = scheduler.getJobDetail(jobKey); |
| if(jobDetail == null) { |
| throw new IllegalArgumentException("No such job '" + jobKey + "'"); |
| } |
| |
| String triggerClassName = (String) abstractTriggerInfo.remove("triggerClass"); |
| if(triggerClassName == null) { |
| throw new IllegalArgumentException("No triggerClass specified"); |
| } |
| Class<?> triggerClass = Class.forName(triggerClassName); |
| Trigger trigger = (Trigger) triggerClass.newInstance(); |
| |
| for(Map.Entry<String, Object> entry : abstractTriggerInfo.entrySet()) { |
| String key = entry.getKey(); |
| Object value = entry.getValue(); |
| if("jobDataMap".equals(key)) { |
| value = new JobDataMap((Map<?, ?>)value); |
| } |
| invokeSetter(trigger, key, value); |
| } |
| |
| AbstractTrigger<?> at = (AbstractTrigger<?>)trigger; |
| at.setKey(new TriggerKey(at.getName(), at.getGroup())); |
| |
| Date startDate = at.getStartTime(); |
| if(startDate == null || startDate.before(new Date())) { |
| at.setStartTime(new Date()); |
| } |
| |
| scheduler.scheduleJob(trigger); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void addJob(Map<String, Object> abstractJobInfo, boolean replace) throws Exception { |
| try { |
| String jobDetailClassName = (String) abstractJobInfo.remove("jobDetailClass"); |
| if(jobDetailClassName == null) { |
| throw new IllegalArgumentException("No jobDetailClass specified"); |
| } |
| Class<?> jobDetailClass = Class.forName(jobDetailClassName); |
| JobDetail jobDetail = (JobDetail) jobDetailClass.newInstance(); |
| |
| String jobClassName = (String) abstractJobInfo.remove("jobClass"); |
| if(jobClassName == null) { |
| throw new IllegalArgumentException("No jobClass specified"); |
| } |
| Class<?> jobClass = Class.forName(jobClassName); |
| abstractJobInfo.put("jobClass", jobClass); |
| |
| for(Map.Entry<String, Object> entry : abstractJobInfo.entrySet()) { |
| String key = entry.getKey(); |
| Object value = entry.getValue(); |
| if("jobDataMap".equals(key)) { |
| value = new JobDataMap((Map<?, ?>)value); |
| } |
| invokeSetter(jobDetail, key, value); |
| } |
| |
| scheduler.addJob(jobDetail, replace); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| private Exception newPlainException(Exception e) { |
| String type = e.getClass().getName(); |
| if(type.startsWith("java.") || type.startsWith("javax.") || type.startsWith("jakarta.")) { |
| return e; |
| } else { |
| Exception result = new Exception(e.getMessage()); |
| result.setStackTrace(e.getStackTrace()); |
| return result; |
| } |
| } |
| |
| public void deleteCalendar(String calendarName) throws Exception { |
| try { |
| scheduler.deleteCalendar(calendarName); |
| } catch(Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public boolean deleteJob(String jobName, String jobGroupName) throws Exception { |
| try { |
| return scheduler.deleteJob(jobKey(jobName, jobGroupName)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<String> getCalendarNames() throws Exception { |
| try { |
| return scheduler.getCalendarNames(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public CompositeData getJobDetail(String jobName, String jobGroupName) |
| throws Exception { |
| try { |
| JobDetail jobDetail = scheduler.getJobDetail(jobKey(jobName, jobGroupName)); |
| return JobDetailSupport.toCompositeData(jobDetail); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<String> getJobGroupNames() throws Exception { |
| try { |
| return scheduler.getJobGroupNames(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<String> getJobNames(String groupName) throws Exception { |
| try { |
| List<String> jobNames = new ArrayList<String>(); |
| for(JobKey key: scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) { |
| jobNames.add(key.getName()); |
| } |
| return jobNames; |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public String getJobStoreClassName() { |
| return scheduler.getJobStoreClass().getName(); |
| } |
| |
| public Set<String> getPausedTriggerGroups() throws Exception { |
| try { |
| return scheduler.getPausedTriggerGroups(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public CompositeData getTrigger(String name, String groupName) throws Exception { |
| try { |
| Trigger trigger = scheduler.getTrigger(triggerKey(name, groupName)); |
| return TriggerSupport.toCompositeData(trigger); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<String> getTriggerGroupNames() throws Exception { |
| try { |
| return scheduler.getTriggerGroupNames(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<String> getTriggerNames(String groupName) throws Exception { |
| try { |
| List<String> triggerNames = new ArrayList<String>(); |
| for(TriggerKey key: scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(groupName))) { |
| triggerNames.add(key.getName()); |
| } |
| return triggerNames; |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public String getTriggerState(String triggerName, String triggerGroupName) throws Exception { |
| try { |
| TriggerKey triggerKey = triggerKey(triggerName, triggerGroupName); |
| TriggerState ts = scheduler.getTriggerState(triggerKey); |
| return ts.name(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public List<CompositeData> getTriggersOfJob(String jobName, String jobGroupName) throws Exception { |
| try { |
| JobKey jobKey = jobKey(jobName, jobGroupName); |
| return TriggerSupport.toCompositeList(scheduler.getTriggersOfJob(jobKey)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public boolean interruptJob(String jobName, String jobGroupName) throws Exception { |
| try { |
| return scheduler.interrupt(jobKey(jobName, jobGroupName)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public boolean interruptJob(String fireInstanceId) throws Exception { |
| try { |
| return scheduler.interrupt(fireInstanceId); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public Date scheduleJob(String jobName, String jobGroup, |
| String triggerName, String triggerGroup) throws Exception { |
| try { |
| JobKey jobKey = jobKey(jobName, jobGroup); |
| JobDetail jobDetail = scheduler.getJobDetail(jobKey); |
| if (jobDetail == null) { |
| throw new IllegalArgumentException("No such job: " + jobKey); |
| } |
| TriggerKey triggerKey = triggerKey(triggerName, triggerGroup); |
| Trigger trigger = scheduler.getTrigger(triggerKey); |
| if (trigger == null) { |
| throw new IllegalArgumentException("No such trigger: " + triggerKey); |
| } |
| return scheduler.scheduleJob(jobDetail, trigger); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public boolean unscheduleJob(String triggerName, String triggerGroup) throws Exception { |
| try { |
| return scheduler.unscheduleJob(triggerKey(triggerName, triggerGroup)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void clear() throws Exception { |
| try { |
| scheduler.clear(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public String getVersion() { |
| return scheduler.getVersion(); |
| } |
| |
| public boolean isShutdown() { |
| return scheduler.isShutdown(); |
| } |
| |
| public boolean isStarted() { |
| return scheduler.isStarted(); |
| } |
| |
| public void start() throws Exception { |
| try { |
| scheduler.start(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void shutdown() { |
| scheduler.shutdown(); |
| } |
| |
| public void standby() { |
| scheduler.standby(); |
| } |
| |
| public boolean isStandbyMode() { |
| return scheduler.isInStandbyMode(); |
| } |
| |
| public String getSchedulerName() { |
| return scheduler.getSchedulerName(); |
| } |
| |
| public String getSchedulerInstanceId() { |
| return scheduler.getSchedulerInstanceId(); |
| } |
| |
| public String getThreadPoolClassName() { |
| return scheduler.getThreadPoolClass().getName(); |
| } |
| |
| public int getThreadPoolSize() { |
| return scheduler.getThreadPoolSize(); |
| } |
| |
| public void pauseJob(String jobName, String jobGroup) throws Exception { |
| try { |
| scheduler.pauseJob(jobKey(jobName, jobGroup)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void pauseJobs(GroupMatcher<JobKey> matcher) throws Exception { |
| try { |
| scheduler.pauseJobs(matcher); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void pauseJobGroup(String jobGroup) throws Exception { |
| pauseJobs(GroupMatcher.<JobKey>groupEquals(jobGroup)); |
| } |
| |
| public void pauseJobsStartingWith(String jobGroupPrefix) throws Exception { |
| pauseJobs(GroupMatcher.<JobKey>groupStartsWith(jobGroupPrefix)); |
| } |
| |
| public void pauseJobsEndingWith(String jobGroupSuffix) throws Exception { |
| pauseJobs(GroupMatcher.<JobKey>groupEndsWith(jobGroupSuffix)); |
| } |
| |
| public void pauseJobsContaining(String jobGroupToken) throws Exception { |
| pauseJobs(GroupMatcher.<JobKey>groupContains(jobGroupToken)); |
| } |
| |
| public void pauseJobsAll() throws Exception { |
| pauseJobs(GroupMatcher.anyJobGroup()); |
| } |
| |
| public void pauseAllTriggers() throws Exception { |
| try { |
| scheduler.pauseAll(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| private void pauseTriggers(GroupMatcher<TriggerKey> matcher) throws Exception { |
| try { |
| scheduler.pauseTriggers(matcher); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void pauseTriggerGroup(String triggerGroup) throws Exception { |
| pauseTriggers(GroupMatcher.<TriggerKey>groupEquals(triggerGroup)); |
| } |
| |
| public void pauseTriggersStartingWith(String triggerGroupPrefix) throws Exception { |
| pauseTriggers(GroupMatcher.<TriggerKey>groupStartsWith(triggerGroupPrefix)); |
| } |
| |
| public void pauseTriggersEndingWith(String triggerGroupSuffix) throws Exception { |
| pauseTriggers(GroupMatcher.<TriggerKey>groupEndsWith(triggerGroupSuffix)); |
| } |
| |
| public void pauseTriggersContaining(String triggerGroupToken) throws Exception { |
| pauseTriggers(GroupMatcher.<TriggerKey>groupContains(triggerGroupToken)); |
| } |
| |
| public void pauseTriggersAll() throws Exception { |
| pauseTriggers(GroupMatcher.anyTriggerGroup()); |
| } |
| |
| public void pauseTrigger(String triggerName, String triggerGroup) throws Exception { |
| try { |
| scheduler.pauseTrigger(triggerKey(triggerName, triggerGroup)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void resumeAllTriggers() throws Exception { |
| try { |
| scheduler.resumeAll(); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void resumeJob(String jobName, String jobGroup) throws Exception { |
| try { |
| scheduler.resumeJob(jobKey(jobName, jobGroup)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void resumeJobs(GroupMatcher<JobKey> matcher) throws Exception { |
| try { |
| scheduler.resumeJobs(matcher); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void resumeJobGroup(String jobGroup) throws Exception { |
| resumeJobs(GroupMatcher.<JobKey>groupEquals(jobGroup)); |
| } |
| |
| public void resumeJobsStartingWith(String jobGroupPrefix) throws Exception { |
| resumeJobs(GroupMatcher.<JobKey>groupStartsWith(jobGroupPrefix)); |
| } |
| |
| public void resumeJobsEndingWith(String jobGroupSuffix) throws Exception { |
| resumeJobs(GroupMatcher.<JobKey>groupEndsWith(jobGroupSuffix)); |
| } |
| |
| public void resumeJobsContaining(String jobGroupToken) throws Exception { |
| resumeJobs(GroupMatcher.<JobKey>groupContains(jobGroupToken)); |
| } |
| |
| public void resumeJobsAll() throws Exception { |
| resumeJobs(GroupMatcher.anyJobGroup()); |
| } |
| |
| public void resumeTrigger(String triggerName, String triggerGroup) throws Exception { |
| try { |
| scheduler.resumeTrigger(triggerKey(triggerName, triggerGroup)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| private void resumeTriggers(GroupMatcher<TriggerKey> matcher) throws Exception { |
| try { |
| scheduler.resumeTriggers(matcher); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void resumeTriggerGroup(String triggerGroup) throws Exception { |
| resumeTriggers(GroupMatcher.<TriggerKey>groupEquals(triggerGroup)); |
| } |
| |
| public void resumeTriggersStartingWith(String triggerGroupPrefix) throws Exception { |
| resumeTriggers(GroupMatcher.<TriggerKey>groupStartsWith(triggerGroupPrefix)); |
| } |
| |
| public void resumeTriggersEndingWith(String triggerGroupSuffix) throws Exception { |
| resumeTriggers(GroupMatcher.<TriggerKey>groupEndsWith(triggerGroupSuffix)); |
| } |
| |
| public void resumeTriggersContaining(String triggerGroupToken) throws Exception { |
| resumeTriggers(GroupMatcher.<TriggerKey>groupContains(triggerGroupToken)); |
| } |
| |
| public void resumeTriggersAll() throws Exception { |
| resumeTriggers(GroupMatcher.anyTriggerGroup()); |
| } |
| |
| public void triggerJob(String jobName, String jobGroup, Map<String, String> jobDataMap) |
| throws Exception { |
| try { |
| scheduler.triggerJob(jobKey(jobName, jobGroup), new JobDataMap(jobDataMap)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| public void triggerJob(CompositeData trigger) throws Exception { |
| try { |
| scheduler.triggerJob(TriggerSupport.newTrigger(trigger)); |
| } catch (Exception e) { |
| throw newPlainException(e); |
| } |
| } |
| |
| // ScheduleListener |
| |
| public void jobAdded(JobDetail jobDetail) { |
| sendNotification(JOB_ADDED, JobDetailSupport.toCompositeData(jobDetail)); |
| } |
| |
| public void jobDeleted(JobKey jobKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("jobName", jobKey.getName()); |
| map.put("jobGroup", jobKey.getGroup()); |
| sendNotification(JOB_DELETED, map); |
| } |
| |
| public void jobScheduled(Trigger trigger) { |
| sendNotification(JOB_SCHEDULED, TriggerSupport.toCompositeData(trigger)); |
| } |
| |
| public void jobUnscheduled(TriggerKey triggerKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("triggerName", triggerKey.getName()); |
| map.put("triggerGroup", triggerKey.getGroup()); |
| sendNotification(JOB_UNSCHEDULED, map); |
| } |
| |
| public void schedulingDataCleared() { |
| sendNotification(SCHEDULING_DATA_CLEARED); |
| } |
| |
| public void jobPaused(JobKey jobKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("jobName", jobKey.getName()); |
| map.put("jobGroup", jobKey.getGroup()); |
| sendNotification(JOBS_PAUSED, map); |
| } |
| |
| public void jobsPaused(String jobGroup) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("jobName", null); |
| map.put("jobGroup", jobGroup); |
| sendNotification(JOBS_PAUSED, map); |
| } |
| |
| public void jobsResumed(String jobGroup) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("jobName", null); |
| map.put("jobGroup", jobGroup); |
| sendNotification(JOBS_RESUMED, map); |
| } |
| |
| public void jobResumed(JobKey jobKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("jobName", jobKey.getName()); |
| map.put("jobGroup", jobKey.getGroup()); |
| sendNotification(JOBS_RESUMED, map); |
| } |
| |
| public void schedulerError(String msg, SchedulerException cause) { |
| sendNotification(SCHEDULER_ERROR, cause.getMessage()); |
| } |
| |
| public void schedulerStarted() { |
| sendNotification(SCHEDULER_STARTED); |
| } |
| |
| //not doing anything, just like schedulerShuttingdown |
| public void schedulerStarting() { |
| } |
| |
| public void schedulerInStandbyMode() { |
| sendNotification(SCHEDULER_PAUSED); |
| } |
| |
| public void schedulerShutdown() { |
| scheduler.removeInternalSchedulerListener(this); |
| scheduler.removeInternalJobListener(getName()); |
| |
| sendNotification(SCHEDULER_SHUTDOWN); |
| } |
| |
| public void schedulerShuttingdown() { |
| } |
| |
| public void triggerFinalized(Trigger trigger) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("triggerName", trigger.getKey().getName()); |
| map.put("triggerGroup", trigger.getKey().getGroup()); |
| sendNotification(TRIGGER_FINALIZED, map); |
| } |
| |
| public void triggersPaused(String triggerGroup) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("triggerName", null); |
| map.put("triggerGroup", triggerGroup); |
| sendNotification(TRIGGERS_PAUSED, map); |
| } |
| |
| public void triggerPaused(TriggerKey triggerKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| if(triggerKey != null) { |
| map.put("triggerName", triggerKey.getName()); |
| map.put("triggerGroup", triggerKey.getGroup()); |
| } |
| sendNotification(TRIGGERS_PAUSED, map); |
| } |
| |
| public void triggersResumed(String triggerGroup) { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("triggerName", null); |
| map.put("triggerGroup", triggerGroup); |
| sendNotification(TRIGGERS_RESUMED, map); |
| } |
| |
| public void triggerResumed(TriggerKey triggerKey) { |
| Map<String, String> map = new HashMap<String, String>(); |
| if(triggerKey != null) { |
| map.put("triggerName", triggerKey.getName()); |
| map.put("triggerGroup", triggerKey.getGroup()); |
| } |
| sendNotification(TRIGGERS_RESUMED, map); |
| } |
| |
| // JobListener |
| |
| public String getName() { |
| return "QuartzSchedulerMBeanImpl.listener"; |
| } |
| |
| public void jobExecutionVetoed(JobExecutionContext context) { |
| try { |
| sendNotification(JOB_EXECUTION_VETOED, JobExecutionContextSupport |
| .toCompositeData(context)); |
| } catch (Exception e) { |
| throw new RuntimeException(newPlainException(e)); |
| } |
| } |
| |
| public void jobToBeExecuted(JobExecutionContext context) { |
| try { |
| sendNotification(JOB_TO_BE_EXECUTED, JobExecutionContextSupport |
| .toCompositeData(context)); |
| } catch (Exception e) { |
| throw new RuntimeException(newPlainException(e)); |
| } |
| } |
| |
| public void jobWasExecuted(JobExecutionContext context, |
| JobExecutionException jobException) { |
| try { |
| sendNotification(JOB_WAS_EXECUTED, JobExecutionContextSupport |
| .toCompositeData(context)); |
| } catch (Exception e) { |
| throw new RuntimeException(newPlainException(e)); |
| } |
| } |
| |
| // NotificationBroadcaster |
| |
| /** |
| * sendNotification |
| * |
| * @param eventType |
| */ |
| public void sendNotification(String eventType) { |
| sendNotification(eventType, null, null); |
| } |
| |
| /** |
| * sendNotification |
| * |
| * @param eventType |
| * @param data |
| */ |
| public void sendNotification(String eventType, Object data) { |
| sendNotification(eventType, data, null); |
| } |
| |
| /** |
| * sendNotification |
| * |
| * @param eventType |
| * @param data |
| * @param msg |
| */ |
| public void sendNotification(String eventType, Object data, String msg) { |
| Notification notif = new Notification(eventType, this, sequenceNumber |
| .incrementAndGet(), System.currentTimeMillis(), msg); |
| if (data != null) { |
| notif.setUserData(data); |
| } |
| emitter.sendNotification(notif); |
| } |
| |
| /** |
| * @author gkeim |
| */ |
| private class Emitter extends NotificationBroadcasterSupport { |
| /** |
| * @see javax.management.NotificationBroadcasterSupport#getNotificationInfo() |
| */ |
| @Override |
| public MBeanNotificationInfo[] getNotificationInfo() { |
| return QuartzSchedulerMBeanImpl.this.getNotificationInfo(); |
| } |
| } |
| |
| /** |
| * @see javax.management.NotificationBroadcaster#addNotificationListener(javax.management.NotificationListener, |
| * javax.management.NotificationFilter, java.lang.Object) |
| */ |
| public void addNotificationListener(NotificationListener notif, |
| NotificationFilter filter, Object callBack) { |
| emitter.addNotificationListener(notif, filter, callBack); |
| } |
| |
| /** |
| * @see javax.management.NotificationBroadcaster#getNotificationInfo() |
| */ |
| public MBeanNotificationInfo[] getNotificationInfo() { |
| return NOTIFICATION_INFO; |
| } |
| |
| /** |
| * @see javax.management.NotificationBroadcaster#removeNotificationListener(javax.management.NotificationListener) |
| */ |
| public void removeNotificationListener(NotificationListener listener) |
| throws ListenerNotFoundException { |
| emitter.removeNotificationListener(listener); |
| } |
| |
| /** |
| * @see javax.management.NotificationEmitter#removeNotificationListener(javax.management.NotificationListener, |
| * javax.management.NotificationFilter, java.lang.Object) |
| */ |
| public void removeNotificationListener(NotificationListener notif, |
| NotificationFilter filter, Object callBack) |
| throws ListenerNotFoundException { |
| emitter.removeNotificationListener(notif, filter, callBack); |
| } |
| |
| public synchronized boolean isSampledStatisticsEnabled() { |
| return sampledStatisticsEnabled; |
| } |
| |
| public void setSampledStatisticsEnabled(boolean enabled) { |
| if (enabled != this.sampledStatisticsEnabled) { |
| this.sampledStatisticsEnabled = enabled; |
| if(enabled) { |
| this.sampledStatistics = new SampledStatisticsImpl(scheduler); |
| } |
| else { |
| this.sampledStatistics.shutdown(); |
| this.sampledStatistics = NULL_SAMPLED_STATISTICS; |
| } |
| sendNotification(SAMPLED_STATISTICS_ENABLED, Boolean.valueOf(enabled)); |
| } |
| } |
| |
| public long getJobsCompletedMostRecentSample() { |
| return this.sampledStatistics.getJobsCompletedMostRecentSample(); |
| } |
| |
| public long getJobsExecutedMostRecentSample() { |
| return this.sampledStatistics.getJobsExecutingMostRecentSample(); |
| } |
| |
| public long getJobsScheduledMostRecentSample() { |
| return this.sampledStatistics.getJobsScheduledMostRecentSample(); |
| } |
| |
| public Map<String, Long> getPerformanceMetrics() { |
| Map<String, Long> result = new HashMap<String, Long>(); |
| result.put("JobsCompleted", Long |
| .valueOf(getJobsCompletedMostRecentSample())); |
| result.put("JobsExecuted", Long |
| .valueOf(getJobsExecutedMostRecentSample())); |
| result.put("JobsScheduled", Long |
| .valueOf(getJobsScheduledMostRecentSample())); |
| return result; |
| } |
| } |