org.rzo.yajsw.timer.TimerImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of wrapper Show documentation
YAJSW is a java centric implementation of the java service wrapper by tanuki (JSW). It aims at being mostly configuration compliant with the original. It should therefore be easy to switch from JSW to YAJSW.
The newest version!
/* This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.  
 */
package org.rzo.yajsw.timer;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.rzo.yajsw.config.YajswConfigurationImpl;
import org.rzo.yajsw.wrapper.WrappedProcess;

// TODO: Auto-generated Javadoc
/**
 * The Class Timer.
 */
public class TimerImpl implements Timer
{

	/** The _config. */
	YajswConfigurationImpl	_config;

	/** The _wp. */
	WrappedProcess			_wp;

	/** The _scheduler. */
	static Scheduler		_scheduler;

	/** The _cron start. */
	MyCronTrigger			_cronStart;

	/** The _cron stop. */
	MyCronTrigger			_cronStop;

	/** The _cron restart. */
	MyCronTrigger			_cronRestart;

	/** The _simple start. */
	MySimpleTrigger			_simpleStart;

	/** The _simple stop. */
	MySimpleTrigger			_simpleStop;

	/** The _simple restart. */
	MySimpleTrigger			_simpleRestart;

	/** The _has trigger. */
	boolean					_hasTrigger		= false;

	/** The _start immediate. */
	boolean					_startImmediate	= true;

	/** The _triggered. */
	boolean					_triggered		= false;

	/**
	 * Instantiates a new timer.
	 * 
	 * @param config
	 *            the config
	 * @param wp
	 *            the wp
	 */
	public TimerImpl(YajswConfigurationImpl config, WrappedProcess wp)
	{
		_config = config;
		_wp = wp;
	}

	/**
	 * Inits the.
	 */
	public synchronized void init()
	{
		for (Iterator keys = _config.getKeys("wrapper.timer"); keys.hasNext();)
		{
			String key = (String) keys.next();
			if (key.contains(".simple."))
			{
				if (key.contains(".START."))
				{
					if (_simpleStart == null)
						_simpleStart = getSimpleTrigger(key);
				}
				else if (key.contains(".STOP."))
				{
					if (_simpleStop == null)
						_simpleStop = getSimpleTrigger(key);
				}
				else if (key.contains(".RESTART."))
				{
					if (_simpleRestart == null)
						_simpleRestart = getSimpleTrigger(key);
				}
				else
					System.out.println("Cannot interpret timer property: " + key);
			}
			else if (key.contains(".cron."))
			{
				if (key.contains(".START"))
					_cronStart = getCronTrigger(key);
				else if (key.contains(".STOP"))
					_cronStop = getCronTrigger(key);
				else if (key.contains(".RESTART"))
					_cronRestart = getCronTrigger(key);
				else
					System.out.println("Cannot interpret timer property: " + key);
			}
			else
			{
				System.out.println("Cannot interpret timer property: " + key);
			}
		}

	}

	/**
	 * Gets the simple trigger.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the simple trigger
	 */
	private MySimpleTrigger getSimpleTrigger(String key)
	{
		JobDetail jobDetail = new JobDetail();
		JobDataMap jobDataMap = new JobDataMap();
		jobDataMap.put("process", _wp);
		jobDetail.setJobDataMap(jobDataMap);

		Class jobClass = getJobClass(key);
		if (jobClass == null)
			return null;
		jobDetail.setJobClass(jobClass);
		jobDetail.setName(key);

		MySimpleTrigger trigger = new MySimpleTrigger(jobDetail);
		Date startTime = getStartTime(key);
		if (startTime != null)
		{
			trigger.setStartTime(startTime);
		}
		int repeatCount = getRepeatCount(key);
		if (repeatCount >= -1)
			trigger.setRepeatCount(repeatCount);
		int interval = getInterval(key);
		if (interval > 0)
			trigger.setRepeatInterval(interval * 1000);
		_hasTrigger = true;

		if (trigger != null)
			trigger.setName(key);
		_startImmediate = false; // getStartTime will always return a date.
		// per default the current time.
		trigger.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
		return trigger;
	}

	/**
	 * Gets the interval.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the interval
	 */
	private int getInterval(String key)
	{
		return _config.getInt(key.substring(0, key.lastIndexOf(".")) + ".INTERVAL", SimpleTrigger.REPEAT_INDEFINITELY);
	}

	/**
	 * Gets the repeat count.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the repeat count
	 */
	private int getRepeatCount(String key)
	{
		return _config.getInt(key.substring(0, key.lastIndexOf(".")) + ".COUNT", SimpleTrigger.REPEAT_INDEFINITELY);
	}

	/**
	 * Gets the start time.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the start time
	 */
	private Date getStartTime(String key)
	{
		String str = _config.getString(key.substring(0, key.lastIndexOf(".")) + ".FIRST");
		if (str == null)
			return new Date();
		SimpleDateFormat df = null;
		if (str.contains(" "))
			df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
		else
			df = new SimpleDateFormat("HH:mm:ss");
		try
		{
			return df.parse(str);
		}
		catch (ParseException e)
		{
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * Gets the job class.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the job class
	 */
	private Class getJobClass(String key)
	{
		if (key.contains(".RESTART"))
			return RestartJob.class;
		else if (key.contains(".STOP"))
			return StopJob.class;
		else if (key.contains(".START"))
			return StartJob.class;
		return null;
	}

	/**
	 * Gets the cron trigger.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the cron trigger
	 */
	private MyCronTrigger getCronTrigger(String key)
	{
		JobDetail jobDetail = new JobDetail();
		JobDataMap jobDataMap = new JobDataMap();
		jobDataMap.put("process", _wp);
		jobDetail.setJobDataMap(jobDataMap);
		jobDetail.setName(key);

		Class jobClass = getJobClass(key);
		if (jobClass == null)
			return null;
		jobDetail.setJobClass(jobClass);

		MyCronTrigger trigger = new MyCronTrigger(jobDetail);
		CronExpression cronExpression = getCronExpression(key);
		if (cronExpression != null)
		{
			trigger.setCronExpression(cronExpression);
			if (jobClass.equals(StartJob.class))
				_startImmediate = false;
			_hasTrigger = true;
		}
		else
		{
			return null;
		}

		trigger.setName(key);
		trigger.setMisfireInstruction(trigger.MISFIRE_INSTRUCTION_FIRE_ONCE_NOW);
		return trigger;
	}

	/**
	 * Gets the cron expression.
	 * 
	 * @param key
	 *            the key
	 * 
	 * @return the cron expression
	 */
	private CronExpression getCronExpression(String key)
	{
		String str = _config.getString(key);
		if (str == null)
		{
			return null;
		}
		try
		{
			return new CronExpression(str);
		}
		catch (ParseException e)
		{
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * Start.
	 */
	public synchronized void start()
	{
		if (!_hasTrigger)
			return;
		if (getScheduler() == null)
			return;
		try
		{
			if (!_scheduler.isStarted())
				_scheduler.start();
		}
		catch (SchedulerException e)
		{
			e.printStackTrace();
			return;
		}

		if (_cronStart != null)
			startTrigger(_cronStart, _cronStart.getJobDetail());
		if (_cronStop != null)
			startTrigger(_cronStop, _cronStop.getJobDetail());
		if (_cronRestart != null)
			startTrigger(_cronRestart, _cronRestart.getJobDetail());
		if (_simpleStart != null)
			startTrigger(_simpleStart, _simpleStart.getJobDetail());
		if (_simpleStop != null)
			startTrigger(_simpleStop, _simpleStop.getJobDetail());
		if (_simpleRestart != null)
			startTrigger(_simpleRestart, _simpleRestart.getJobDetail());
		_triggered = true;
	}

	/**
	 * Gets the scheduler.
	 * 
	 * @return the scheduler
	 */
	private Scheduler getScheduler()
	{
		if (_scheduler == null)
		{
			SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
			try
			{
				_scheduler = schedFact.getScheduler();
			}
			catch (SchedulerException e)
			{
				e.printStackTrace();
				_scheduler = null;
			}
		}
		return _scheduler;
	}

	/**
	 * Start trigger.
	 * 
	 * @param trigger
	 *            the trigger
	 * @param jobDetail
	 *            the job detail
	 */
	private void startTrigger(Trigger trigger, JobDetail jobDetail)
	{
		if (trigger != null)
			try
			{
				_scheduler.scheduleJob(jobDetail, trigger);
			}
			catch (SchedulerException e)
			{
				e.printStackTrace();
			}
	}

	/**
	 * Stop.
	 */
	public void stop()
	{
		if (!_hasTrigger)
			return;
		stopTrigger(_cronStart);
		stopTrigger(_cronStop);
		stopTrigger(_cronRestart);
		stopTrigger(_simpleStart);
		stopTrigger(_simpleStop);
		stopTrigger(_simpleRestart);

	}

	/**
	 * Stop trigger.
	 * 
	 * @param trigger
	 *            the trigger
	 */
	private synchronized void stopTrigger(Trigger trigger)
	{
		try
		{
			_scheduler.pauseAll();
		}
		catch (SchedulerException e)
		{
			e.printStackTrace();
			return;
		}
		_triggered = false;
	}

	/**
	 * Checks if is triggered.
	 * 
	 * @return true, if is triggered
	 */
	public boolean isTriggered()
	{
		return _triggered;
	}

	/**
	 * Checks if is start immediate.
	 * 
	 * @return true, if is start immediate
	 */
	public boolean isStartImmediate()
	{
		return _startImmediate;
	}

	/**
	 * Checks if is checks for trigger.
	 * 
	 * @return true, if is checks for trigger
	 */
	public boolean isHasTrigger()
	{
		return _hasTrigger;
	}

	/**
	 * The Class MyCronTrigger.
	 */
	class MyCronTrigger extends CronTrigger
	{

		/** The _job detail. */
		JobDetail	_jobDetail;

		/**
		 * Instantiates a new my cron trigger.
		 * 
		 * @param jobDetail
		 *            the job detail
		 */
		MyCronTrigger(JobDetail jobDetail)
		{
			_jobDetail = jobDetail;
		}

		/**
		 * Gets the job detail.
		 * 
		 * @return the job detail
		 */
		JobDetail getJobDetail()
		{
			return _jobDetail;
		}
	}

	/**
	 * The Class MySimpleTrigger.
	 */
	class MySimpleTrigger extends SimpleTrigger
	{

		/** The _job detail. */
		JobDetail	_jobDetail;

		/**
		 * Instantiates a new my simple trigger.
		 * 
		 * @param jobDetail
		 *            the job detail
		 */
		MySimpleTrigger(JobDetail jobDetail)
		{
			_jobDetail = jobDetail;
		}

		/**
		 * Gets the job detail.
		 * 
		 * @return the job detail
		 */
		JobDetail getJobDetail()
		{
			return _jobDetail;
		}
	}

}