org.quartz.UnableToInterruptJobException Java Examples

public String processActionKill() {
	if (getIsKillable()) {
		InterruptableJob job = (InterruptableJob)jec.getJobInstance();
		try {
			job.interrupt();
		} catch (UnableToInterruptJobException e) {
			log.error(e.getMessage(), e);
		}
		FacesContext.getCurrentInstance().addMessage(null, 
				new FacesMessage(FacesMessage.SEVERITY_INFO, 
						parentTool.rb.getFormattedMessage("kill_message", 
								new String[] {jec.getJobDetail().getKey().getName()}), null));
	}
	
	return "runningJobs";
}
 

@Override
public void interruptJob(String jobName) {
    List<JobExecutionContext> runningJobs = getRunningJobs();
    for (JobExecutionContext jobCtx : runningJobs) {
        if (jobName.equals(jobCtx.getJobDetail().getName())) {
            // if so...
            try {
                ((Job) jobCtx.getJobInstance()).interrupt();
            }
            catch (UnableToInterruptJobException ex) {
                LOG.warn("Unable to perform job interrupt", ex);
            }
            break;
        }
    }

}
 

@Override
protected void shutDown()
    throws Exception {
  LOG.info("Stopping the job scheduler");
  closer.close();
  cancelRequested = true;
  List<JobExecutionContext> currentExecutions = this.scheduler.getScheduler().getCurrentlyExecutingJobs();
  for (JobExecutionContext jobExecutionContext : currentExecutions) {
    try {
      this.scheduler.getScheduler().interrupt(jobExecutionContext.getFireInstanceId());
    } catch (UnableToInterruptJobException e) {
      LOG.error("Failed to cancel job " + jobExecutionContext.getJobDetail().getKey(), e);
    }
  }

  ExecutorsUtils.shutdownExecutorService(this.jobExecutor, Optional.of(LOG));
}
 

public String processActionKill() {
	if (getIsKillable()) {
		InterruptableJob job = (InterruptableJob)jec.getJobInstance();
		try {
			job.interrupt();
		} catch (UnableToInterruptJobException e) {
			log.error(e.getMessage(), e);
		}
		FacesContext.getCurrentInstance().addMessage(null, 
				new FacesMessage(FacesMessage.SEVERITY_INFO, 
						parentTool.rb.getFormattedMessage("kill_message", 
								new String[] {jec.getJobDetail().getKey().getName()}), null));
	}
	
	return "runningJobs";
}
 

/**
 * Interrupt the identified InterruptableJob executing in this Scheduler instance.
 *  
 * <p>
 * This method is not cluster aware.  That is, it will only interrupt 
 * instances of the identified InterruptableJob currently executing in this 
 * Scheduler instance, not across the entire cluster.
 * </p>
 * 
 * @see org.quartz.core.RemotableQuartzScheduler#interrupt(JobKey)
 */
public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
    List<JobExecutionContext> jobs = getCurrentlyExecutingJobs();
    
    Job job = null;
    
    for(JobExecutionContext jec : jobs) {
        if (jec.getFireInstanceId().equals(fireInstanceId)) {
            job = jec.getJobInstance();
            if (job instanceof InterruptableJob) {
                ((InterruptableJob)job).interrupt();
                return true;
            } else {
                throw new UnableToInterruptJobException(
                    "Job " + jec.getJobDetail().getKey() +
                    " can not be interrupted, since it does not implement " +                        
                    InterruptableJob.class.getName());
            }
        }                        
    }
    
    return false;
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
  if (task instanceof Cancelable && !((Cancelable) task).isCanceled()) {
    ((Cancelable) task).cancel();
    eventManager.post(new TaskEventCanceled(taskInfo));
  }
  else if (task != null) {
    log.info("Task not cancelable: {}", task.taskConfiguration().getTaskLogName());
    throw new UnableToInterruptJobException("Task not cancelable: " + task);
  }
  // else premature/too-late; ignore
}
 

public boolean interrupt(final String fireInstanceId) {
    try {
        return scheduler.interrupt(fireInstanceId);
    } catch (final UnableToInterruptJobException e) {
        throw new QuartzInterruptException("Failed to interrupt the job.",
                e);
    }
}
 

public boolean interrupt(final JobKey jobKey) {
    try {
        return scheduler.interrupt(jobKey);
    } catch (final UnableToInterruptJobException e) {
        throw new QuartzInterruptException("Failed to interrupt the job.",
                e);
    }
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {

    if (mailSource != null) {
        mailSource.close();
    }

}
 

/**
 * {@inheritDoc}
 */
@Override
public void stop() {
    client.destroy();
    try {
        scheduler.interrupt(jobDetail.getKey());
    } catch (UnableToInterruptJobException e) {
        log.error("RestSource error. " + e.getMessage());
    }
}
 

/**
 * @throws UnableToInterruptJobException
 */
@Override
public void interrupt() throws UnableToInterruptJobException {
    // ask the step to interrupt
    if (currentStep != null) {
        currentStep.interrupt();
    }
    // also attempt to interrupt the thread, to cause an InterruptedException if the step ever waits or sleeps
    workerThread.interrupt();
}
 

/**
 * Used by {@link QuartzTaskFuture#cancel(boolean)}.
 */
@Guarded(by = STARTED)
public boolean cancelJob(final JobKey jobKey) {
  checkNotNull(jobKey);

  try (TcclBlock tccl = TcclBlock.begin(this)) {
    return scheduler.interrupt(jobKey);
  }
  catch (UnableToInterruptJobException e) {
    log.debug("Unable to interrupt job with key: {}", jobKey, e);
  }
  return false;
}
 

/**
 * @see org.quartz.Scheduler#interrupt(java.lang.String, java.lang.String)
 */
public boolean interrupt(String jobName, String groupName) throws UnableToInterruptJobException  {
    try {
        return getRemoteScheduler().interrupt(schedCtxt, jobName, groupName);
    } catch (RemoteException re) {
        throw new UnableToInterruptJobException(invalidateHandleCreateException(
                "Error communicating with remote scheduler.", re));
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

/**
 * @see org.quartz.Scheduler#interrupt(JobKey)
 */
public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException  {
    try {
        return (Boolean)invoke(
                "interruptJob",
                new Object[] { jobKey.getName(), jobKey.getGroup() },
                new String[] { String.class.getName(), String.class.getName() });
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
    try {
        return (Boolean)invoke(
                "interruptJob",
                new Object[] { fireInstanceId },
                new String[] { String.class.getName() });
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

/**
 * @see org.quartz.Scheduler#interrupt(JobKey)
 */
public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException  {
    try {
        return getRemoteScheduler().interrupt(jobKey);
    } catch (RemoteException re) {
        throw new UnableToInterruptJobException(invalidateHandleCreateException(
                "Error communicating with remote scheduler.", re));
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

/**
 * Interrupt all instances of the identified InterruptableJob executing in 
 * this Scheduler instance.
 *  
 * <p>
 * This method is not cluster aware.  That is, it will only interrupt 
 * instances of the identified InterruptableJob currently executing in this 
 * Scheduler instance, not across the entire cluster.
 * </p>
 * 
 * @see org.quartz.core.RemotableQuartzScheduler#interrupt(JobKey)
 */
public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException {

    List<JobExecutionContext> jobs = getCurrentlyExecutingJobs();
    
    JobDetail jobDetail = null;
    Job job = null;
    
    boolean interrupted = false;
    
    for(JobExecutionContext jec : jobs) {
        jobDetail = jec.getJobDetail();
        if (jobKey.equals(jobDetail.getKey())) {
            job = jec.getJobInstance();
            if (job instanceof InterruptableJob) {
                ((InterruptableJob)job).interrupt();
                interrupted = true;
            } else {
                throw new UnableToInterruptJobException(
                        "Job " + jobDetail.getKey() +
                        " can not be interrupted, since it does not implement " +                        
                        InterruptableJob.class.getName());
            }
        }                        
    }
    
    return interrupted;
}
 

/**
 * @see org.quartz.Scheduler#interrupt(java.lang.String, java.lang.String)
 */
public boolean interrupt(String jobName, String groupName) throws UnableToInterruptJobException  {
    try {
        return ((Boolean)invoke(
                "interrupt", 
                new Object[] { schedulingContext, jobName, groupName}, 
                new String[] { SchedulingContext.class.getName(), String.class.getName(), String.class.getName() })).booleanValue();
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
    try {
        return getRemoteScheduler().interrupt(fireInstanceId);
    } catch (RemoteException re) {
        throw new UnableToInterruptJobException(invalidateHandleCreateException(
                "Error communicating with remote scheduler.", re));
    } catch (SchedulerException se) {
        throw new UnableToInterruptJobException(se);
    }
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
  log.info("Job was interrupted");
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
	System.out.println("Stopping thread... ");
	toStopFlag = false;
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
	System.out.println("Stopping thread... ");
	toStopFlag = false;
}
 

public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException {
    return sched.interrupt(jobKey);
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
	run = false;
}
 

public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
    return sched.interrupt(fireInstanceId);
}
 

@Override
public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
    throw new UnsupportedOperationException();
}
 

@Override
public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException {
    throw new UnsupportedOperationException();
}
 

@Override
public void interrupt() throws UnableToInterruptJobException {
    getDelegate().interrupt();
}
 

@Override
public void interrupt()
    throws UnableToInterruptJobException {
  log.info("Job was interrupted");
}
 

public boolean interrupt(String fireInstanceId) throws UnableToInterruptJobException {
	// TODO Auto-generated method stub
	return false;
}