Crash Recovery Schemes

[sgeos]

I assume that a basic crash recovery system looks something
like this. It works superficially, although I have not gone crazy
with a debugger. Is there anything obviously stupid about
this scheme, or is it more or less usable?

import java.io.*;

public class CrashRecovery
implements ITicking, Serializable
{
// User Constant
private static final String DEFAULT_FILE_NAME = "recovery.ser";
private static final String DEFAULT_MIRROR_NAME =
"recovery_mirror.ser";
private static final int DEFAULT_TIMEOUT = 60 * 60 * 5; //
60fps * 60s/m * 5m

// System Constant
private static final int DEFAULT_TICK = 1;
private static final int ONE_SECOND = 1000; // milliseconds

// State
private Serializable mHost;
private String mFileName;
private String mMirrorName;
private int mTimer;
private int mTimeout;
private int mVersion;

public CrashRecovery()
{
init(null, DEFAULT_FILE_NAME, DEFAULT_MIRROR_NAME);
}

public CrashRecovery(Serializable pHost, String pFileName, String
pMirrorName)
{
init(pHost, pFileName, pMirrorName);
}

public CrashRecovery init(Serializable pHost, String pFileName,
String pMirrorName)
{
setHost(pHost);
setFile(pFileName, pMirrorName);
resetTimer();
resetVersion();
return this;
}

public CrashRecovery setHost(Serializable pHost)
{
mHost = pHost;
return this;
}

public CrashRecovery setFile(String pFileName, String pMirrorName)
{
mFileName = pFileName;
mMirrorName = pMirrorName;
return this;
}

// tick every frame
public void tick()
{
tick(DEFAULT_TICK);
}

// ITicking supports multiticking
public void tick(int pTick)
{
mTimer += pTick;
if (mTimeout < mTimer)
{
resetTimer();
save();
}
}

public void setTimeout(int pTimeout)
{
mTimeout = pTimeout;
}

// because splitting timeout time and FPS is probably a good thing
public void setTimeout(int pSeconds, int pFps)
{
mTimeout = pSeconds * pFps;
}

public void resetTimer()
{
mTimer = 0;
}

private void resetVersion()
{
mVersion = 0;
}

public boolean save()
{
mVersion++;
resetTimer();
boolean success = saveState(mFileName);
success &= saveState(mMirrorName);
return success;
}

public Serializable load()
{
Serializable result;
SerializableShell data = loadShell(mFileName);
SerializableShell mirror = loadShell(mMirrorName);

// null is bad
if ((null == data) && (null == mirror))
{
result = null;
}
else if (null == data)
{
result = mirror.host;
}
else if (null == mirror)
{
result = data.host;
}

// lower version is more reliable
else if (mirror.version < data.version)
{
result = mirror.host;
}
else
{
result = data.host;
}
if (null != result)
{
setHost(result);
resetVersion();
save();
}
return mHost;
}

public boolean saveState(String pFilename)
{
boolean success;
try
{
SerializableShell data = new SerializableShell(mHost,
mVersion);
FileOutputStream fos = new
FileOutputStream(pFilename);
ObjectOutputStream out = new ObjectOutputStream(fos);
out.writeObject(data);
out.close();
success = true;
}
catch (IOException e)
{
success = false;
}
return success;
}

public Serializable loadState(String pFilename)
{
SerializableShell data = loadShell(pFilename);
if (null == data)
{
return null;
}
return data.host;
}

private SerializableShell loadShell(String pFilename)
{
SerializableShell data = null;
try
{
FileInputStream fis = new
FileInputStream(pFilename);
ObjectInputStream in = new ObjectInputStream(fis);
data = (SerializableShell)in.readObject();
in.close();
}
catch (Throwable e)
{
data = null;
}
return data;
}

public boolean deleteFiles()
{
boolean success = (new File(mFileName)).delete();
success &= (new File(mMirrorName)).delete();
return success;
}

class SerializableShell
implements Serializable
{
public Serializable host;
public int version;

public SerializableShell(Serializable pHost, int pVersion)
{
host = pHost;
version = pVersion;
}
}
}

-Brendan

 

[Tom Forsmo]

You should give a short and written description of your algorithm, not
the entire code, it makes it more accessable to use and easier for us to
help you.

tom