@Override
public boolean replaceTrigger(TriggerKey triggerKey,
		OperableTrigger newTrigger) throws JobPersistenceException {
	boolean replaced = false;
	String triggerHashKey = createTriggerHashKey(triggerKey.getGroup(), triggerKey.getName());
     try (Jedis jedis = pool.getResource()) {
        lockPool.acquire();
		
		String jobHashKey =jedis.hget(triggerHashKey, JOB_HASH_KEY); 
		if (jobHashKey == null || jobHashKey.isEmpty())
			throw new JobPersistenceException("trigger does not exist or no job is associated with the trigger");			
		
		if (!jobHashKey.equals(createJobHashKey(newTrigger.getJobKey().getGroup(), newTrigger.getJobKey().getName())))
			throw new JobPersistenceException("the new trigger is associated with a diffrent job than the existing trigger");
		
		removeTrigger(triggerKey, jedis);
		storeTrigger(newTrigger, false, jedis);
		replaced = true;
	} catch (Exception ex) {
		log.error("could not replace trigger: " + triggerHashKey, ex);
		throw new JobPersistenceException(ex.getMessage(), ex.getCause());
	} finally {
        lockPool.release();
	}
	return replaced;
}
 

protected synchronized void resumeLocalTask(String taskName) throws TaskException {
    String taskGroup = this.getTenantTaskGroup();
    if (!this.isPreviouslyScheduled(taskName, taskGroup)) {
        throw new TaskException("Non-existing task for resuming with name: " + taskName,
                                TaskException.Code.NO_TASK_EXISTS);
    }
    try {
        Trigger trigger = this.getScheduler().getTrigger(new TriggerKey(taskName, taskGroup));
        if (trigger instanceof OperableTrigger) {
            ((OperableTrigger) trigger).setNextFireTime(trigger.getFireTimeAfter(null));
        }
        this.getScheduler().resumeJob(new JobKey(taskName, taskGroup));
        log.info("Task resumed: [" + this.getTaskType() + "][" + taskName + "]");
    } catch (SchedulerException e) {
        throw new TaskException("Error in resuming task with name: " + taskName, TaskException.Code.UNKNOWN, e);
    }
}
 

/**
 * <p>
 * Delete the base trigger data for a trigger.
 * </p>
 * 
 * @param conn
 *          the DB Connection
 * @return the number of rows deleted
 */
public int deleteTrigger(Connection conn, TriggerKey triggerKey) throws SQLException {
    PreparedStatement ps = null;

    deleteTriggerExtension(conn, triggerKey);
    
    try {
        ps = conn.prepareStatement(rtp(DELETE_TRIGGER));
        ps.setString(1, triggerKey.getName());
        ps.setString(2, triggerKey.getGroup());

        return ps.executeUpdate();
    } finally {
        closeStatement(ps);
    }
}
 

public boolean removeTriggers(final List<TriggerKey> triggerKeys)
        throws JobPersistenceException {
    return (Boolean) executeInLock(
            LOCK_TRIGGER_ACCESS,
            new TransactionCallback() {
                public Object execute(Connection conn) throws JobPersistenceException {
                    boolean allFound = true;

                    // FUTURE_TODO: make this more efficient with a true bulk operation...
                    for (TriggerKey triggerKey : triggerKeys)
                        allFound = removeTrigger(conn, triggerKey) && allFound;

                    return allFound ? Boolean.TRUE : Boolean.FALSE;
                }
            });
}
 

@Override
public void resumeTrigger(TriggerKey triggerKey)
		throws JobPersistenceException {
	String triggerHashKey = createTriggerHashKey(triggerKey.getGroup(), triggerKey.getName());
     try (Jedis jedis = pool.getResource()) {
        lockPool.acquire();
		
        OperableTrigger trigger = retrieveTrigger(new TriggerKey(triggerHashKey.split(":")[2], triggerHashKey.split(":")[1]), jedis);
		resumeTrigger(trigger, jedis);
		if (trigger != null)
			applyMisfire(trigger, jedis);
	} catch (Exception ex) {
		log.error("could not resume trigger: " + triggerHashKey, ex);
		throw new JobPersistenceException(ex.getMessage(), ex.getCause());
	} finally {
        lockPool.release();
	}
}
 

/**
 * Remove the indicated Trigger from the scheduler. 
 * If the related job does not have any other triggers, and the job is not durable, then the job will also be deleted.
 */
@Override
public boolean unScheduleJob(String jobName) {
	System.out.println("Request received for Unscheduleding job.");

	String jobKey = jobName;

	TriggerKey tkey = new TriggerKey(jobKey);
	System.out.println("Parameters received for unscheduling job : tkey :"+jobKey);
	try {
		boolean status = schedulerFactoryBean.getScheduler().unscheduleJob(tkey);
		System.out.println("Trigger associated with jobKey :"+jobKey+ " unscheduled with status :"+status);
		return status;
	} catch (SchedulerException e) {
		System.out.println("SchedulerException while unscheduling job with key :"+jobKey + " message :"+e.getMessage());
		e.printStackTrace();
		return false;
	}
}
 

/**
 * <p>
 * Remove (delete) the <code>{@link org.quartz.Calendar}</code> with the given name.
 * </p>
 * <p>
 * If removal of the <code>Calendar</code> would result in <code.Trigger</code>s pointing to non-existent calendars,
 * then a <code>JobPersistenceException</code> will be thrown.
 * </p>
 * *
 * 
 * @param calName The name of the <code>Calendar</code> to be removed.
 * @return <code>true</code> if a <code>Calendar</code> with the given name was found and removed from the store.
 */
@Override
public boolean removeCalendar(String calName) throws JobPersistenceException {
  int numRefs = 0;

  lock();
  try {
    for (TriggerKey triggerKey : triggerFacade.allTriggerKeys()) {
      TriggerWrapper tw = triggerFacade.get(triggerKey);
      if (tw.getCalendarName() != null && tw.getCalendarName().equals(calName)) {
        numRefs++;
      }
    }

    if (numRefs > 0) { throw new JobPersistenceException("Calender cannot be removed if it referenced by a Trigger!"); }

    return (calendarsByName.remove(calName) != null);
  } finally {
    unlock();
  }
}
 

@Test
public void testCreateTriggerEventSucceds()
    throws Exception
{
    final TriggerEventHibernateImpl
        evt = getTestTriggerEvent();

    final TriggerEventHibernateImpl
        result = (TriggerEventHibernateImpl)mgr.createTriggerEvent(evt.getEventType(),
                                                                   JobKey.jobKey(evt.getJobName()),
                                                                   TriggerKey.triggerKey(evt.getTriggerName()),
                                                                   evt.getTime(),
                                                                   evt.getMessage(),
                                                                   "server1");

    Assert.assertNotNull(result);
    Assert.assertNotNull(result.getId());

    assertEquals(evt, result);
}
 

/**
 * <p>
 * Get the names of all of the triggers in the given group and state that
 * have misfired.
 * </p>
 * 
 * @param conn
 *          the DB Connection
 * @return an array of <code>{@link
 * org.quartz.utils.Key}</code> objects
 */
public List<TriggerKey> selectMisfiredTriggersInGroupInState(Connection conn,
        String groupName, String state, long ts) throws SQLException {
    PreparedStatement ps = null;
    ResultSet rs = null;

    try {
        ps = conn
                .prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS_IN_GROUP_IN_STATE));
        ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
        ps.setString(2, groupName);
        ps.setString(3, state);
        rs = ps.executeQuery();

        LinkedList<TriggerKey> list = new LinkedList<TriggerKey>();
        while (rs.next()) {
            String triggerName = rs.getString(COL_TRIGGER_NAME);
            list.add(triggerKey(triggerName, groupName));
        }
        return list;
    } finally {
        closeResultSet(rs);
        closeStatement(ps);
    }
}
 

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

protected boolean updateMisfiredTrigger(Connection conn,
        TriggerKey triggerKey, String newStateIfNotComplete, boolean forceState)
    throws JobPersistenceException {
    try {

        OperableTrigger trig = retrieveTrigger(conn, triggerKey);

        long misfireTime = System.currentTimeMillis();
        if (getMisfireThreshold() > 0) {
            misfireTime -= getMisfireThreshold();
        }

        if (trig.getNextFireTime().getTime() > misfireTime) {
            return false;
        }

        doUpdateOfMisfiredTrigger(conn, trig, forceState, newStateIfNotComplete, false);

        return true;

    } catch (Exception e) {
        throw new JobPersistenceException(
                "Couldn't update misfired trigger '" + triggerKey + "': " + e.getMessage(), e);
    }
}
 

@RequestMapping(value = "/remove")
public @ResponseBody Map<String,Object> remove(HttpServletRequest request) {
	Map<String,Object> map = new HashMap<String,Object>();
    String name = request.getParameter("name");
    String group = request.getParameter("group");
    if (StringUtils.isNotBlank(name) || StringUtils.isNotBlank(group)) {
    	boolean result = schedulerCenter.unscheduleJob(new TriggerKey(name, group));
        map.put("success", result);
  if(result) {
  	map.put("msg", "删除成功！");
  }else {
  	map.put("msg", "删除失败！");
  }
    }
    return map;
}
 

@SuppressWarnings("unchecked")
@Test
public void testExecuteWithRangeLessThanZero() throws Exception {
    JobExecutionContext context = mock(JobExecutionContext.class);
    Scheduler scheduler = mock(Scheduler.class);
    GriffinMeasure measure = createGriffinMeasure("measureName");
    JobDetail jd = createJobDetail(JsonUtil.toJson(measure), "");
    BatchJob job = new BatchJob(1L, "jobName", "qName", "qGroup", false);
    List<Trigger> triggers = Arrays.asList(createSimpleTrigger(2, 0));
    given(context.getJobDetail()).willReturn(jd);
    given(measureRepo.findOne(Matchers.anyLong())).willReturn(measure);
    given(jobRepo.findOne(Matchers.anyLong())).willReturn(job);
    given(factory.getScheduler()).willReturn(scheduler);
    given((List<Trigger>) scheduler.getTriggersOfJob(Matchers.any(
            JobKey.class))).willReturn(triggers);
    given(scheduler.checkExists(Matchers.any(TriggerKey.class)))
            .willReturn(false);
    given(jobRepo.save(Matchers.any(BatchJob.class))).willReturn(job);
    given(scheduler.checkExists(Matchers.any(JobKey.class)))
            .willReturn(false);
    jobInstance.execute(context);

}
 

public void validateTriggerName(FacesContext context, UIComponent component,
    Object object)
{
  if (object instanceof String)
  {
    String value = (String)object;
    try
    {
      Trigger trigger = schedulerManager.getScheduler().getTrigger(TriggerKey.triggerKey(value, Scheduler.DEFAULT_GROUP));
      if (trigger != null)
      {
        FacesMessage message = new FacesMessage(rb.getString("existing_trigger_name"));
        message.setSeverity(FacesMessage.SEVERITY_WARN);
        throw new ValidatorException(message);
      }
    }
    catch (SchedulerException e)
    {
      log.error("Scheduler down!");
    }
  }
}
 

public List<TriggerKey> selectMisfiredTriggersInState(Connection conn, String state,
        long ts) throws SQLException {
    PreparedStatement ps = null;
    ResultSet rs = null;

    try {
        ps = conn.prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS_IN_STATE));
        ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
        ps.setString(2, state);
        rs = ps.executeQuery();

        LinkedList<TriggerKey> list = new LinkedList<TriggerKey>();
        while (rs.next()) {
            String triggerName = rs.getString(COL_TRIGGER_NAME);
            String groupName = rs.getString(COL_TRIGGER_GROUP);
            list.add(triggerKey(triggerName, groupName));
        }
        return list;
    } finally {
        closeResultSet(rs);
        closeStatement(ps);
    }
}
 

/**
 * <p>
 * Pause the <code>{@link org.quartz.Trigger}</code> with the given name.
 * </p>
 * 
 * @see #resumeTrigger(Connection, TriggerKey)
 */
public void pauseTrigger(Connection conn, 
        TriggerKey triggerKey)
    throws JobPersistenceException {

    try {
        String oldState = getDelegate().selectTriggerState(conn,
                triggerKey);

        if (oldState.equals(STATE_WAITING)
                || oldState.equals(STATE_ACQUIRED)) {

            getDelegate().updateTriggerState(conn, triggerKey,
                    STATE_PAUSED);
        } else if (oldState.equals(STATE_BLOCKED)) {
            getDelegate().updateTriggerState(conn, triggerKey,
                    STATE_PAUSED_BLOCKED);
        }
    } catch (SQLException e) {
        throw new JobPersistenceException("Couldn't pause trigger '"
                + triggerKey + "': " + e.getMessage(), e);
    }
}
 

public void validateTriggerName(FacesContext context, UIComponent component,
    Object object)
{
  if (object instanceof String)
  {
    String value = (String)object;
    try
    {
      Trigger trigger = schedulerManager.getScheduler().getTrigger(TriggerKey.triggerKey(value, Scheduler.DEFAULT_GROUP));
      if (trigger != null)
      {
        FacesMessage message = new FacesMessage(rb.getString("existing_trigger_name"));
        message.setSeverity(FacesMessage.SEVERITY_WARN);
        throw new ValidatorException(message);
      }
    }
    catch (SchedulerException e)
    {
      log.error("Scheduler down!");
    }
  }
}
 

@Transactional(propagation = REQUIRES_NEW)
public DelayedInvocation[] findDelayedInvocations(String componentId, String opaqueContext) {
	log.debug("componentId=" + componentId + ", opaqueContext=" + opaqueContext);
	Collection<String> uuids = dao.find(componentId, opaqueContext);
	List<DelayedInvocation> invocations = new ArrayList<>();
	for (String uuid: uuids) {
		TriggerKey key = new TriggerKey(uuid, GROUP_NAME);
		try {
			Trigger trigger = schedulerFactory.getScheduler().getTrigger(key);
			if (trigger == null) {
				log.error("Failed to trigger with key: {}", key);
			} else {
				invocations.add(new DelayedInvocation(trigger.getKey().getName(), trigger.getNextFireTime(), key.getName(), opaqueContext));
			}
		} catch (SchedulerException e) {
			log.warn("Problem finding delayed invocations.", e);
			return null;
		}
	}
	return invocations.toArray(new DelayedInvocation[]{});
}
 

public void resumeTrigger(final TriggerKey triggerKey) {
    try {
        scheduler.resumeTrigger(triggerKey);
    } catch (final SchedulerException e) {
        throw new QuartzSchedulerException(e);
    }
}
 

public void continueTrigger(String triggerName, String triggerGroup) {
	if(!getIsEnabled()){
		throw new FixFlowScheduleException(ExceptionCode.QUARZTEXCEPTION_ISENABLE);
	}
	Scheduler scheduler = getScheduler();
	TriggerKey tKey = new TriggerKey(triggerName,triggerGroup);
	try {
		scheduler.resumeTrigger(tKey);
	} catch (SchedulerException e) {
		throw new FixFlowException(e.getMessage(),e);
	}
}
 

/**
 * <p>
 * Calls the equivalent method on the 'proxied' <code>QuartzScheduler</code>.
 * </p>
 */
public boolean checkExists(TriggerKey triggerKey) throws SchedulerException {
    try {
        return getRemoteScheduler().checkExists(triggerKey);
    } catch (RemoteException re) {
        throw invalidateHandleCreateException(
                "Error communicating with remote scheduler.", re);
    }
}
 

/**
 * Pause triggers.
 *
 * @param triggerGroupHashKey the trigger group hash key
 * @param jedis thread-safe redis connection
 * @throws JobPersistenceException
 */
private boolean pauseTriggers(String triggerGroupHashKey, Jedis jedis) throws JobPersistenceException {
	if (jedis.sadd(PAUSED_TRIGGER_GROUPS_SET, triggerGroupHashKey) > 0) { 
		Set<String> triggers = jedis.smembers(triggerGroupHashKey);
		for(String trigger : triggers)
			pauseTrigger(new TriggerKey(trigger.split(":")[2], trigger.split(":")[1]), jedis);
		return true;
	}
	return false;
}
 

/**
    * addJob
    *
    * @param jobName
    * @param jobGroup
    * @param cronExpression
    * @return
    * @throws SchedulerException
    */
public static boolean addJob(String jobName, String jobGroup, String cronExpression) throws SchedulerException {
   	// TriggerKey : name + group
       TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
       JobKey jobKey = new JobKey(jobName, jobGroup);
       
       // TriggerKey valid if_exists
       if (checkExists(jobName, jobGroup)) {
           logger.info(">>>>>>>>> addJob fail, job already exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
           return false;
       }
       
       // CronTrigger : TriggerKey + cronExpression	// withMisfireHandlingInstructionDoNothing 忽略掉调度终止过程中忽略的调度
       CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionDoNothing();
       CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(cronScheduleBuilder).build();

       // JobDetail : jobClass
	Class<? extends Job> jobClass_ = RemoteHttpJobBean.class;   // Class.forName(jobInfo.getJobClass());
       
	JobDetail jobDetail = JobBuilder.newJob(jobClass_).withIdentity(jobKey).build();
       /*if (jobInfo.getJobData()!=null) {
       	JobDataMap jobDataMap = jobDetail.getJobDataMap();
       	jobDataMap.putAll(JacksonUtil.readValue(jobInfo.getJobData(), Map.class));	
       	// JobExecutionContext context.getMergedJobDataMap().get("mailGuid");
	}*/
       
       // schedule : jobDetail + cronTrigger
       Date date = scheduler.scheduleJob(jobDetail, cronTrigger);

       logger.info(">>>>>>>>>>> addJob success, jobDetail:{}, cronTrigger:{}, date:{}", jobDetail, cronTrigger, date);
       return true;
   }
 

/**
 * <p>
 * Calls the equivalent method on the 'proxied' <code>QuartzScheduler</code>.
 * </p>
 */
public boolean checkExists(TriggerKey triggerKey) throws SchedulerException {
    return (Boolean)invoke(
            "checkExists", 
            new Object[] { triggerKey }, 
            new String[] { TriggerKey.class.getName() });
}
 

/**
 * 删除定时任务
 * 
 * @param jobClassName
 */
private void schedulerDelete(String jobClassName) {
	try {
		scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName));
		scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName));
		scheduler.deleteJob(JobKey.jobKey(jobClassName));
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		throw new JeecgBootException("删除定时任务失败");
	}
}
 

/**
 * 删除定时任务
 * 
 * @param jobClassName
 */
private void schedulerDelete(String jobClassName) {
	try {
		scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName));
		scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName));
		scheduler.deleteJob(JobKey.jobKey(jobClassName));
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		throw new JeecgBootException("删除定时任务失败");
	}
}
 

/**
 * 删除定时任务
 * 
 * @param jobClassName
 */
private void schedulerDelete(String jobClassName) {
	try {
		scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName));
		scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName));
		scheduler.deleteJob(JobKey.jobKey(jobClassName));
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		throw new JeecgBootException("删除定时任务失败");
	}
}
 

public boolean unscheduleJobs(final List<TriggerKey> triggerKeys) {
    try {
        return scheduler.unscheduleJobs(triggerKeys);
    } catch (final SchedulerException e) {
        throw new QuartzSchedulerException(e);
    }
}
 

@Test
public void assertRescheduleJobSuccess() throws SchedulerException {
    when(scheduler.getTrigger(TriggerKey.triggerKey("test_job_Trigger"))).thenReturn(new CronTriggerImpl());
    ReflectionUtils.setFieldValue(jobScheduleController, "scheduler", scheduler);
    jobScheduleController.rescheduleJob("0/1 * * * * ?");
    verify(scheduler).rescheduleJob(eq(TriggerKey.triggerKey("test_job_Trigger")), any());
}
 

@Override
public void resumeTrigger(final TriggerKey triggerKey) throws JobPersistenceException {
  executeWrite(db -> {
    resumeTrigger(db, triggerKey);
    return null;
  });
}