ninja.NinjaScheduler Maven / Gradle / Ivy

Go to download
package ninja;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import ninja.lifecycle.Start;
import ninja.utils.NinjaProperties;

import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import quartz.QuartzJobFactory;

import com.google.common.base.Preconditions;
import com.google.inject.Inject;
import com.google.inject.Singleton;

/**
 * Provide methods to manage jobs with Quartz scheduler.
 *
 * @author svenkubiak
 * @author Thibault Meyer
 */
@Singleton
public class NinjaScheduler {
    private static final Logger LOG = LoggerFactory.getLogger(NinjaScheduler.class);
    private Scheduler scheduler;

    @Inject
    private QuartzJobFactory quartzJobFactory;

    @Inject
    private NinjaProperties ninjaProperties;

    /**
     * Initialize the scheduler.
     */
    @Start(order = 50)
    public void init() {
        for (String property : this.ninjaProperties.getAllCurrentNinjaProperties().stringPropertyNames()) {
            if (property.startsWith("org.quartz.")) {
                System.setProperty(property, this.ninjaProperties.get(property));
            }
        }
        
        final SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        try {
            this.scheduler = schedulerFactory.getScheduler();
            this.scheduler.setJobFactory(quartzJobFactory);
        } catch (SchedulerException e) {
            LOG.error("Failed to get scheduler from schedulerFactory", e);
        }
    }

    /**
     * Get the current in-use scheduler. If {@code NinjaScheduler} is not
     * initialized, null will be returned.
     *
     * @return The in-use scheduler
     */
    public Scheduler getScheduler() {
        return this.scheduler;
    }

    /**
     * Start the scheduler.
     */
    public void start() {
        Preconditions.checkNotNull(this.scheduler, "Scheduler has not been initialized");
        
        try {
            this.scheduler.start();
            if (this.scheduler.isStarted()) {
                LOG.info("Successfully started quartz scheduler");
            } else {
                LOG.error("Scheduler is not started");
            }
        } catch (SchedulerException e) {
            LOG.error("Failed to start scheduler", e);
        }
    }

    /**
     * Shutdown the scheduler.
     */
    public void shutdown() {
        Preconditions.checkNotNull(this.scheduler);
        
        try {
            this.scheduler.shutdown();
            if (this.scheduler.isShutdown()) {
                LOG.info("Successfully shutdown quartz scheduler");
            } else {
                LOG.error("Failed to shutdown scheduler");
            }
        } catch (SchedulerException e) {
            LOG.error("Failed to shutdown scheduler", e);
        }
    }

    /**
     * Set the scheduler in standby.
     */
    public void standby() {
        Preconditions.checkNotNull(this.scheduler);
        
        try {
            this.scheduler.standby();
            if (this.scheduler.isInStandbyMode()) {
                LOG.info("Scheduler is now in standby");
            } else {
                LOG.error("Failed to put scheduler in standby");
            }
        } catch (SchedulerException e) {
            LOG.error("Failed to put scheduler in standby", e);
        }
    }

    /**
     * Adds a job to the scheduler based on a JobDetail and a Trigger
     *
     * @param jobDetail The JobDetail
     * @param trigger   The Trigger
     */
    public void schedule(JobDetail jobDetail, Trigger trigger) {
        Preconditions.checkNotNull(this.scheduler, "Scheduler has not been initialized");
        Preconditions.checkNotNull(jobDetail, "JobDetail is required for schedule");
        Preconditions.checkNotNull(trigger, "trigger is required for schedule");

        try {
            this.scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            LOG.error("Failed to schedule a new job", e);
        }
    }

    /**
     * Convenient method for creating a new Trigger based on
     * a cron expression
     *
     * @param identity           The identity in quartz for the trigger
     * @param cronExpression     The cron expression (e.g. 0 4 * * * ?)
     * @param triggerGroupName   The name of the trigger grop in quartz
     * @param triggerDescription An optional description
     * @return A new Trigger object
     */
    public Trigger getTrigger(String identity, String cronExpression, String triggerGroupName, String triggerDescription) {
        Preconditions.checkNotNull(identity, "Identity is required for creating a new trigger");
        Preconditions.checkNotNull(cronExpression, "CronExpression is required for new trigger");
        Preconditions.checkNotNull(triggerGroupName, "TriggerGroupName is required for new trigger");

        return newTrigger()
                .withIdentity(identity, triggerGroupName)
                .withSchedule(cronSchedule(cronExpression))
                .withDescription(triggerDescription)
                .build();
    }

    /**
     * Convenient method for creating a new JobDetail
     *
     * @param clazz        The job class to execute
     * @param identity     The identity in quartz for the job
     * @param jobGroupName The name of the job group in quartz
     * @return A new JobDetail object for scheduling
     */
    public  JobDetail getJobDetail(Class clazz, String identity, String jobGroupName) {
        Preconditions.checkNotNull(clazz, "Class is required for new JobDetail");
        Preconditions.checkNotNull(identity, "Identity is required for new JobDetail");
        Preconditions.checkNotNull(jobGroupName, "JobeGroupName is required for new JobDetail");

        return newJob(clazz)
                .withIdentity(identity, jobGroupName)
                .build();
    }
}