@Override
public ActionMessages establishRequiredState(HttpServletRequest request, ActionForm form) throws Exception {
    if ("moveToRouteQueue".equals(request.getParameter("methodToCall")) && request.getAttribute(RENDER_LIST_OVERRIDE) == null) {
        return null;
    }

    Scheduler scheduler = KSBServiceLocator.getScheduler();
    List<QuartzQueueForm> jobs = new ArrayList<QuartzQueueForm>();
    List<String> jobGroups = KSBServiceLocator.getScheduler().getJobGroupNames();

    for (int i = 0; i < jobGroups.size(); i++) {
        String jobGroup = KSBServiceLocator.getScheduler().getJobGroupNames().get(i);
        for(JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(jobGroup))) {
            Trigger trigger = scheduler.getTriggersOfJob(jobKey).get(0);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            jobs.add(new QuartzQueueForm(jobDetail, trigger) );
        }
    }

    request.setAttribute("jobs", jobs);
    return null;
}
 

@Test
public void resumeJobsEndsWith() throws Exception {
    Map<JobDetail, Set<? extends Trigger>> jobsAndTriggers = getJobsAndTriggers(2, 2, 2, 2);
    jobStore.storeJobsAndTriggers(jobsAndTriggers, false);

    // pause one of the job groups
    String pausedGroupName = new ArrayList<>(jobsAndTriggers.keySet()).get(0).getKey().getGroup();
    String substring = pausedGroupName.substring(pausedGroupName.length() - 1, pausedGroupName.length());
    Collection<String> pausedGroups = jobStore.pauseJobs(GroupMatcher.jobGroupEndsWith(substring));

    assertThat(pausedGroups, hasSize(1));
    assertThat(pausedGroups, containsInAnyOrder(pausedGroupName));

    // resume the paused jobs
    Collection<String> resumedGroups = jobStore.resumeJobs(GroupMatcher.jobGroupEndsWith(substring));

    assertThat(resumedGroups, hasSize(1));
    assertThat(resumedGroups, containsInAnyOrder(pausedGroupName));

    for (Trigger trigger : new ArrayList<>(jobsAndTriggers.entrySet()).get(0).getValue()) {
        assertEquals(Trigger.TriggerState.NORMAL, jobStore.getTriggerState(trigger.getKey()));
    }
}
 

/**
 * <p>
 * Pause all of the <code>{@link Trigger}s</code> in the given group.
 * </p>
 * <p>
 * The JobStore should "remember" that the group is paused, and impose the pause on any new triggers that are added to
 * the group while the group is paused.
 * </p>
 */
@Override
public Collection<String> pauseTriggers(GroupMatcher<TriggerKey> matcher) throws JobPersistenceException {
  HashSet<String> pausedGroups = new HashSet<String>();
  lock();
  try {
    Set<TriggerKey> triggerKeys = getTriggerKeys(matcher);
    for (TriggerKey key : triggerKeys) {
      triggerFacade.addPausedGroup(key.getGroup());
      pausedGroups.add(key.getGroup());
      pauseTrigger(key);
    }
    // make sure to account for an exact group match for a group that doesn't yet exist
    StringMatcher.StringOperatorName operator = matcher.getCompareWithOperator();
    if (operator.equals(StringOperatorName.EQUALS)) {
      triggerFacade.addPausedGroup(matcher.getCompareToValue());
      pausedGroups.add(matcher.getCompareToValue());
    }
  } finally {
    unlock();
  }
  return pausedGroups;
}
 

/**
 * <p>
 * Pause all of the <code>{@link org.quartz.JobDetail}s</code> in the given group - by pausing all of their
 * <code>Trigger</code>s.
 * </p>
 * <p>
 * The JobStore should "remember" that the group is paused, and impose the pause on any new jobs that are added to the
 * group while the group is paused.
 * </p>
 */
@Override
public Collection<String> pauseJobs(GroupMatcher<JobKey> matcher) throws JobPersistenceException {
  Collection<String> pausedGroups = new HashSet<String>();
  lock();
  try {

    Set<JobKey> jobKeys = getJobKeys(matcher);

    for (JobKey jobKey : jobKeys) {
      for (OperableTrigger trigger : getTriggersForJob(jobKey)) {
        pauseTrigger(trigger.getKey());
      }
      pausedGroups.add(jobKey.getGroup());
    }
    // make sure to account for an exact group match for a group that doesn't yet exist
    StringMatcher.StringOperatorName operator = matcher.getCompareWithOperator();
    if (operator.equals(StringOperatorName.EQUALS)) {
      jobFacade.addPausedGroup(matcher.getCompareToValue());
      pausedGroups.add(matcher.getCompareToValue());
    }
  } finally {
    unlock();
  }
  return pausedGroups;
}
 

/**
 * protected
 * <p>
 * Resume (un-pause) all triggers - equivalent of calling <code>resumeTriggerGroup(group)</code>
 * on every group.
 * </p>
 * 
 * <p>
 * If any <code>Trigger</code> missed one or more fire-times, then the
 * <code>Trigger</code>'s misfire instruction will be applied.
 * </p>
 * 
 * @see #pauseAll(Connection)
 */
public void resumeAll(Connection conn)
    throws JobPersistenceException {

    List<String> names = getTriggerGroupNames(conn);

    for (String name: names) {
        resumeTriggerGroup(conn, GroupMatcher.triggerGroupEquals(name));
    }

    try {
        getDelegate().deletePausedTriggerGroup(conn, ALL_GROUPS_PAUSED);
    } catch (SQLException e) {
        throw new JobPersistenceException(
                "Couldn't resume all trigger groups: " + e.getMessage(), e);
    }
}
 

/**
 * <p>
 * Resume (un-pause) all triggers - equivalent of calling <code>resumeTriggerGroup(group)</code> on every group.
 * </p>
 * <p>
 * If any <code>Trigger</code> missed one or more fire-times, then the <code>Trigger</code>'s misfire instruction will
 * be applied.
 * </p>
 * 
 * @see #pauseAll()
 */
@Override
public void resumeAll() throws JobPersistenceException {

  lock();
  try {
    jobFacade.clearPausedJobGroups();
    List<String> names = getTriggerGroupNames();

    for (String name : names) {
      resumeTriggers(GroupMatcher.triggerGroupEquals(name));
    }
  } finally {
    unlock();
  }
}
 

/**
 * <p>
 * Resume (un-pause) all of the <code>{@link Trigger}s</code> in the
 * given group.
 * </p>
 *
 * <p>
 * If any <code>Trigger</code> missed one or more fire-times, then the
 * <code>Trigger</code>'s misfire instruction will be applied.
 * </p>
 *
 */
public List<String> resumeTriggers(GroupMatcher<TriggerKey> matcher) {
    Set<String> groups = new HashSet<String>();

    synchronized (lock) {
        Set<TriggerKey> keys = getTriggerKeys(matcher);

        for (TriggerKey triggerKey: keys) {
            groups.add(triggerKey.getGroup());
            if(triggersByKey.get(triggerKey) != null) {
                String jobGroup = triggersByKey.get(triggerKey).jobKey.getGroup();
                if(pausedJobGroups.contains(jobGroup)) {
                    continue;
                }
            }
            resumeTrigger(triggerKey);
        }
        for (String group : groups) {
            pausedTriggerGroups.remove(group);
        }
    }

    return new ArrayList<String>(groups);
}
 

/**
    * Get all waitting queue jobs scheduled in Quartz table and display job name, job start time and description. The
    * description will be in format "Lesson Name":"the lesson creator", or "The gate name":"The relatived lesson name".
    */
   @RequestMapping(path = "/joblist", method = RequestMethod.POST)
   public String execute(HttpServletRequest request) throws Exception {
ArrayList<ScheduledJobDTO> jobList = new ArrayList<>();
try {
    Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(Scheduler.DEFAULT_GROUP));
    for (JobKey jobKey : jobKeys) {
	ScheduledJobDTO jobDto = new ScheduledJobDTO();
	JobDetail detail = scheduler.getJobDetail(jobKey);
	jobDto.setName(jobKey.getName());
	jobDto.setDescription(detail.getDescription());
	List<Trigger> triggers = (List<Trigger>) scheduler.getTriggersOfJob(jobKey);
	for (Trigger trigger : triggers) {
	    jobDto.setStartDate(trigger.getStartTime());
	    jobList.add(jobDto);
	}
    }
} catch (SchedulerException e) {
    ScheduledJobListController.log.equals("Failed get job names:" + e.getMessage());
}

request.setAttribute("jobList", jobList);
return "joblist";
   }
 

@GetMapping(URL_LIST)
@SuppressWarnings("unchecked")
public List<Map<String, String>> listScheduledJobs() throws SchedulerException {
    List<Map<String, String>> jobs = new LinkedList<>();
    SiteContext siteContext = SiteContext.getCurrent();
    Scheduler scheduler = siteContext.getScheduler();
    if(scheduler != null) {
        List<String> groups = scheduler.getJobGroupNames();
        for (String group : groups) {
            Set<JobKey> keys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(group));
            for (JobKey key : keys) {
                List<Trigger> triggers = (List<Trigger>)scheduler.getTriggersOfJob(key);
                Map<String, String> job = new HashMap<>();
                job.put("name", key.getName());
                job.put("nextFireTime", triggers.get(0).getNextFireTime().toInstant().toString());
                jobs.add(job);
            }
        }
    }
    return jobs;
}
 

/**
 * <p>
 * Calls the equivalent method on the 'proxied' <code>QuartzScheduler</code>,
 * passing the <code>SchedulingContext</code> associated with this
 * instance.
 * </p>
 */
public void pauseJobs(GroupMatcher<JobKey> matcher) throws SchedulerException {
    String operation = null;
    switch (matcher.getCompareWithOperator()) {
        case EQUALS:
            operation = "pauseJobGroup";
            break;
        case STARTS_WITH:
            operation = "pauseJobsStartingWith";
            break;
        case ENDS_WITH:
            operation = "pauseJobsEndingWith";
            break;
        case CONTAINS:
            operation = "pauseJobsContaining";
        case ANYTHING:
            operation = "pauseJobsAll";
    }

    invoke(
            operation,
            new Object[] { matcher.getCompareToValue() },
            new String[] { String.class.getName() });
}
 

@Test
@SuppressWarnings( "unchecked" )
public void testApplicationDeleted_exceptionWhileListingJobs() throws Exception {

	RoboconfScheduler roboconfScheduler = Mockito.mock( RoboconfScheduler.class );
	roboconfScheduler.scheduler = Mockito.mock( Scheduler.class );
	Mockito
		.when( roboconfScheduler.scheduler.getTriggerKeys( Mockito.any( GroupMatcher.class )))
		.thenThrow( new SchedulerException( "For test" ));

	ManagerListener listener = new ManagerListener( roboconfScheduler );
	listener.application(
			new Application( "app", Mockito.mock( ApplicationTemplate.class )),
			EventType.DELETED );

	Mockito
		.verify( roboconfScheduler.scheduler, Mockito.times( 1 ))
		.getTriggerKeys( Mockito.any( GroupMatcher.class ));
}
 

public List<JobDetail> getJobList(String queryId){
	if(!getIsEnabled()){
		throw new FixFlowScheduleException(ExceptionCode.QUARZTEXCEPTION_ISENABLE);
	}
	Scheduler scheduler = getScheduler();
	List<JobDetail> jobList = new ArrayList<JobDetail>();
	Set<JobKey> set = new HashSet<JobKey>();
	try {
		//如果queryId不为空，则返回queryId对应的job,否则返回所有job
		if(StringUtil.isNotEmpty(queryId)){
			set = scheduler.getJobKeys(GroupMatcher.jobGroupContains(queryId));
		}else{
			List<String> groupNames = scheduler.getJobGroupNames();
			for(String groupName:groupNames){
				set.addAll(scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName)));
			}
		}
		for(JobKey key :set){
			JobDetail job = scheduler.getJobDetail(key); 
			jobList.add(job);
		}
	}catch (SchedulerException e) {
			throw new FixFlowException(e.getMessage(),e);
		}
	return jobList;
}
 

@Override
public Map<IJobKey, CrontabEntry> getScheduledJobs() {
  // NOTE: no synchronization is needed here since this is just a dump of internal quartz state
  // for debugging.
  ImmutableMap.Builder<IJobKey, CrontabEntry> scheduledJobs = ImmutableMap.builder();
  try {
    for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.anyGroup())) {
      // The quartz API allows jobs to have multiple triggers. We don't use that feature but
      // we're defensive here since this function is used for debugging.
      Optional<CronTrigger> trigger = FluentIterable.from(scheduler.getTriggersOfJob(jobKey))
          .filter(CronTrigger.class)
          .first()
          .toJavaUtil();
      if (trigger.isPresent()) {
        scheduledJobs.put(
            Quartz.auroraJobKey(jobKey),
            Quartz.crontabEntry(trigger.get()));
      }
    }
  } catch (SchedulerException e) {
    throw new RuntimeException(e);
  }
  return scheduledJobs.build();
}
 

@Test
public void pauseJobsStartsWith() throws Exception {
    JobDetail job1 = getJobDetail("job1", "jobGroup1");
    storeJobAndTriggers(job1, getCronTrigger("trigger1", "triggerGroup1", job1.getKey()), getCronTrigger("trigger2", "triggerGroup1", job1.getKey()));
    JobDetail job2 = getJobDetail("job2", "yobGroup1");
    CronTriggerImpl trigger3 = getCronTrigger("trigger3", "triggerGroup3", job2.getKey());
    CronTriggerImpl trigger4 = getCronTrigger("trigger4", "triggerGroup4", job2.getKey());
    storeJobAndTriggers(job2, trigger3, trigger4);

    // pause jobs with groups beginning with "yob"
    Collection<String> pausedJobs = jobStore.pauseJobs(GroupMatcher.jobGroupStartsWith("yob"));
    assertThat(pausedJobs, hasSize(1));
    assertThat(pausedJobs, containsInAnyOrder("yobGroup1"));

    // ensure that the job was added to the paused jobs set
    assertTrue(jedis.sismember(schema.pausedJobGroupsSet(), schema.jobGroupSetKey(job2.getKey())));

    // ensure that the job's triggers have been paused
    assertEquals(Trigger.TriggerState.PAUSED, jobStore.getTriggerState(trigger3.getKey()));
    assertEquals(Trigger.TriggerState.PAUSED, jobStore.getTriggerState(trigger4.getKey()));
}
 

public AbstractQuartzTaskManager(TaskRepository taskRepository, TaskStore taskStore) throws TaskException {

        this.taskRepository = taskRepository;
        this.scheduler = TasksDSComponent.getScheduler();
        this.taskStore = taskStore;
        try {
            Matcher<TriggerKey> tenantTaskTypeGroupMatcher = GroupMatcher.groupEquals(this.getTenantTaskGroup());
            this.getScheduler().getListenerManager().addTriggerListener(
                    new TaskTriggerListener(this.getTenantTaskGroup()), tenantTaskTypeGroupMatcher);
        } catch (SchedulerException e) {
            throw new TaskException("Error in initiating task trigger listener", TaskException.Code.UNKNOWN, e);
        }
    }
 

public List<JobInfo> listAllJobs() {
	List<JobInfo> jobInfoList = new ArrayList<>();
	try {
		for (String groupName : scheduler.getJobGroupNames()) {
			for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
				String jobName = jobKey.getName();
				JobDetail jobDetail = scheduler.getJobDetail(jobKey);
				JobInfo jobInfo = new JobInfo();

				jobInfo.setGroupName(groupName);
				jobInfo.setJobName(jobName);
				jobInfo.setClassName(jobDetail.getJobClass().getName());
				jobInfo.setDescription(jobDetail.getDescription());

				TriggerKey triggerKey = TriggerKey.triggerKey(jobName + TRG_SUFFIX, groupName + TRG_SUFFIX);
				CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
				Trigger.TriggerState status = getJobState(jobName, groupName);
				jobInfo.setCron(cronTrigger.getCronExpression());
				jobInfo.setStatus(status.toString());
				jobInfoList.add(jobInfo);
			}
		}
	} catch (SchedulerException e) {
		log.error("获取定时任务列表出错", e);
		return null;
	}
	return jobInfoList;
}
 

@Test
public void testLoadAllJobs_exception() throws Exception {

	Utils.createDirectory( this.scheduler.getSchedulerDirectory());

	// Create several job FILES
	final int max = 5;
	for( int i=0; i<max; i++ ) {

		Properties props = new Properties();
		props.put( RoboconfScheduler.JOB_NAME, "job " + i );
		props.put( RoboconfScheduler.APP_NAME, "app" );
		props.put( RoboconfScheduler.CMD_NAME, "cmd" );
		props.put( RoboconfScheduler.CRON, "0 0 0 ? 1 *" );

		Utils.writePropertiesFile( props, this.scheduler.getJobFile( "job-id-" + i ));
	}

	// Throw an exception when a job is scheduled
	this.scheduler.scheduler = Mockito.mock( Scheduler.class );
	Mockito.when( this.scheduler.scheduler.scheduleJob(
			Mockito.any( JobDetail.class ),
			Mockito.any( Trigger.class ))).thenThrow( new SchedulerException( "For test" ));

	// Load the jobs...
	this.scheduler.loadJobs();
	File schedulerDirectory = this.scheduler.getSchedulerDirectory();

	Set<JobKey> jobKeys = this.scheduler.scheduler.getJobKeys( GroupMatcher.anyJobGroup());
	Assert.assertEquals( 0, jobKeys.size());
	Assert.assertEquals( max, Utils.listAllFiles( schedulerDirectory ).size());
}
 

/**
 * <p>
 * Resume (un-pause) all of the <code>{@link org.quartz.JobDetail}s</code>
 * in the matching groups.
 * </p>
 * 
 * <p>
 * If any of the <code>Job</code> s had <code>Trigger</code> s that
 * missed one or more fire-times, then the <code>Trigger</code>'s
 * misfire instruction will be applied.
 * </p>
 *  
 */
public void resumeJobs(GroupMatcher<JobKey> matcher)
    throws SchedulerException {
    validateState();

    if(matcher == null) {
        matcher = GroupMatcher.groupEquals(Scheduler.DEFAULT_GROUP);
    }
    
    Collection<String> resumedGroups = resources.getJobStore().resumeJobs(matcher);
    notifySchedulerThread(0L);
    for (String pausedGroup : resumedGroups) {
        notifySchedulerListenersResumedJobs(pausedGroup);
    }
}
 

public void resumeJobs(final GroupMatcher<JobKey> matcher) {
    try {
        scheduler.resumeJobs(matcher);
    } catch (final SchedulerException e) {
        throw new QuartzSchedulerException(e);
    }
}
 

protected void stopAndDeleteAllSnifferJobs(final long snifferId) throws SchedulerException {
	for (final JobKey job : scheduler.getJobKeys(GroupMatcher.jobGroupEquals("SNIFFER:" + snifferId))) {
		logger.info("Deleting scheduled job for sniffer={} and log source={}", snifferId, getLogSourceId(job));
		scheduler.deleteJob(job);
		logger.info("Interrupting job for sniffer={} and log source={}", snifferId, getLogSourceId(job));
		scheduler.interrupt(job);
	}
}
 

/**
 * 获取scheduler下所有的jobDetail
 * @param scheduler
 * @return
 * @throws SchedulerException
 */
public static List<JobDetail> getAllJobsOfScheduler(Scheduler scheduler) throws SchedulerException {
    List<JobDetail> result = new ArrayList<JobDetail>();
    List<String> jobGroupNames = scheduler.getJobGroupNames();
    for (String groupName : jobGroupNames) {
        Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(groupName));
        for (JobKey jobKey : jobKeys) {
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            result.add(jobDetail);
        }
    }
    return result;
}
 

public static List<JobDetail> getAllJobDetails(Scheduler scheduler) throws SchedulerException {
	List<JobDetail> jobDetails = new ArrayList<JobDetail>();
	
	List<String> groupNames = scheduler.getJobGroupNames();
	for (String jobGroup : groupNames) {
   		Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(jobGroup)); 
		for (JobKey jobKey : jobKeys) {
			jobDetails.add(scheduler.getJobDetail(jobKey));
		}
	}
	
	return jobDetails;
}
 

public Set<JobKey> getJobKeys(final GroupMatcher<JobKey> matcher) {
    try {
        return scheduler.getJobKeys(matcher);
    } catch (final SchedulerException e) {
        throw new QuartzSchedulerException(e);
    }
}
 

public void resumeJobs(GroupMatcher<JobKey> matcher) throws Exception {
    try {
        scheduler.resumeJobs(matcher);
    } catch (Exception e) {
        throw newPlainException(e);
    }
}
 

public void init() throws SchedulerException {
	log.info("init()");
	triggerListener = new ContextTriggerListener("ContextTriggerListener");
	ListenerManager listenerManager = schedulerFactory.getScheduler().getListenerManager();
	// Just filter on our group.
	listenerManager.addTriggerListener(triggerListener, GroupMatcher.triggerGroupEquals(GROUP_NAME));
}
 

@Override
public Collection<String> pauseTriggers(GroupMatcher<TriggerKey> matcher) throws JobPersistenceException {
  try {
    return realJobStore.pauseTriggers(matcher);
  } catch (RejoinException e) {
    throw new JobPersistenceException("Pausing triggers failed due to client rejoin", e);
  }
}
 

private void pauseTriggers(GroupMatcher<TriggerKey> matcher) throws Exception {
    try {
        scheduler.pauseTriggers(matcher);
    } catch (Exception e) {
        throw newPlainException(e);
    }
}
 

/**
 * Returns all trigger keys that are matched by passed in matcher.
 */
private Set<TriggerKey> getTriggerKeys(final ODatabaseDocumentTx db,
                                       final GroupMatcher<TriggerKey> matcher)
    throws JobPersistenceException
{
  Iterable<TriggerEntity> matches = triggerEntityAdapter.browseWithPredicate
      (db, input -> matcher.isMatch(input.getValue().getKey()));

  Set<TriggerKey> result = new HashSet<>();
  for (TriggerEntity entity : matches) {
    result.add(entity.getValue().getKey());
  }
  return result;
}
 

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);
    }
}
 

@Test
public void getJobKeys() throws Exception {
    jobStore.storeJob(getJobDetail("job1", "group1"), false);
    jobStore.storeJob(getJobDetail("job2", "group1"), false);
    jobStore.storeJob(getJobDetail("job3", "group2"), false);

    Set<JobKey> jobKeys = jobStore.getJobKeys(GroupMatcher.jobGroupEquals("group1"));

    assertThat(jobKeys, hasSize(2));
    assertThat(jobKeys, containsInAnyOrder(new JobKey("job1", "group1"), new JobKey("job2", "group1")));

    jobStore.storeJob(getJobDetail("job4", "awesomegroup1"), false);

    jobKeys = jobStore.getJobKeys(GroupMatcher.jobGroupContains("group"));

    assertThat(jobKeys, hasSize(4));
    assertThat(jobKeys, containsInAnyOrder(new JobKey("job1", "group1"), new JobKey("job2", "group1"),
            new JobKey("job4", "awesomegroup1"), new JobKey("job3", "group2")));

    jobKeys = jobStore.getJobKeys(GroupMatcher.jobGroupStartsWith("awe"));

    assertThat(jobKeys, hasSize(1));
    assertThat(jobKeys, containsInAnyOrder(new JobKey("job4", "awesomegroup1")));

    jobKeys = jobStore.getJobKeys(GroupMatcher.jobGroupEndsWith("1"));

    assertThat(jobKeys, hasSize(3));
    assertThat(jobKeys, containsInAnyOrder(new JobKey("job1", "group1"), new JobKey("job2", "group1"),
            new JobKey("job4", "awesomegroup1")));
}