private boolean notifyTriggerListenersComplete(JobExecutionContext jobExCtxt, CompletedExecutionInstruction instCode) {
    try {
        qs.notifyTriggerListenersComplete(jobExCtxt, instCode);

    } catch (SchedulerException se) {
        qs.notifySchedulerListenersError(
                "Unable to notify TriggerListener(s) of Job that was executed: "
                        + "(error will be ignored). trigger= "
                        + jobExCtxt.getTrigger().getKey() + " job= "
                        + jobExCtxt.getJobDetail().getKey(), se);

        return false;
    }
    if (jobExCtxt.getTrigger().getNextFireTime() == null) {
        qs.notifySchedulerListenersFinalized(jobExCtxt.getTrigger());
    }

    return true;
}
 

public void notifyTriggerListenersComplete(JobExecutionContext jec,
        CompletedExecutionInstruction instCode) throws SchedulerException {
    // build a list of all trigger listeners that are to be notified...
    List<TriggerListener> triggerListeners = buildTriggerListenerList();

    // notify all trigger listeners in the list
    for(TriggerListener tl: triggerListeners) {
        try {
            if(!matchTriggerListener(tl, jec.getTrigger().getKey()))
                continue;
            tl.triggerComplete(jec.getTrigger(), jec, instCode);
        } catch (Exception e) {
            SchedulerException se = new SchedulerException(
                    "TriggerListener '" + tl.getName()
                            + "' threw exception: " + e.getMessage(), e);
            throw se;
        }
    }
}
 

@Test
public void jobDataOnlySavedWhenDirty() throws Exception {
  JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("testJob").build();
  OperableTrigger trigger = (OperableTrigger) TriggerBuilder.newTrigger().withIdentity("testJob").forJob(job).build();
  jobStore.storeJobAndTrigger(job, trigger);

  int baseRecordVersion = queryJobDetail("testJob").getVersion();

  // same job data after trigger fired...
  jobStore.triggersFired(Arrays.asList(trigger));
  jobStore.triggeredJobComplete(trigger, job, CompletedExecutionInstruction.NOOP);

  // ...should not save the job
  assertThat(queryJobDetail("testJob").getVersion(), is(baseRecordVersion));

  // different job data after trigger fired...
  jobStore.triggersFired(Arrays.asList(trigger));
  job.getJobDataMap().put("testKey", "testValue");
  jobStore.triggeredJobComplete(trigger, job, CompletedExecutionInstruction.NOOP);

  // ...should save the job
  assertThat(queryJobDetail("testJob").getVersion(), greaterThan(baseRecordVersion));
}
 

/**
 * {@inheritDoc}
 */
@Override
public void triggerComplete(Trigger trigger, JobExecutionContext ctx,
        CompletedExecutionInstruction cei) {
    synchronized (this) {
        if (this.jobCount == 0 && !this.shutdownStarted) {
            this.shutdownStarted = true;
            this.owner.startShutdown();
        }
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void triggerComplete(Trigger trigger, JobExecutionContext ctx,
        CompletedExecutionInstruction cei) {
    for (Iterator iter = this.listenerChain.iterator(); iter.hasNext();) {
        TriggerListener listener = (TriggerListener) iter.next();
        listener.triggerComplete(trigger, ctx, cei);
    }
}
 

/**
 * <p>
 * Inform the <code>JobStore</code> that the scheduler has completed the
 * firing of the given <code>Trigger</code> (and the execution its
 * associated <code>Job</code>), and that the <code>{@link org.quartz.JobDataMap}</code>
 * in the given <code>JobDetail</code> should be updated if the <code>Job</code>
 * is stateful.
 * </p>
 */
public void triggeredJobComplete(final OperableTrigger trigger,
        final JobDetail jobDetail, final CompletedExecutionInstruction triggerInstCode) {
    retryExecuteInNonManagedTXLock(
        LOCK_TRIGGER_ACCESS,
        new VoidTransactionCallback() {
            public void executeVoid(Connection conn) throws JobPersistenceException {
                triggeredJobComplete(conn, trigger, jobDetail,triggerInstCode);
            }
        });    
}
 

public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {

        Iterator<TriggerListener> itr = listeners.iterator();
        while(itr.hasNext()) {
            TriggerListener l = itr.next();
            l.triggerComplete(trigger, context, triggerInstructionCode);
        }
    }
 

public void triggerComplete(Trigger trigger, JobExecutionContext context,
        CompletedExecutionInstruction triggerInstructionCode) {
    if (!getLog().isInfoEnabled()) {
        return;
    } 
    
    String instrCode = "UNKNOWN";
    if (triggerInstructionCode == CompletedExecutionInstruction.DELETE_TRIGGER) {
        instrCode = "DELETE TRIGGER";
    } else if (triggerInstructionCode == CompletedExecutionInstruction.NOOP) {
        instrCode = "DO NOTHING";
    } else if (triggerInstructionCode == CompletedExecutionInstruction.RE_EXECUTE_JOB) {
        instrCode = "RE-EXECUTE JOB";
    } else if (triggerInstructionCode == CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_COMPLETE) {
        instrCode = "SET ALL OF JOB'S TRIGGERS COMPLETE";
    } else if (triggerInstructionCode == CompletedExecutionInstruction.SET_TRIGGER_COMPLETE) {
        instrCode = "SET THIS TRIGGER COMPLETE";
    }

    Object[] args = {
        trigger.getKey().getName(), trigger.getKey().getGroup(),
        trigger.getPreviousFireTime(), trigger.getNextFireTime(),
        new java.util.Date(), context.getJobDetail().getKey().getName(),
        context.getJobDetail().getKey().getGroup(),
        Integer.valueOf(context.getRefireCount()),
        triggerInstructionCode.toString(), instrCode
    };

    getLog().info(MessageFormat.format(getTriggerCompleteMessage(), args));
}
 

@Test
public void testResetErrorTrigger() throws Exception {
  JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("job1", "jobGroup1").storeDurably(true).build();
  this.jobStore.storeJob(jobDetail, false);
  Date baseFireTimeDate = DateBuilder.evenMinuteDateAfterNow();
  long baseFireTime = baseFireTimeDate.getTime();

  // create and store a trigger
  OperableTrigger trigger1 =
      new SimpleTriggerImpl("trigger1", "triggerGroup1", jobDetail.getKey().getName(),
          jobDetail.getKey().getGroup(), new Date(baseFireTime + 200000),
          new Date(baseFireTime + 200000), 2, 2000);

  trigger1.computeFirstFireTime(null);
  jobStore.storeTrigger(trigger1, false);

  long firstFireTime = new Date(trigger1.getNextFireTime().getTime()).getTime();


  // pretend to fire it
  List<OperableTrigger> aqTs = jobStore.acquireNextTriggers(
      firstFireTime + 10000, 1, 0L);
  assertEquals(trigger1.getKey(), aqTs.get(0).getKey());

  List<TriggerFiredResult> fTs = jobStore.triggersFired(aqTs);
  TriggerFiredResult ft = fTs.get(0);

  // get the trigger into error state
  jobStore.triggeredJobComplete(ft.getTriggerFiredBundle().getTrigger(), ft.getTriggerFiredBundle().getJobDetail(),
      Trigger.CompletedExecutionInstruction.SET_TRIGGER_ERROR);
  TriggerState state = jobStore.getTriggerState(trigger1.getKey());
  assertEquals(TriggerState.ERROR, state);

  // test reset
  jobStore.resetTriggerFromErrorState(trigger1.getKey());
  state = jobStore.getTriggerState(trigger1.getKey());
  assertEquals(TriggerState.NORMAL, state);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void triggerComplete(Trigger trigger, JobExecutionContext ctx,
        CompletedExecutionInstruction cei) {
}
 

@Override
public void triggerComplete(Trigger arg0, JobExecutionContext arg1,
        CompletedExecutionInstruction arg2) {
}
 

@Override
public void triggerComplete(Trigger arg0, JobExecutionContext arg1,
        CompletedExecutionInstruction arg2) {
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context,
		CompletedExecutionInstruction triggerInstructionCode) {
	System.out.println("triggerComplete:" + trigger.toString());
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
    System.out.println("TriggerListner.triggerComplete()");
}
 

@Override
public void triggeredJobComplete(OperableTrigger trigger, JobDetail jobDetail,
                                 CompletedExecutionInstruction triggerInstCode) {
  clusteredJobStore.triggeredJobComplete(trigger, jobDetail, triggerInstCode);
}
 

public void triggerComplete(
    Trigger trigger,
    JobExecutionContext context,
    CompletedExecutionInstruction triggerInstructionCode) {
}
 

protected void notifyJobStoreJobComplete(OperableTrigger trigger, JobDetail detail, CompletedExecutionInstruction instCode) {
    resources.getJobStore().triggeredJobComplete(trigger, detail, instCode);
}
 

protected void notifyJobStoreJobVetoed(OperableTrigger trigger, JobDetail detail, CompletedExecutionInstruction instCode) {
    resources.getJobStore().triggeredJobComplete(trigger, detail, instCode);
}
 

protected void mesure(String suffix, Trigger trigger, JobExecutionContext context,
		CompletedExecutionInstruction triggerInstructionCode) {
	if (null == this.counterService && null == this.gaugeService) {
		return;
	}
	getLog().trace("exposing metrics");

	String jobKey = METRIC_PREFIX + METRIC_INFIX_TYPE_JOB + trigger.getJobKey().getGroup() + SEPARATOR
			+ trigger.getJobKey().getName() + suffix;
	String triggerKey = METRIC_PREFIX + METRIC_INFIX_TYPE_TRIGGER + trigger.getKey().getGroup() + SEPARATOR
			+ trigger.getKey().getName() + suffix;

	if (null != this.counterService) {
		if (this.metricSettings.isEnableJobGroupCounter()) {
			// count job group
			this.counterService.increment(METRIC_PREFIX + METRIC_INFIX_TYPE_JOB + trigger.getJobKey().getGroup() + suffix);
		}
		if (this.metricSettings.isEnableJobCounter()) {
			// count job group and job name
			this.counterService.increment(jobKey);
		}
		if (this.metricSettings.isEnableTriggerCounter()) {
			// count trigger group and trigger name
			this.counterService.increment(triggerKey);
		}
		
		// count finish code
		if (this.metricSettings.isEnableExecutionInstructionCounter() && null != triggerInstructionCode) {
			if (this.metricSettings.isEnableTriggerCounter()) {
				this.counterService.increment(triggerKey + SEPARATOR + triggerInstructionCode.name());
			}
			if (this.metricSettings.isEnableJobCounter()) {
				// if a job has more than one trigger .
				this.counterService.increment(jobKey + SEPARATOR + triggerInstructionCode.name());
			}
		}
	}

	if (null != context && null != this.gaugeService) {
		if (context.getJobRunTime() != -1) {
			if (this.metricSettings.isEnableTriggerGauges()) {
				gaugeService.submit(triggerKey, Long.valueOf(context.getJobRunTime()).doubleValue());
			}
			if (this.metricSettings.isEnableJobGauges()) {
				// if a job has more than one trigger .
				gaugeService.submit(jobKey, Long.valueOf(context.getJobRunTime()).doubleValue());
			}
		}
	}

}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context,
		CompletedExecutionInstruction triggerInstructionCode) {
	mesure(METRIC_SUFFIX_COMPLETE, trigger, context, triggerInstructionCode);
}
 

@Override
public void triggeredJobComplete(final OperableTrigger trigger,
                                 final JobDetail jobDetail,
                                 final CompletedExecutionInstruction instruction)
{
  log.debug("Triggered job complete: trigger={}, jobDetail={}, instruction={}", trigger, jobDetail, instruction);

  executeWriteAndPropagate(db -> {

    // back from quartz; save job-data-map if needed
    if (jobDetail.getJobDataMap().isDirty() && jobDetail.isPersistJobDataAfterExecution()) {
      JobDetailEntity jobDetailEntity = jobDetailEntityAdapter.readByKey(db, jobDetail.getKey());

      if (jobDetailEntity != null) {
        jobDetailEntity.setValue(jobDetail);
        jobDetailEntityAdapter.editEntity(db, jobDetailEntity);
      }
    }

    // unblock triggers if concurrent execution is disallowed
    if (jobDetail.isConcurrentExectionDisallowed()) {
      unblockTriggers(db, jobDetail);
      signaler.signalSchedulingChange(0L);
    }

    TriggerEntity triggerEntity = triggerEntityAdapter.readByKey(db, trigger.getKey());

    if (triggerEntity != null) {
      switch (instruction) {
        case DELETE_TRIGGER:
          if (trigger.getNextFireTime() == null) {
            // double check for possible reschedule within job execution, which would cancel the need to delete
            if (triggerEntity.getValue().getNextFireTime() == null) {
              triggerEntityAdapter.deleteEntity(db, triggerEntity);
            }
          }
          else {
            triggerEntityAdapter.deleteEntity(db, triggerEntity);
            signaler.signalSchedulingChange(0L);
          }
          break;

        case SET_TRIGGER_COMPLETE:
          triggerEntity.setState(COMPLETE);
          triggerEntityAdapter.editEntity(db, triggerEntity);
          signaler.signalSchedulingChange(0L);
          break;

        case SET_TRIGGER_ERROR:
          triggerEntity.setState(ERROR);
          triggerEntityAdapter.editEntity(db, triggerEntity);
          signaler.signalSchedulingChange(0L);
          break;

        case SET_ALL_JOB_TRIGGERS_COMPLETE:
          updateTriggerState(db, jobDetail.getKey(), COMPLETE);
          signaler.signalSchedulingChange(0L);
          break;

        case SET_ALL_JOB_TRIGGERS_ERROR:
          updateTriggerState(db, jobDetail.getKey(), ERROR);
          signaler.signalSchedulingChange(0L);
          break;
      }
    }

    return null;
  });
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context,
		CompletedExecutionInstruction triggerInstructionCode) {
	closeTrace(context);
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context,
		CompletedExecutionInstruction triggerInstructionCode) {
	complete(context.getResult());
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
    Date complete = Date.from(context.getFireTime().toInstant().plusMillis(context.getJobRunTime()));
    eventManager.createTriggerEvent (TriggerEvent.TRIGGER_EVENT_TYPE.COMPLETE, context.getJobDetail().getKey(), trigger.getKey(), complete, "Trigger complete", getServerId());
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
    info (EVENTTYPE.TRIGGER_COMPLETED, trigger, context, null, triggerInstructionCode);        
}
 

private void info (EVENTTYPE eventType, Trigger trig, JobExecutionContext context, JobExecutionException exception, CompletedExecutionInstruction instructionCode) {
    JobDetail
        detail = (context != null)?context.getJobDetail():null;
    final JobDataMap
        dataMap = (context != null)?context.getMergedJobDataMap():null;
    final String
        jobName = (detail != null)?detail.getKey().getName():null,
        jobDesc = (detail != null)?detail.getDescription():null;
    final Class
        jobClass = (detail != null)?detail.getJobClass():null;
    final Trigger
        trigger = (trig != null)?trig:((context != null)?context.getTrigger():null);
    final String
        trigName = (trigger != null)?trigger.getKey().getName():null,
        trigDesc = (trigger != null)?trigger.getDescription():null;
    final Date
        trigStart = (trigger != null)?trigger.getStartTime():null,
        trigEnd = (trigger != null)?trigger.getEndTime():null;

    StringBuilder
        sb = new StringBuilder();

    switch (eventType)
    {
        case JOB_EXECUTING:
        {
            sb.append("Job Executing: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            sb.append("]");
            break;
        }
        case JOB_VETOED:
        {
            sb.append("Job Vetoed: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            break;
        }
        case JOB_EXECUTED:
        {
            sb.append("Job Executed: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
              .append(", class: ").append(jobClass.getName());

            if (exception != null)
            {
                sb.append (", exception: ").append(exception.getMessage());
                if (exception.getCause() != null)
                {
                  sb.append(", exception cause: ").append(exception.getCause().getClass().getName());
                }
            }
            sb.append("]");

            break;
        }
        case TRIGGER_FIRED:
        {
            sb.append("Trigger Fired: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart != null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd != null)?trigEnd.toString():null);
            sb.append(", job: ").append(jobName).append(", job description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            sb.append("]");
            break;
        }
        case TRIGGER_MISFIRED:
        {
            sb.append("Trigger Misfired: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart!=null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd!=null)?trigEnd.toString():null);
            sb.append("]");
            break;
        }
        case TRIGGER_COMPLETED:
        {
            sb.append("Trigger Completed: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart!=null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd!=null)?trigEnd.toString():null);
            sb.append(", job: ").append(jobName).append(", job description: ").append((jobDesc != null)?jobDesc:"")
              .append(", class: ").append(jobClass.getName())
              .append(", execution result: ").append(instructionCode);
            sb.append("]");
            break;
        }
    }
    if (log.isDebugEnabled())
    {
    	log.debug(sb.toString());
    }
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
    Date complete = Date.from(context.getFireTime().toInstant().plusMillis(context.getJobRunTime()));
    eventManager.createTriggerEvent (TriggerEvent.TRIGGER_EVENT_TYPE.COMPLETE, context.getJobDetail().getKey(), trigger.getKey(), complete, "Trigger complete", getServerId());
}
 

@Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
    info (EVENTTYPE.TRIGGER_COMPLETED, trigger, context, null, triggerInstructionCode);        
}
 

private void info (EVENTTYPE eventType, Trigger trig, JobExecutionContext context, JobExecutionException exception, CompletedExecutionInstruction instructionCode) {
    JobDetail
        detail = (context != null)?context.getJobDetail():null;
    final JobDataMap
        dataMap = (context != null)?context.getMergedJobDataMap():null;
    final String
        jobName = (detail != null)?detail.getKey().getName():null,
        jobDesc = (detail != null)?detail.getDescription():null;
    final Class
        jobClass = (detail != null)?detail.getJobClass():null;
    final Trigger
        trigger = (trig != null)?trig:((context != null)?context.getTrigger():null);
    final String
        trigName = (trigger != null)?trigger.getKey().getName():null,
        trigDesc = (trigger != null)?trigger.getDescription():null;
    final Date
        trigStart = (trigger != null)?trigger.getStartTime():null,
        trigEnd = (trigger != null)?trigger.getEndTime():null;

    StringBuilder
        sb = new StringBuilder();

    switch (eventType)
    {
        case JOB_EXECUTING:
        {
            sb.append("Job Executing: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            sb.append("]");
            break;
        }
        case JOB_VETOED:
        {
            sb.append("Job Vetoed: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            break;
        }
        case JOB_EXECUTED:
        {
            sb.append("Job Executed: [");
            sb.append("name: ").append(jobName).append(", description: ").append((jobDesc != null)?jobDesc:"")
              .append(", class: ").append(jobClass.getName());

            if (exception != null)
            {
                sb.append (", exception: ").append(exception.getMessage());
                if (exception.getCause() != null)
                {
                  sb.append(", exception cause: ").append(exception.getCause().getClass().getName());
                }
            }
            sb.append("]");

            break;
        }
        case TRIGGER_FIRED:
        {
            sb.append("Trigger Fired: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart != null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd != null)?trigEnd.toString():null);
            sb.append(", job: ").append(jobName).append(", job description: ").append((jobDesc != null)?jobDesc:"")
                    .append(", class: ").append(jobClass.getName());
            sb.append("]");
            break;
        }
        case TRIGGER_MISFIRED:
        {
            sb.append("Trigger Misfired: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart!=null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd!=null)?trigEnd.toString():null);
            sb.append("]");
            break;
        }
        case TRIGGER_COMPLETED:
        {
            sb.append("Trigger Completed: [");
            sb.append("trigger: ").append(trigName).append(", trigger description: ").append((trigDesc != null)?trigDesc:"")
              .append(", start: ").append((trigStart!=null)?trigStart.toString():null)
              .append(", end: ").append((trigEnd!=null)?trigEnd.toString():null);
            sb.append(", job: ").append(jobName).append(", job description: ").append((jobDesc != null)?jobDesc:"")
              .append(", class: ").append(jobClass.getName())
              .append(", execution result: ").append(instructionCode);
            sb.append("]");
            break;
        }
    }
    if (log.isDebugEnabled())
    {
    	log.debug(sb.toString());
    }
}
 

/**
 * <p>
 * Called by the <code>{@link Scheduler}</code> when a <code>{@link Trigger}</code>
 * has fired, it's associated <code>{@link org.quartz.JobDetail}</code>
 * has been executed, and it's <code>triggered(xx)</code> method has been
 * called.
 * </p>
 * 
 * @param trigger
 *          The <code>Trigger</code> that was fired.
 * @param context
 *          The <code>JobExecutionContext</code> that was passed to the
 *          <code>Job</code>'s<code>execute(xx)</code> method.
 * @param triggerInstructionCode
 *          the result of the call on the <code>Trigger</code>'s<code>triggered(xx)</code>
 *          method.
 */
void triggerComplete(Trigger trigger, JobExecutionContext context,
        CompletedExecutionInstruction triggerInstructionCode);