/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cocoon.components.cron;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Date;
import java.util.Map;
import java.util.NoSuchElementException;
import org.apache.avalon.framework.CascadingException;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.activity.Startable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.components.thread.RunnableManager;
import org.apache.cocoon.components.thread.ThreadPool;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.impl.DirectSchedulerFactory;
import org.quartz.impl.jdbcjobstore.InvalidConfigurationException;
import org.quartz.impl.jdbcjobstore.JobStoreSupport;
import org.quartz.simpl.RAMJobStore;
import org.quartz.spi.JobStore;
import org.quartz.spi.TriggerFiredBundle;
import org.quartz.utils.ConnectionProvider;
import org.quartz.utils.DBConnectionManager;
import org.quartz.utils.JNDIConnectionProvider;
/**
* This component can either schedule jobs or directly execute one.
*
* @author <a href="mailto:giacomo@apache.org">Giacomo Pati</a>
* @version CVS $Id$
*
* @since 2.1.1
*/
public class QuartzJobScheduler extends AbstractLogEnabled
implements JobScheduler, Component, ThreadSafe,
Serviceable, Configurable, Startable,
Disposable, Contextualizable, Initializable {
/** Map key for the component role */
static final String DATA_MAP_ROLE = "QuartzJobScheduler.ROLE";
/** Map key for the job object */
static final String DATA_MAP_OBJECT = "QuartzJobScheduler.Object";
/** Map key for the job name */
static final String DATA_MAP_NAME = "QuartzJobScheduler.JobName";
/** Map key for the avalon context */
static final String DATA_MAP_CONTEXT = "QuartzJobScheduler.Context";
/** Map key for the service manager */
static final String DATA_MAP_MANAGER = "QuartzJobScheduler.ServiceManager";
/** Map key for the logger */
static final String DATA_MAP_LOGGER = "QuartzJobScheduler.Logger";
/** Map key for the concurrent run property */
static final String DATA_MAP_RUN_CONCURRENT = "QuartzJobScheduler.RunConcurrently";
/** Map key for additional Parameters */
static final String DATA_MAP_PARAMETERS = "QuartzJobScheduler.Parameters";
/** Map key for additional Object Map */
static final String DATA_MAP_OBJECTMAP = "QuartzJobScheduler.Map";
/* Map key for the last JobExecutionContext
static final String DATA_MAP_JOB_EXECUTION_CONTEXT = "QuartzJobScheduler.JobExecutionContext"; */
/** Map key for the run status */
static final String DATA_MAP_KEY_ISRUNNING = "QuartzJobExecutor.isRunning";
/** The group name */
static final String DEFAULT_QUARTZ_JOB_GROUP = "Cocoon";
/** The scheduler name */
static final String DEFAULT_QUARTZ_SCHEDULER_NAME = "Cocoon";
/** The Avalon Context instance */
private Context context;
/** The PooledExecutor instance */
private ThreadPool executor;
/** The quartz scheduler */
private Scheduler scheduler;
/** The ServiceManager instance */
private ServiceManager manager;
/** The configuration, parsed in initialize() */
private Configuration config;
/** Should we wait for running jobs to terminate on shutdown ? */
private boolean m_shutdownGraceful;
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#getJobNames()
*/
public String[] getJobNames() {
try {
final String[] names = scheduler.getJobNames(DEFAULT_QUARTZ_JOB_GROUP);
Arrays.sort(names);
return names;
} catch (final SchedulerException se) {
getLogger().error("could not gather job names", se);
}
return new String[0];
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#getSchedulerEntry(java.lang.String)
*/
public JobSchedulerEntry getJobSchedulerEntry(String jobname) {
try {
return new QuartzJobSchedulerEntry(jobname, scheduler);
} catch (final Exception e) {
getLogger().error("cannot create QuartzJobSchedulerEntry", e);
}
return null;
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#addJob(java.lang.String, java.lang.Object, java.lang.String, boolean, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public void addJob(final String name, final Object job, final String cronSpec, final boolean canRunConcurrently,
final Parameters params, final Map objects)
throws CascadingException {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_OBJECT, job);
addJob(name, jobDataMap, cronSpec, canRunConcurrently, params, objects);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#addJob(java.lang.String, java.lang.String, java.lang.String, boolean, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public void addJob(final String name, final String jobrole, final String cronSpec,
final boolean canRunConcurrently, final Parameters params, final Map objects)
throws CascadingException {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_ROLE, jobrole);
addJob(name, jobDataMap, cronSpec, canRunConcurrently, params, objects);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#addJob(java.lang.String, java.lang.Object, java.lang.String, boolean)
*/
public void addJob(final String name, final Object job, final String cronSpec, final boolean canRunConcurrently)
throws CascadingException {
if (!(job instanceof CronJob) && !(job instanceof Runnable) && !(job instanceof Job)) {
throw new CascadingException("Job object is neither an instance of " + CronJob.class.getName() + "," +
Runnable.class.getName() + " nor " + Job.class.getName());
}
addJob(name, job, cronSpec, canRunConcurrently, null, null);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#addJob(java.lang.String, java.lang.String, java.lang.String, boolean)
*/
public void addJob(final String name, final String jobrole, final String cronSpec, final boolean canRunConcurrently)
throws CascadingException {
addJob(name, jobrole, cronSpec, canRunConcurrently, null, null);
}
/**
* Schedule a period job. Note that if a Job already has same name then it is overwritten.
*
* @param name the name of the job
* @param jobrole The Avalon components role name of the job itself
* @param period Every period seconds this job is started
* @param canRunConcurrently whether this job can run even previous scheduled runs are still running
* @param params additional Parameters to be passed to the job
* @param objects additional objects to be passed to the job
*
* @throws CascadingException in case of failures
*/
public void addPeriodicJob(String name, String jobrole, long period, boolean canRunConcurrently, Parameters params,
Map objects)
throws CascadingException {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_ROLE, jobrole);
final long ms = period * 1000;
final SimpleTrigger timeEntry =
new SimpleTrigger(name, DEFAULT_QUARTZ_JOB_GROUP, new Date(System.currentTimeMillis() + ms), null,
SimpleTrigger.REPEAT_INDEFINITELY, ms);
addJob(name, jobDataMap, timeEntry, canRunConcurrently, params, objects);
}
/**
* Schedule a periodic job. The job is started the first time when the period has passed. Note that if a job with
* the same name has already beed added it is overwritten.
*
* @param name the name of the job
* @param job The job object itself. It must implement either CronJob, Runnable or might also be an implementation
* specific class (i.e. org.quartz.Job)
* @param period Every period seconds this job is started
* @param canRunConcurrently whether this job can run even previous scheduled runs are still running
* @param params Additional Parameters to setup CronJob
* @param objects A Map with additional object to setup CronJob
*/
public void addPeriodicJob(String name, Object job, long period, boolean canRunConcurrently, Parameters params,
Map objects)
throws CascadingException {
if (!(job instanceof CronJob) && !(job instanceof Runnable) && !(job instanceof Job)) {
throw new CascadingException("Job object is neither an instance of " + CronJob.class.getName() + "," +
Runnable.class.getName() + " nor " + Job.class.getName());
}
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_OBJECT, job);
final long ms = period * 1000;
final SimpleTrigger timeEntry =
new SimpleTrigger(name, DEFAULT_QUARTZ_JOB_GROUP, new Date(System.currentTimeMillis() + ms), null,
SimpleTrigger.REPEAT_INDEFINITELY, ms);
addJob(name, jobDataMap, timeEntry, canRunConcurrently, params, objects);
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration)
*/
public void configure(final Configuration config)
throws ConfigurationException {
this.config = config;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.activity.Disposable#dispose()
*/
public void dispose() {
try {
if (getLogger().isInfoEnabled()) {
getLogger().info("shutting down scheduler " +
(m_shutdownGraceful ? "graceful (waiting for running jobs to complete)"
: "immediately (killing running jobs)"));
}
scheduler.shutdown(m_shutdownGraceful);
scheduler = null;
} catch (final SchedulerException se) {
getLogger().error("failure during scheduler shutdown", se);
}
this.executor = null;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.context.Contextualizable#contextualize(org.apache.avalon.framework.context.Context)
*/
public void contextualize(Context context) throws ContextException {
this.context = context;
}
public void initialize() throws Exception {
try {
// If cocoon reloads (or is it the container that reload us?)
// we cannot create the same scheduler again
final String runID = new Date().toString().replace(' ', '_');
final QuartzThreadPool pool = createThreadPool(this.config.getChild("thread-pool"));
final JobStore store = createJobStore(DEFAULT_QUARTZ_SCHEDULER_NAME, runID, this.config.getChild("store"));
DirectSchedulerFactory.getInstance().createScheduler(DEFAULT_QUARTZ_SCHEDULER_NAME, runID, pool, store);
// scheduler = DirectSchedulerFactory.getInstance().getScheduler(DEFAULT_QUARTZ_SCHEDULER_NAME, runID);
scheduler = DirectSchedulerFactory.getInstance().getScheduler(DEFAULT_QUARTZ_SCHEDULER_NAME);
} catch (final SchedulerException se) {
throw new ConfigurationException("cannot create a quartz scheduler", se);
}
final Configuration[] triggers = this.config.getChild("triggers").getChildren("trigger");
createTriggers(triggers);
// We're finished with the configuration
this.config = null;
if (getLogger().isDebugEnabled() && (triggers.length == 0)) {
getLogger().debug("no triggers configured at startup");
}
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireTarget(java.lang.Object)
*/
public boolean fireJob(final Object job) {
return fireJob(job.getClass().getName(), job);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireTarget(java.lang.String)
*/
public boolean fireJob(final String jobrole) {
Object job = null;
try {
job = manager.lookup(jobrole);
return fireJob(jobrole, job);
} catch (final ServiceException se) {
getLogger().error("cannot fire job " + jobrole, se);
} finally {
manager.release(job);
}
return false;
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJob(java.lang.Object, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public boolean fireJob(final Object job, final Parameters params, final Map objects)
throws CascadingException {
if (job instanceof ConfigurableCronJob) {
((ConfigurableCronJob)job).setup(params, objects);
}
return fireJob(job);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJob(java.lang.String, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public boolean fireJob(final String jobrole, final Parameters params, final Map objects)
throws CascadingException {
Object job = null;
try {
job = manager.lookup(jobrole);
if (job instanceof ConfigurableCronJob) {
((ConfigurableCronJob)job).setup(params, objects);
}
return fireJob(jobrole, job);
} catch (final ServiceException se) {
getLogger().error("cannot fire job " + jobrole, se);
} finally {
manager.release(job);
}
return false;
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJobAt(java.util.Date, java.lang.String, java.lang.Object)
*/
public void fireJobAt(final Date date, final String name, final Object job)
throws CascadingException {
fireJobAt(date, name, job, null, null);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJobAt(java.util.Date, java.lang.String, java.lang.String)
*/
public void fireJobAt(final Date date, final String name, final String jobrole)
throws CascadingException {
fireJobAt(date, name, jobrole, null, null);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJobAt(java.util.Date, java.lang.String, java.lang.Object, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public void fireJobAt(final Date date, final String name, final Object job, final Parameters params,
final Map objects)
throws CascadingException {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_OBJECT, job);
addJob(name, jobDataMap, date, true, params, objects);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireJobAt(java.util.Date, java.lang.String, java.lang.String, org.apache.avalon.framework.parameters.Parameters, java.util.Map)
*/
public void fireJobAt(final Date date, final String name, final String jobrole, final Parameters params,
final Map objects)
throws CascadingException {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_ROLE, jobrole);
addJob(name, jobDataMap, date, true, params, objects);
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#removeJob(java.lang.String)
*/
public void removeJob(final String name)
throws NoSuchElementException {
try {
if (scheduler.deleteJob(name, DEFAULT_QUARTZ_JOB_GROUP)) {
getLogger().info("job " + name + " removed by request");
} else {
getLogger().error("couldn't remove requested job " + name);
}
} catch (final SchedulerException se) {
getLogger().error("cannot remove job " + name, se);
throw new NoSuchElementException(se.getMessage());
}
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.service.Serviceable#service(org.apache.avalon.framework.service.ServiceManager)
*/
public void service(final ServiceManager manager)
throws ServiceException {
this.manager = manager;
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.activity.Startable#start()
*/
public void start()
throws Exception {
scheduler.start();
}
/* (non-Javadoc)
* @see org.apache.avalon.framework.activity.Startable#stop()
*/
public void stop()
throws Exception {
scheduler.standby();
}
/**
* Add a job to the scheduler
*
* @param name The name of the job to add
* @param jobDataMap The JobDataMap to use for this job
* @param date the date to schedule this job
* @param canRunConcurrently whether this job can be run concurrently
* @param params Additional Parameters to setup CronJob
* @param objects A Map with additional object to setup CronJob
*
* @throws CascadingException thrown in case of errors
*/
private void addJob(final String name, final JobDataMap jobDataMap, final Date date,
final boolean canRunConcurrently, final Parameters params, final Map objects)
throws CascadingException {
final SimpleTrigger trigger = new SimpleTrigger(name, DEFAULT_QUARTZ_JOB_GROUP, date);
addJob(name, jobDataMap, trigger, canRunConcurrently, params, objects);
}
/**
* Add a job to the scheduler
*
* @param name The name of the job to add
* @param jobDataMap The JobDataMap to use for this job
* @param cronSpec a Cron time expression
* @param canRunConcurrently whether this job can be run concurrently
* @param params Additional Parameters to setup CronJob
* @param objects A Map with additional object to setup CronJob
*
* @throws CascadingException thrown in case of errors
*/
private void addJob(final String name, final JobDataMap jobDataMap, final String cronSpec,
final boolean canRunConcurrently, final Parameters params, final Map objects)
throws CascadingException {
final CronTrigger cronJobEntry = new CronTrigger(name, DEFAULT_QUARTZ_JOB_GROUP);
try {
cronJobEntry.setCronExpression(cronSpec);
} catch (final ParseException pe) {
throw new CascadingException(pe.getMessage(), pe);
}
addJob(name, jobDataMap, cronJobEntry, canRunConcurrently, params, objects);
}
/**
* Add a job to the scheduler
*
* @param name The name of the job to add
* @param jobDataMap The JobDataMap to use for this job
* @param trigger a Trigger
* @param canRunConcurrently whether this job can be run concurrently
* @param params Additional Parameters to setup CronJob (might be null)
* @param objects A Map with additional object to setup CronJob (might be null)
*
* @throws CascadingException thrown in case of errors
*/
private void addJob(final String name, final JobDataMap jobDataMap, final Trigger trigger,
final boolean canRunConcurrently, final Parameters params, final Map objects)
throws CascadingException {
try {
final JobDetail jobdetail = scheduler.getJobDetail(name, DEFAULT_QUARTZ_JOB_GROUP);
if (jobdetail != null) {
removeJob(name);
}
} catch (final SchedulerException ignored) {
}
initDataMap(jobDataMap, name, canRunConcurrently, params, objects);
final JobDetail detail = createJobDetail(name, jobDataMap);
if (getLogger().isInfoEnabled()) {
getLogger().info("Adding CronJob '" + trigger.getFullName() + "'");
}
try {
scheduler.scheduleJob(detail, trigger);
} catch (final SchedulerException se) {
throw new CascadingException(se.getMessage(), se);
}
if (getLogger().isDebugEnabled()) {
if (trigger instanceof CronTrigger) {
getLogger().debug("Time schedule summary:\n" + ((CronTrigger)trigger).getExpressionSummary());
} else {
getLogger().debug("Next scheduled time: " + trigger.getNextFireTime());
}
}
}
protected JobDataMap initDataMap(JobDataMap jobDataMap, String jobName, boolean concurent,
Parameters params, Map objects) {
jobDataMap.put(DATA_MAP_NAME, jobName);
jobDataMap.put(DATA_MAP_LOGGER, getLogger());
jobDataMap.put(DATA_MAP_CONTEXT, this.context);
jobDataMap.put(DATA_MAP_MANAGER, this.manager);
jobDataMap.put(DATA_MAP_RUN_CONCURRENT, concurent? Boolean.TRUE: Boolean.FALSE);
if (null != params) {
jobDataMap.put(DATA_MAP_PARAMETERS, params);
}
if (null != objects) {
jobDataMap.put(DATA_MAP_OBJECTMAP, objects);
}
return jobDataMap;
}
protected JobDetail createJobDetail(String name, JobDataMap jobDataMap) {
final JobDetail detail = new JobDetail(name, DEFAULT_QUARTZ_JOB_GROUP, QuartzJobExecutor.class);
detail.setJobDataMap(jobDataMap);
return detail;
}
/**
* Create a QuartzThreadPool
*
* @param poolConfig Configuration element for the thread pool
*
* @return QuartzThreadPool
*/
private QuartzThreadPool createThreadPool(final Configuration poolConfig)
throws ServiceException {
final int queueSize = poolConfig.getChild("queue-size").getValueAsInteger(-1);
final int maxPoolSize = poolConfig.getChild("max-pool-size").getValueAsInteger(-1);
final int minPoolSize = poolConfig.getChild("min-pool-size").getValueAsInteger(-1);
final int keepAliveTimeMs = poolConfig.getChild("keep-alive-time-ms").getValueAsInteger(-1);
final String blockPolicy = poolConfig.getChild("block-policy").getValue(null);
m_shutdownGraceful = poolConfig.getChild("shutdown-graceful").getValueAsBoolean(true);
final int shutdownWaitTimeMs = poolConfig.getChild("shutdown-wait-time-ms").getValueAsInteger(-1);
final RunnableManager runnableManager = (RunnableManager)this.manager.lookup(RunnableManager.ROLE);
this.executor = runnableManager.createPool(queueSize,
maxPoolSize,
minPoolSize,
Thread.NORM_PRIORITY,
false, // no daemon
keepAliveTimeMs,
blockPolicy,
m_shutdownGraceful,
shutdownWaitTimeMs);
final QuartzThreadPool pool = new QuartzThreadPool(this.executor);
return pool;
}
/**
* Create the triggers
*
* @param triggers array of trigger configuration elements
*
* @throws ConfigurationException thrown in case of configuration failures
*/
private void createTriggers(final Configuration[] triggers)
throws ConfigurationException {
for (int i = 0; i < triggers.length; i++) {
String cron = triggers[i].getChild("cron").getValue(null);
if (null == cron) {
final String seconds = triggers[i].getChild("seconds").getValue("0");
final String minutes = triggers[i].getChild("minutes").getValue("*");
final String hours = triggers[i].getChild("hours").getValue("*");
final String days = triggers[i].getChild("days").getValue("*");
final String months = triggers[i].getChild("months").getValue("*");
final String weekdays = triggers[i].getChild("weekdays").getValue("?");
final String years = triggers[i].getChild("years").getValue("*");
cron = seconds + " " + minutes + " " + hours + " " + days + " " + months + " " + weekdays + " " +
years;
}
try {
addJob(triggers[i].getAttribute("name"), triggers[i].getAttribute("target"), cron,
triggers[i].getAttributeAsBoolean("concurrent-runs", true));
} catch (final CascadingException ce) {
throw new ConfigurationException("failed adding trigger to scheduler", ce);
}
}
}
private JobStore createJobStore(String instanceName, String instanceID, final Configuration configuration)
throws ConfigurationException {
String type = configuration.getAttribute("type", "ram");
if (type.equals("ram")) {
return new RAMJobStore();
}
JobStoreSupport store = null;
if (type.equals("tx")) {
store = new QuartzJobStoreTX(getLogger(), this.manager, this.context);
} else if (type.equals("cmt")) {
store = new QuartzJobStoreCMT(getLogger(), this.manager, this.context);
} else {
throw new ConfigurationException("Unknown store type: " + type);
}
Configuration dsConfig = configuration.getChild("datasource", false);
if (dsConfig == null) {
throw new ConfigurationException("Store " + type + " requires datasource configuration.");
}
String dsName = dsConfig.getValue();
String dsType = dsConfig.getAttribute("provider", "jndi");
ConnectionProvider provider;
if (dsType.equals("jndi")) {
provider = new JNDIConnectionProvider(dsName, false);
} else if (dsType.equals("excalibur")) {
provider = new DataSourceComponentConnectionProvider(dsName, this.manager);
} else {
// assume class name
try {
provider = (ConnectionProvider)Class.forName(dsType).newInstance();
} catch (Exception e) {
throw new ConfigurationException("Could not instantiate ConnectionProvider class " + dsType);
}
}
store.setInstanceName(instanceName);
store.setInstanceId(instanceID);
store.setDataSource(dsType + ":" + dsName);
DBConnectionManager.getInstance().addConnectionProvider(dsType + ":" + dsName, provider);
String delegate = configuration.getAttribute("delegate", null);
try {
if (delegate != null) {
store.setDriverDelegateClass(delegate);
}
} catch (InvalidConfigurationException e) {
throw new ConfigurationException("Could not instantiate DriverDelegate class " + delegate, e);
}
return store;
}
/* (non-Javadoc)
* @see org.apache.cocoon.components.cron.JobScheduler#fireTarget(java.lang.Object)
*/
private boolean fireJob(final String name, final Object job) {
try {
if (job instanceof CronJob || job instanceof Job) {
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(DATA_MAP_OBJECT, job);
initDataMap(jobDataMap, name, true, null, null);
final JobDetail detail = createJobDetail(name, jobDataMap);
final Trigger trigger = new SimpleTrigger(name, DEFAULT_QUARTZ_JOB_GROUP);
TriggerFiredBundle fireBundle = new TriggerFiredBundle(detail, trigger, null, false, null, null, null, null);
final Job executor = createJobExecutor();
final JobExecutionContext context = new JobExecutionContext(this.scheduler, fireBundle, executor);
this.executor.execute(new Runnable() {
public void run() {
try {
executor.execute(context);
} catch (JobExecutionException e) {
getLogger().error("Job '" + job + "' died.", e);
}
}
});
} else if (job instanceof Runnable) {
this.executor.execute((Runnable)job);
} else {
getLogger().error("Job named '" + name + "' is of invalid class: " + job.getClass().getName());
return false;
}
return true;
} catch (final InterruptedException ie) {
getLogger().error("job " + name + " interrupted", ie);
}
return false;
}
protected Job createJobExecutor() {
return new QuartzJobExecutor();
}
/**
* A QuartzThreadPool for the Quartz Scheduler based on Doug Leas concurrency utilities PooledExecutor
*
* @author <a href="mailto:giacomo@otego.com">Giacomo Pati</a>
* @version CVS $Id$
*/
private static class QuartzThreadPool extends AbstractLogEnabled implements org.quartz.spi.ThreadPool {
/** Our executor thread pool */
private ThreadPool executor;
/**
*
*/
public QuartzThreadPool(final ThreadPool executor) {
super();
this.executor = executor;
}
/* (non-Javadoc)
* @see org.quartz.spi.QuartzThreadPool#getPoolSize()
*/
public int getPoolSize() {
return this.executor.getMaximumPoolSize();
}
/* (non-Javadoc)
* @see org.quartz.spi.QuartzThreadPool#initialize()
*/
public void initialize() {
}
/* (non-Javadoc)
* @see org.quartz.spi.QuartzThreadPool#runInThread(java.lang.Runnable)
*/
public boolean runInThread(final Runnable job) {
try {
this.executor.execute(job);
} catch (final InterruptedException ie) {
getLogger().error("Cronjob failed", ie);
}
return true;
}
/* (non-Javadoc)
* @see org.quartz.spi.QuartzThreadPool#shutdown(boolean)
*/
public void shutdown(final boolean waitForJobsToComplete) {
this.executor.shutdown();
}
}
}