InProcessBatchManager.java

package net.sf.appstatus.batch;

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

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * This implementation stores batch history and status in memory.
 * <p>
 * Can be used when batch is run within the same JVM as the console.
 * <p>
 * History is lost on restart.
 *
 * @author Nicolas Richeton
 *
 */
public class InProcessBatchManager implements IBatchManager {

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

	private List<IBatch> errorBatches = new Vector<IBatch>();

	List<IBatch> finishedBatches = new Vector<IBatch>();
	private int logInterval = 1000;
	private long maxSize = 25;
	List<IBatch> runningBatches = new Vector<IBatch>();

	private int zombieInterval;

	public IBatch addBatch(String name, String group, String uuid) {

		// Add batch
		IBatch b = new Batch(uuid, name, group);
		((Batch) b).setZombieInterval(this.zombieInterval);

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

			// initMonitor
			getMonitor(b);

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

		return b;
	}

	protected void addTo(List<IBatch> l, IBatch b) {
		// Ensure batch list does not exceed defined size
		if (l.size() >= maxSize) {
			l.remove(0);
		}

		l.add(b);
	}

	public void batchEnd(Batch batch) {
		runningBatches.remove(batch);
		addTo(finishedBatches, batch);

		if (!batch.isSuccess()) {
			addTo(errorBatches, batch);
		}
	}

	public List<IBatch> getBatches(String group, String name) {
		List<IBatch> result = new ArrayList<IBatch>();

		for (IBatch b : runningBatches) {
			if (StringUtils.equals(group, b.getGroup()) && StringUtils.equals(name, b.getName())) {
				result.add(b);
			}
		}

		for (IBatch b : finishedBatches) {
			if (StringUtils.equals(group, b.getGroup()) && StringUtils.equals(name, b.getName())) {
				result.add(b);
			}
		}

		return result;
	}

	public Properties getConfiguration() {
		return null;
	}

	public List<IBatch> getErrorBatches() {
		return errorBatches;
	}

	public List<IBatch> getFinishedBatches() {
		return finishedBatches;
	}

	public IBatchProgressMonitor getMonitor(IBatch batch) {
		Batch b = (Batch) batch;
		// If batch has no progress monitor, create one.
		if (b.getProgressMonitor() == null) {
			// Calling this method automatically call
			// IBatch#setProgressMonitor()
			InProcessBatchProgressMonitor pm = new InProcessBatchProgressMonitor(batch.getUuid(), batch, this);
			pm.setWritingDelay(logInterval);
		}

		// Return current monitor.
		return b.getProgressMonitor();
	}

	public List<IBatch> getRunningBatches() {
		return runningBatches;
	}

	public void init() {
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see net.sf.appstatus.core.batch.IBatchManager#removeAllBatches(int)
	 */
	public void removeAllBatches(int scope) {

		if (finishedBatches == null || finishedBatches.size() == 0) {
			// Nothing can be removed using scoped.
			return;
		}

		ArrayList<IBatch> toRemove = new ArrayList<IBatch>();
		switch (scope) {
		case REMOVE_SUCCESS:
			for (IBatch b : finishedBatches) {
				if (b.isSuccess() && (b.getRejectedItemsId() == null || b.getRejectedItemsId().size() == 0)) {
					toRemove.add(b);
				}
			}
			break;

		case REMOVE_OLD:
			// Create reference date.
			Calendar c = Calendar.getInstance();
			c.add(Calendar.MONTH, -6);
			Date thisIsOld = c.getTime();

			for (IBatch b : finishedBatches) {
				if (b.getLastUpdate().before(thisIsOld)) {
					toRemove.add(b);
				}
			}
			break;
		}

		// Remove all batches marked for deletion.
		for (IBatch b : toRemove) {
			removeBatch(b);
		}

	}

	private void removeBatch(IBatch b) {

		// Remove only finished jobs
		if (!runningBatches.contains(b)) {

			// remove from errorBatches
			if (errorBatches.contains(b)) {
				errorBatches.remove(b);
			}

			// Remove from finished batches.
			if (finishedBatches.contains(b)) {
				finishedBatches.remove(b);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * net.sf.appstatus.core.batch.IBatchManager#removeBatch(net.sf.appstatus
	 * .core.batch.IBatch)
	 */
	public void removeBatch(String uuid) {
		Batch b = new Batch(uuid);
		removeBatch(b);
	}

	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 {
			maxSize = Integer.parseInt(configuration.getProperty("batch.maxHistory"));
		} catch (NumberFormatException e) {
			maxSize = 25;
		}
		logger.info("Batch history size: {}", maxSize);

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

	}
}