org.archive.bdb

Class BdbModule

java.lang.Object

org.archive.bdb.BdbModule

All Implemented Interfaces:

Closeable, AutoCloseable, Checkpointable, org.springframework.beans.factory.DisposableBean, org.springframework.context.Lifecycle

public class BdbModule
extends Object
implements org.springframework.context.Lifecycle, Checkpointable, Closeable, org.springframework.beans.factory.DisposableBean

Utility module for managing a shared BerkeleyDB-JE environment

Contributor:

pjack, gojomo

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	BdbModule.BdbConfig Configuration object for databases.

Field Summary

Fields

Modifier and Type	Field and Description
protected int	cachePercent
protected int	cacheSize
protected ConfigPath	dir
protected int	expectedConcurrency Expected number of concurrent threads; used to tune nLockTables according to JE FAQ http://www.oracle.com/technology/products/berkeley-db/faq/je_faq.html#33
protected boolean	isRunning
protected Checkpoint	recoveryCheckpoint
protected long	sn uniqueness serial number for temp map databases
protected boolean	useHardLinkCheckpoints Whether to use hard-links to log files to collect/retain the BDB log files needed for a checkpoint.
protected boolean	useSharedCache

Constructor Summary

Constructors

Constructor and Description
BdbModule()

Method Summary

Methods

Modifier and Type	Method and Description
void	close()
void	closeDatabase(com.sleepycat.je.Database db)
void	closeDatabase(String name)
void	destroy()
void	doCheckpoint(Checkpoint checkpointInProgress) Do the actual checkpoint.
protected void	doRecover()
void	finishCheckpoint(Checkpoint checkpointInProgress) Cleanup/unlock; need not complete for a checkpoint to be valid.
int	getCachePercent()
int	getCacheSize()
com.sleepycat.bind.serial.StoredClassCatalog	getClassCatalog()
com.sleepycat.je.Database	getDatabase(String name)
ConfigPath	getDir()
int	getExpectedConcurrency()
<V extends IdentityCacheable> ObjectIdentityCache<V>	getObjectCache(String dbName, boolean recycle, Class<V> valueClass)
<V extends IdentityCacheable> ObjectIdentityCache<V>	getObjectCache(String dbName, boolean recycle, Class<V> declaredClass, Class<? extends V> valueClass) Get an ObjectIdentityCache, backed by a BDB Database of the given name, with objects of the given valueClass type.
<V extends IdentityCacheable> ObjectIdentityBdbManualCache<V>	getOIBCCache(String dbName, boolean recycle, Class<? extends V> valueClass) Get an ObjectIdentityBdbCache, backed by a BDB Database of the given name, with the given value class type.
<K,V> DisposableStoredSortedMap<K,V>	getStoredMap(String dbName, Class<K> keyClass, Class<V> valueClass, boolean allowDuplicates, boolean usePriorData) Creates a database-backed TempStoredSortedMap for transient reporting requirements.
<K extends Serializable> StoredQueue<K>	getStoredQueue(String dbname, Class<K> clazz, boolean usePriorData)
boolean	getUseHardLinkCheckpoints()
boolean	getUseSharedCache()
boolean	isRunning()
com.sleepycat.je.Database	openDatabase(String name, BdbModule.BdbConfig config, boolean usePriorData) Open a Database inside this BdbModule's environment, and remember it for automatic close-at-module-stop.
void	setCachePercent(int cachePercent)
void	setCacheSize(int cacheSize)
void	setDir(ConfigPath dir)
void	setExpectedConcurrency(int expectedConcurrency)
void	setRecoveryCheckpoint(Checkpoint checkpoint) Used to inform a bean that it should restore its state from the given Checkpoint when launched (Lifecycle start()).
protected void	setup(File f, boolean create)
void	setUseHardLinkCheckpoints(boolean useHardLinkCheckpoints)
void	setUseSharedCache(boolean useSharedCache)
void	start()
void	startCheckpoint(Checkpoint checkpointInProgress) Note a checkpoint is about to begin.
void	stop()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

dir

protected ConfigPath dir

cachePercent

protected int cachePercent

cacheSize

protected int cacheSize

useSharedCache

protected boolean useSharedCache

expectedConcurrency

protected int expectedConcurrency

Expected number of concurrent threads; used to tune nLockTables according to JE FAQ http://www.oracle.com/technology/products/berkeley-db/faq/je_faq.html#33

useHardLinkCheckpoints

protected boolean useHardLinkCheckpoints

Whether to use hard-links to log files to collect/retain the BDB log files needed for a checkpoint. Default is true. May not work on Windows (especially on pre-NTFS filesystems). If false, the BDB 'je.cleaner.expunge' value will be set to 'false', as well, meaning BDB will *not* delete obsolete JDB files, but only rename the '.DEL'. They will have to be manually deleted to free disk space, but .DEL files referenced in any checkpoint's 'jdbfiles.manifest' should be retained to keep the checkpoint valid.

isRunning

protected boolean isRunning

recoveryCheckpoint

protected Checkpoint recoveryCheckpoint

sn

protected long sn

uniqueness serial number for temp map databases

Constructor Detail

BdbModule

public BdbModule()

Method Detail

getDir

public ConfigPath getDir()

setDir

public void setDir(ConfigPath dir)

getCachePercent

public int getCachePercent()

setCachePercent

public void setCachePercent(int cachePercent)

getCacheSize

public int getCacheSize()

setCacheSize

public void setCacheSize(int cacheSize)

getUseSharedCache

public boolean getUseSharedCache()

setUseSharedCache

public void setUseSharedCache(boolean useSharedCache)

getExpectedConcurrency

public int getExpectedConcurrency()

setExpectedConcurrency

public void setExpectedConcurrency(int expectedConcurrency)

getUseHardLinkCheckpoints

public boolean getUseHardLinkCheckpoints()

setUseHardLinkCheckpoints

public void setUseHardLinkCheckpoints(boolean useHardLinkCheckpoints)

start

public void start()

Specified by:

start in interface org.springframework.context.Lifecycle

isRunning

public boolean isRunning()

Specified by:

isRunning in interface org.springframework.context.Lifecycle

stop

public void stop()

Specified by:

stop in interface org.springframework.context.Lifecycle

setup

protected void setup(File f,
         boolean create)
              throws com.sleepycat.je.DatabaseException,
                     IOException

Throws:

com.sleepycat.je.DatabaseException

IOException

closeDatabase

public void closeDatabase(com.sleepycat.je.Database db)

closeDatabase

public void closeDatabase(String name)

openDatabase

public com.sleepycat.je.Database openDatabase(String name,
                                     BdbModule.BdbConfig config,
                                     boolean usePriorData)
                                       throws com.sleepycat.je.DatabaseException

Open a Database inside this BdbModule's environment, and remember it for automatic close-at-module-stop.

Parameters:

name -

config -

usePriorData -

Returns:

Throws:

com.sleepycat.je.DatabaseException

getClassCatalog

public com.sleepycat.bind.serial.StoredClassCatalog getClassCatalog()

getStoredQueue

public <K extends Serializable> StoredQueue<K> getStoredQueue(String dbname,
                                                     Class<K> clazz,
                                                     boolean usePriorData)

getOIBCCache

public <V extends IdentityCacheable> ObjectIdentityBdbManualCache<V> getOIBCCache(String dbName,
                                                                         boolean recycle,
                                                                         Class<? extends V> valueClass)
                                                                       throws com.sleepycat.je.DatabaseException

Get an ObjectIdentityBdbCache, backed by a BDB Database of the given name, with the given value class type. If 'recycle' is true, reuse values already in the database; otherwise start with an empty cache.

Type Parameters:

V -

Parameters:

dbName -

recycle -

valueClass -

Returns:

Throws:

com.sleepycat.je.DatabaseException

getObjectCache

public <V extends IdentityCacheable> ObjectIdentityCache<V> getObjectCache(String dbName,
                                                                  boolean recycle,
                                                                  Class<V> valueClass)
                                                                throws com.sleepycat.je.DatabaseException

Throws:

com.sleepycat.je.DatabaseException

getObjectCache

public <V extends IdentityCacheable> ObjectIdentityCache<V> getObjectCache(String dbName,
                                                                  boolean recycle,
                                                                  Class<V> declaredClass,
                                                                  Class<? extends V> valueClass)
                                                                throws com.sleepycat.je.DatabaseException

Get an ObjectIdentityCache, backed by a BDB Database of the given name, with objects of the given valueClass type. If 'recycle' is true, reuse values already in the database; otherwise start with an empty cache.

Type Parameters:

V -

Parameters:

dbName -

recycle -

valueClass -

Returns:

Throws:

com.sleepycat.je.DatabaseException

startCheckpoint

public void startCheckpoint(Checkpoint checkpointInProgress)

Description copied from interface: Checkpointable

Note a checkpoint is about to begin. Most beans will ignore, but some can use this to wrap up tasks that shouldn't be half-done during a checkpoint (and hold a lock to prevent tasks from beginning during the checkpoint).

Specified by:

startCheckpoint in interface Checkpointable

Parameters:

checkpointInProgress - Checkpoint

doCheckpoint

public void doCheckpoint(Checkpoint checkpointInProgress)
                  throws IOException

Description copied from interface: Checkpointable

Do the actual checkpoint. Beans should ensure any state that they would need to recover gets saved in an appropriate place. A moderate amount of state may be saved as a JSONObject into the Checkpoint (which then keeps it in the checkpoint directory.) Larger amounts of state may be stored in a manner private to the bean, or via other collaborating beans (such as BdbModule) which checkpoint backgin database state.

Specified by:

doCheckpoint in interface Checkpointable

Parameters:

checkpointInProgress - Checkpoint

Throws:

IOException

doRecover

protected void doRecover()
                  throws IOException

Throws:

IOException

finishCheckpoint

public void finishCheckpoint(Checkpoint checkpointInProgress)

Description copied from interface: Checkpointable

Cleanup/unlock; need not complete for a checkpoint to be valid.

Specified by:

finishCheckpoint in interface Checkpointable

Parameters:

checkpointInProgress - Checkpoint

setRecoveryCheckpoint

public void setRecoveryCheckpoint(Checkpoint checkpoint)

Description copied from interface: Checkpointable

Used to inform a bean that it should restore its state from the given Checkpoint when launched (Lifecycle start()). May be autowired or configured after build, but before launch, for example via CheckpointService.setRecoveryCheckpointByName().

Specified by:

setRecoveryCheckpoint in interface Checkpointable

Parameters:

checkpoint - Checkpoint

close

public void close()

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

getDatabase

public com.sleepycat.je.Database getDatabase(String name)

getStoredMap

public <K,V> DisposableStoredSortedMap<K,V> getStoredMap(String dbName,
                                                Class<K> keyClass,
                                                Class<V> valueClass,
                                                boolean allowDuplicates,
                                                boolean usePriorData)

Creates a database-backed TempStoredSortedMap for transient reporting requirements. Calling the returned map's destroy() method when done discards the associated Database.

Type Parameters:

K -

V -

Parameters:

dbName - Database name to use; if null a name will be synthesized

keyClass - Class of keys; should be a Java primitive type

valueClass - Class of values; may be any serializable type

allowDuplicates - whether duplicate keys allowed

Returns:

destroy

public void destroy()
             throws Exception

Specified by:

destroy in interface org.springframework.beans.factory.DisposableBean

Throws:

Exception