GenericSnapshotManager.java

package org.prevayler.implementation.snapshot;

import org.prevayler.foundation.serialization.JavaSerializer;
import org.prevayler.foundation.serialization.Serializer;
import org.prevayler.implementation.PrevalentSystemGuard;
import org.prevayler.implementation.PrevaylerDirectory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;

public class GenericSnapshotManager {

	private Map _strategies;
	private String _primarySuffix;
	private PrevaylerDirectory _directory;
	private PrevalentSystemGuard _recoveredPrevalentSystem;

	public GenericSnapshotManager(Map snapshotSerializers, String primarySnapshotSuffix, Object newPrevalentSystem, PrevaylerDirectory directory, Serializer journalSerializer)
			throws IOException, ClassNotFoundException {
		for (Iterator iterator = snapshotSerializers.keySet().iterator(); iterator.hasNext();) {
			String suffix = (String) iterator.next();
			PrevaylerDirectory.checkValidSnapshotSuffix(suffix);
		}

		if (!snapshotSerializers.containsKey(primarySnapshotSuffix)) {
			throw new IllegalArgumentException("Primary suffix '" + primarySnapshotSuffix + "' does not appear in strategies map");
		}

		_strategies = snapshotSerializers;
		_primarySuffix = primarySnapshotSuffix;

		_directory = directory;
		_directory.produceDirectory();

		File latestSnapshot = _directory.latestSnapshot();
		long recoveredVersion = latestSnapshot == null ? 0 : PrevaylerDirectory.snapshotVersion(latestSnapshot);
		Object recoveredPrevalentSystem = latestSnapshot == null
				? newPrevalentSystem
				: readSnapshot(latestSnapshot);
		_recoveredPrevalentSystem = new PrevalentSystemGuard(recoveredPrevalentSystem, recoveredVersion, journalSerializer);
	}

	GenericSnapshotManager(Object newPrevalentSystem) {
		_strategies = Collections.singletonMap("snapshot", new JavaSerializer());
		_primarySuffix = "snapshot";
		_directory = null;
		_recoveredPrevalentSystem = new PrevalentSystemGuard(newPrevalentSystem, 0, new JavaSerializer());
	}


	public Serializer primarySerializer() {
		return (Serializer) _strategies.get(_primarySuffix);
	}

	public PrevalentSystemGuard recoveredPrevalentSystem() {
		return _recoveredPrevalentSystem;
	}

	public void writeSnapshot(Object prevalentSystem, long version) throws IOException {
		File tempFile = _directory.createTempFile("snapshot" + version + "temp", "generatingSnapshot");

		writeSnapshot(prevalentSystem, tempFile);

		File permanent = snapshotFile(version);
		permanent.delete();
		if (!tempFile.renameTo(permanent)) throw new IOException(
				"Temporary snapshot file generated: " + tempFile + "\nUnable to rename it permanently to: " + permanent);
	}

	private void writeSnapshot(Object prevalentSystem, File snapshotFile) throws IOException {
		OutputStream out = new FileOutputStream(snapshotFile);
		try {
			primarySerializer().writeObject(out, prevalentSystem);
		} finally {
			out.close();
		}
	}


	private File snapshotFile(long version) {
		return _directory.snapshotFile(version, _primarySuffix);
	}

	private Object readSnapshot(File snapshotFile) throws ClassNotFoundException, IOException {
		String suffix = snapshotFile.getName().substring(snapshotFile.getName().indexOf('.') + 1);
		if (!_strategies.containsKey(suffix)) throw new IOException(
				snapshotFile.toString() + " cannot be read; only " + _strategies.keySet().toString() + " supported");

		Serializer serializer = (Serializer) _strategies.get(suffix);
		FileInputStream in = new FileInputStream(snapshotFile);
		try {
			return serializer.readObject(in);
		} finally {
			in.close();
		}
	}

}