/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2006-2008 Sun Microsystems, Inc.
|
* Portions Copyright 2011 ForgeRock AS
|
*/
|
package org.opends.server.backends.jeb;
|
|
import com.sleepycat.je.*;
|
|
import static org.opends.server.loggers.debug.DebugLogger.*;
|
import org.opends.server.loggers.debug.DebugTracer;
|
import org.opends.server.types.DebugLogLevel;
|
|
/**
|
* This class is a wrapper around the JE database object and provides basic
|
* read and write methods for entries.
|
*/
|
public abstract class DatabaseContainer
|
{
|
/**
|
* The tracer object for the debug logger.
|
*/
|
private static final DebugTracer TRACER = getTracer();
|
|
/**
|
* The database entryContainer.
|
*/
|
protected EntryContainer entryContainer;
|
|
/**
|
* The JE database configuration.
|
*/
|
protected DatabaseConfig dbConfig;
|
|
/**
|
* The name of the database within the entryContainer.
|
*/
|
protected String name;
|
|
/**
|
* The reference to the JE Environment.
|
*/
|
private Environment env;
|
|
/**
|
* A JE database handle opened through this database
|
* container.
|
*/
|
private Database database;
|
|
/**
|
* Create a new DatabaseContainer object.
|
*
|
* @param name The name of the entry database.
|
* @param env The JE Environment.
|
* @param entryContainer The entryContainer of the entry database.
|
* @throws DatabaseException if a JE database error occurs.
|
*/
|
protected DatabaseContainer(String name, Environment env,
|
EntryContainer entryContainer)
|
throws DatabaseException
|
{
|
this.env = env;
|
this.entryContainer = entryContainer;
|
this.name = name;
|
}
|
|
/**
|
* Opens a JE database in this database container. If the provided
|
* database configuration is transactional, a transaction will be
|
* created and used to perform the open.
|
*
|
* @throws DatabaseException if a JE database error occurs while
|
* openning the index.
|
*/
|
public void open() throws DatabaseException
|
{
|
if (dbConfig.getTransactional())
|
{
|
// Open the database under a transaction.
|
Transaction txn =
|
entryContainer.beginTransaction();
|
try
|
{
|
database = env.openDatabase(txn, name, dbConfig);
|
if (debugEnabled())
|
{
|
TRACER.debugVerbose("JE database %s opened. txnid=%d",
|
database.getDatabaseName(),
|
txn.getId());
|
}
|
EntryContainer.transactionCommit(txn);
|
}
|
catch (DatabaseException e)
|
{
|
EntryContainer.transactionAbort(txn);
|
throw e;
|
}
|
}
|
else
|
{
|
database = env.openDatabase(null, name, dbConfig);
|
if (debugEnabled())
|
{
|
TRACER.debugVerbose("JE database %s opened. txnid=none",
|
database.getDatabaseName());
|
}
|
}
|
}
|
|
/**
|
* Flush any cached database information to disk and close the
|
* database container.
|
*
|
* The database container should not be closed while other processes
|
* aquired the container. The container should not be closed
|
* while cursors handles into the database remain open, or
|
* transactions that include operations on the database have not yet
|
* been commited or aborted.
|
*
|
* The container may not be accessed again after this method is
|
* called, regardless of the method's success or failure.
|
*
|
* @throws DatabaseException if an error occurs.
|
*/
|
synchronized void close() throws DatabaseException
|
{
|
if(dbConfig.getDeferredWrite())
|
{
|
database.sync();
|
}
|
database.close();
|
database = null;
|
|
if(debugEnabled())
|
{
|
TRACER.debugInfo("Closed database %s", name);
|
}
|
}
|
|
/**
|
* Replace or insert a record into a JE database, with optional debug logging.
|
* This is a simple wrapper around the JE Database.put method.
|
* @param txn The JE transaction handle, or null if none.
|
* @param key The record key.
|
* @param data The record value.
|
* @return The operation status.
|
* @throws DatabaseException If an error occurs in the JE operation.
|
*/
|
protected OperationStatus put(Transaction txn, DatabaseEntry key,
|
DatabaseEntry data)
|
throws DatabaseException
|
{
|
OperationStatus status = database.put(txn, key, data);
|
if (debugEnabled())
|
{
|
TRACER.debugJEAccess(DebugLogLevel.VERBOSE, status, database,
|
txn, key, data);
|
}
|
return status;
|
}
|
|
/**
|
* Read a record from a JE database, with optional debug logging. This is a
|
* simple wrapper around the JE Database.get method.
|
* @param txn The JE transaction handle, or null if none.
|
* @param key The key of the record to be read.
|
* @param data The record value returned as output. Its byte array does not
|
* need to be initialized by the caller.
|
* @param lockMode The JE locking mode to be used for the read.
|
* @return The operation status.
|
* @throws DatabaseException If an error occurs in the JE operation.
|
*/
|
protected OperationStatus read(Transaction txn,
|
DatabaseEntry key, DatabaseEntry data,
|
LockMode lockMode)
|
throws DatabaseException
|
{
|
OperationStatus status = database.get(txn, key, data, lockMode);
|
if (debugEnabled())
|
{
|
TRACER.debugJEAccess(DebugLogLevel.VERBOSE, status, database, txn, key,
|
data);
|
}
|
return status;
|
}
|
|
/**
|
* Insert a record into a JE database, with optional debug logging. This is a
|
* simple wrapper around the JE Database.putNoOverwrite method.
|
* @param txn The JE transaction handle, or null if none.
|
* @param key The record key.
|
* @param data The record value.
|
* @return The operation status.
|
* @throws DatabaseException If an error occurs in the JE operation.
|
*/
|
protected OperationStatus insert(Transaction txn,
|
DatabaseEntry key, DatabaseEntry data)
|
throws DatabaseException
|
{
|
OperationStatus status = database.putNoOverwrite(txn, key, data);
|
if (debugEnabled())
|
{
|
TRACER.debugJEAccess(DebugLogLevel.VERBOSE, status, database, txn, key,
|
data);
|
}
|
return status;
|
}
|
|
/**
|
* Delete a record from a JE database, with optional debug logging. This is a
|
* simple wrapper around the JE Database.delete method.
|
* @param txn The JE transaction handle, or null if none.
|
* @param key The key of the record to be read.
|
* @return The operation status.
|
* @throws DatabaseException If an error occurs in the JE operation.
|
*/
|
protected OperationStatus delete(Transaction txn,
|
DatabaseEntry key)
|
throws DatabaseException
|
{
|
OperationStatus status = database.delete(txn, key);
|
if (debugEnabled())
|
{
|
TRACER.debugJEAccess(DebugLogLevel.VERBOSE, status, database, txn,
|
key, null);
|
}
|
return status;
|
}
|
|
/**
|
* Open a JE cursor on the JE database. This is a simple wrapper around
|
* the JE Database.openCursor method.
|
* @param txn A JE database transaction to be used by the cursor,
|
* or null if none.
|
* @param cursorConfig The JE cursor configuration.
|
* @return A JE cursor.
|
* @throws DatabaseException If an error occurs while attempting to open
|
* the cursor.
|
*/
|
public Cursor openCursor(Transaction txn, CursorConfig cursorConfig)
|
throws DatabaseException
|
{
|
return database.openCursor(txn, cursorConfig);
|
}
|
|
/**
|
* Open a JE disk ordered cursor on the JE database. This is a
|
* simple wrapper around the JE Database.openCursor method.
|
* @param cursorConfig The JE disk ordered cursor configuration.
|
* @return A JE disk ordered cursor.
|
* @throws DatabaseException If an error occurs while attempting to open
|
* the cursor.
|
*/
|
public DiskOrderedCursor openCursor(DiskOrderedCursorConfig cursorConfig)
|
throws DatabaseException
|
{
|
return database.openCursor(cursorConfig);
|
|
}
|
|
/**
|
* Get the count of key/data pairs in the database in a JE database.
|
* This is a simple wrapper around the JE Database.count method.
|
* @return The count of key/data pairs in the database.
|
* @throws DatabaseException If an error occurs in the JE operation.
|
*/
|
public long getRecordCount() throws DatabaseException
|
{
|
long count = database.count();
|
if (debugEnabled())
|
{
|
TRACER.debugJEAccess(DebugLogLevel.VERBOSE, OperationStatus.SUCCESS,
|
database, null, null, null);
|
}
|
return count;
|
}
|
|
/**
|
* Get a string representation of this object.
|
* @return return A string representation of this object.
|
*/
|
public String toString()
|
{
|
return name;
|
}
|
|
/**
|
* Get the JE database name for this database container.
|
*
|
* @return JE database name for this database container.
|
*/
|
public String getName()
|
{
|
return name;
|
}
|
|
/**
|
* Preload the database into cache.
|
*
|
* @param config The preload configuration.
|
* @return Statistics about the preload process.
|
* @throws DatabaseException If an JE database error occurs
|
* during the preload.
|
*/
|
public PreloadStats preload(PreloadConfig config)
|
throws DatabaseException
|
{
|
return database.preload(config);
|
}
|
|
/**
|
* Set the JE database name to use for this container.
|
*
|
* @param name The database name to use for this container.
|
*/
|
void setName(String name)
|
{
|
this.name = name;
|
}
|
}
|
