JdbcBatchManager.java

package net.sf.appstatus.batch.jdbc;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.Vector;

import net.sf.appstatus.core.batch.IBatch;
import net.sf.appstatus.core.batch.IBatchManager;
import net.sf.appstatus.core.batch.IBatchProgressMonitor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JdbcBatchManager implements IBatchManager {

	private static Logger logger = LoggerFactory
			.getLogger(JdbcBatchManager.class);

	private BatchDao batchDao;
	List<IBatch> runningBatches = new Vector<IBatch>();
	private int logInterval;

	private int zombieInterval;

	public void setBatchDao(BatchDao batchDao) {
		this.batchDao = batchDao;
	}

	public void batchEnd(Batch batch) {
		runningBatches.remove(batch);
	}

	public IBatch addBatch(String name, String group, String uuid) {
		BdBatch bdBatch = new BdBatch();
		bdBatch.setName(name);
		bdBatch.setGroup(group);
		bdBatch.setUuid(uuid);
		bdBatch.setStartDate(new Date());
		bdBatch.setStatus(Batch.STATUS_RUNNING);

		IBatch b = new Batch(bdBatch);
		((Batch) b).setZombieInterval(zombieInterval);
		int currentPosition = runningBatches.indexOf(b);
		if (currentPosition >= 0) {
			// Reuse existing object (and keep monitor).
			b = runningBatches.get(currentPosition);
		} else {
			// Add new batch

			// runningBatches is not limited in size.
			runningBatches.add(b);

			batchDao.save(bdBatch);
		}

		return b;
	}

	protected List<IBatch> convertToIBatch(List<BdBatch> bdBaches) {
		List<IBatch> result = null;
		if (bdBaches != null) {
			result = new ArrayList<IBatch>();
			for (BdBatch bdb : bdBaches) {
				Batch b = new Batch(bdb);
				b.setZombieInterval(zombieInterval);

				result.add(b);
			}
		}
		return result;
	}

	public List<IBatch> getErrorBatches() {
		return convertToIBatch(batchDao.fetchError(25));
	}

	public List<IBatch> getFinishedBatches() {
		return convertToIBatch(batchDao.fetchFinished(25));
	}

	public IBatchProgressMonitor getMonitor(IBatch batch) {
		Batch b = (Batch) batch;
		if (b.getProgressMonitor() == null) {
			JdbcBatchProgressMonitor monitor = new JdbcBatchProgressMonitor(
					batch.getUuid(), batch, batchDao);
			monitor.setManager(this);
			monitor.setWritingDelay(logInterval);
		}
		return b.getProgressMonitor();
	}

	public List<IBatch> getRunningBatches() {
		return convertToIBatch(batchDao.fetchRunning(25));

	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see net.sf.appstatus.core.batch.IBatchManager#removeAllBatches(int)
	 */
	public void removeAllBatches(int scope) {
		switch (scope) {
		case IBatchManager.REMOVE_OLD:
			batchDao.deleteOldBatches(6);
			break;

		default:
			batchDao.deleteSuccessBatches();
			break;
		}
	}

	public void removeBatch(String uuid) {
		batchDao.deleteBatch(uuid);
	}

	public void setConfiguration(Properties configuration) {
		try {
			logInterval = Integer.parseInt(configuration
					.getProperty("batch.logInterval"));
		} catch (NumberFormatException e) {
			logInterval = 1000;
		}
		logger.info("Batch log interval: {}ms", logInterval);

		try {
			zombieInterval = Integer.parseInt(configuration
					.getProperty("batch.zombieInterval"));
		} catch (NumberFormatException e) {
			zombieInterval = 1000 * 60 * 10;
		}
		logger.info("Zombie interval: {}", zombieInterval);

	}

	public Properties getConfiguration() {
		Properties props = new Properties();
		props.put("batch.logInterval", String.valueOf(logInterval));
		props.put("batch.zombieInterval", String.valueOf(zombieInterval));
		return props;
	}

	public void init() {
		// Check database for table
		batchDao.createDbIfNecessary();
	}

	public List<IBatch> getBatches(String group, String name) {
		return convertToIBatch(batchDao.fetch(group, name, 25));
	}
}