Index.java revision 8df85caca96d8bb79fcc2cf01cf6ef0a3f06930d
/*
* 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
* 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-2010 Sun Microsystems, Inc.
* Portions Copyright 2012-2015 ForgeRock AS
*/
/**
* Represents an index implemented by a JE database in which each key maps to
* a set of entry IDs. The key is a byte array, and is constructed from some
* normalized form of an attribute value (or fragment of a value) appearing
* in the entry.
*/
class Index extends DatabaseContainer
{
/** The indexer object to construct index keys from LDAP attribute values. */
/** The limit on the number of entry IDs that may be indexed by one key. */
private int indexEntryLimit;
/**
* Limit on the number of entry IDs that may be retrieved by cursoring
* through an index.
*/
private final int cursorEntryLimit;
/**
* Number of keys that have exceeded the entry limit since this
* object was created.
*/
private int entryLimitExceededCount;
/**
* Whether to maintain a count of IDs for a key once the entry limit
* has exceeded.
*/
private final boolean maintainCount;
/**
* A flag to indicate if this index should be trusted to be consistent
* with the entries database. If not trusted, we assume that existing
* entryIDSets for a key is still accurate. However, keys that do not
* exist are undefined instead of an empty entryIDSet. The following
* rules will be observed when the index is not trusted:
*
* - no entryIDs will be added to a non-existing key.
* - undefined entryIdSet will be returned whenever a key is not found.
*/
private boolean trusted;
/**
* A flag to indicate if a rebuild process is running on this index.
* During the rebuild process, we assume that no entryIDSets are
* accurate and return an undefined set on all read operations.
* However all write operations will succeed. The rebuildRunning
* flag overrides all behaviors of the trusted flag.
*/
private boolean rebuildRunning;
private final ImportIDSet newImportIDSet;
/**
* Create a new index object.
* @param name The name of the index database within the entryContainer.
* @param storage The JE Storage
* @param indexer The indexer object to construct index keys from LDAP
* attribute values.
* @param state The state database to persist index state info.
* @param indexEntryLimit The configured limit on the number of entry IDs
* that may be indexed by one key.
* @param cursorEntryLimit The configured limit on the number of entry IDs
* @param maintainCount Whether to maintain a count of IDs for a key once
* the entry limit has exceeded.
* @param txn The transaction to use when creating this object
* @param entryContainer The database entryContainer holding this index.
* @throws StorageRuntimeException If an error occurs in the JE database.
*/
throws StorageRuntimeException
{
this.indexEntryLimit = indexEntryLimit;
this.cursorEntryLimit = cursorEntryLimit;
this.maintainCount = maintainCount;
{
// If there are no entries in the entry container then there
// is no reason why this index can't be upgraded to trusted.
setTrusted(txn, true);
}
}
{
}
{
}
/**
* Delete the specified import ID set from the import ID set associated with the key.
*
* @param txn The database transaction
* @param importIdSet The import ID set to delete.
* @throws StorageRuntimeException If a database error occurs.
*/
{
{
}
else
{
}
} else {
// Should never happen -- the keys should always be there.
throw new RuntimeException();
}
}
/**
* Insert the specified import ID set into this index. Creates a DB cursor if needed.
*
* @param txn The database transaction
* @param importIdSet The set of import IDs.
* @throws StorageRuntimeException If a database error occurs.
*/
{
}
} else {
if(!importIdSet.isDefined()) {
}
}
}
throws StorageRuntimeException
{
/*
* Check the special condition where both deletedIDs and addedIDs are null. This is used when
* deleting entries and corresponding id2children and id2subtree records must be completely
* removed.
*/
{
{
}
return;
}
// Handle cases where nothing is changed early to avoid DB access.
{
return;
}
if (maintainCount)
{
}
else
{
/*
* Avoid taking a write lock on a record which has hit all IDs because it is likely to be a
* point of contention.
*/
{
if (entryIDList.isDefined())
{
} // else the record exists but we've hit all IDs.
}
else
{
{
}
if ((rebuildRunning || trusted)
{
}
}
}
}
{
}
{
}
private void updateKeyWithRMW(WriteableStorage txn, ByteString key, EntryIDSet deletedIDs, EntryIDSet addedIDs)
throws StorageRuntimeException
{
{
{
}
else
{
// No more IDs, so remove the key. If index is not
// trusted then this will cause all subsequent reads
// for this key to return undefined set.
}
}
else
{
{
}
{
}
}
}
{
{
{
if(deletedIDs != null)
{
}
{
if(maintainCount)
{
}
else
{
entryIDList = new EntryIDSet();
}
if(logger.isTraceEnabled())
{
"Limit: %d. ID list size: %d.\nKey:%s",
}
}
else
{
if(deletedIDs != null)
{
}
}
}
else
{
if(deletedIDs != null)
{
}
}
}
else if(deletedIDs != null)
{
}
return entryIDList;
}
{
}
{
if (logger.isTraceEnabled())
{
}
setTrusted(txn, false);
}
{
}
{
}
/**
* Check if an entry ID is in the set of IDs indexed by a given key.
*
* @param txn
* A database transaction.
* @param key
* The index key.
* @param entryID
* The entry ID.
* @return true if the entry ID is indexed by the given key, false if it is not indexed by the
* given key, undefined if the key has exceeded the entry limit.
* @throws StorageRuntimeException
* If an error occurs in the JE database.
*/
throws StorageRuntimeException
{
if(rebuildRunning)
{
return ConditionResult.UNDEFINED;
}
{
if (!entryIDList.isDefined())
{
return ConditionResult.UNDEFINED;
}
}
else if (trusted)
{
return ConditionResult.FALSE;
}
else
{
return ConditionResult.UNDEFINED;
}
}
{
if(rebuildRunning)
{
return new EntryIDSet();
}
try
{
{
if(trusted)
{
}
else
{
return new EntryIDSet();
}
}
}
catch (StorageRuntimeException e)
{
logger.traceException(e);
return new EntryIDSet();
}
}
/**
* Reads a range of keys and collects all their entry IDs into a
* single set.
*
* @param txn The transaction to use for the operation
* @param lower The lower bound of the range. A 0 length byte array indicates
* no lower bound and the range will start from the
* smallest key.
* @param upper The upper bound of the range. A 0 length byte array indicates
* no upper bound and the range will end at the largest
* key.
* @param lowerIncluded true if a key exactly matching the lower bound
* is included in the range, false if only keys
* strictly greater than the lower bound are included.
* This value is ignored if the lower bound is not
* specified.
* @param upperIncluded true if a key exactly matching the upper bound
* is included in the range, false if only keys
* strictly less than the upper bound are included.
* This value is ignored if the upper bound is not
* specified.
* @return The set of entry IDs.
*/
{
// If this index is not trusted, then just return an undefined id set.
if(rebuildRunning || !trusted)
{
return new EntryIDSet();
}
try
{
// Total number of IDs found so far.
int totalIDCount = 0;
try
{
boolean success;
// Set the lower bound if necessary.
{
// Initialize the cursor to the lower bound.
// Advance past the lower bound if necessary.
{
// Do not include the lower value.
}
}
else
{
}
if (!success)
{
// There are no values.
}
// Step through the keys until we hit the upper bound or the last key.
while (success)
{
// Check against the upper bound if necessary
{
{
break;
}
}
{
// There is no point continuing.
return list;
}
{
// There are too many. Give up and return an undefined list.
return new EntryIDSet();
}
}
}
finally
{
}
}
catch (StorageRuntimeException e)
{
logger.traceException(e);
return new EntryIDSet();
}
}
{
return entryLimitExceededCount;
}
throws StorageRuntimeException
{
{
}
}
throws StorageRuntimeException
{
{
}
}
void modifyEntry(IndexBuffer buffer, EntryID entryID, Entry oldEntry, Entry newEntry, List<Modification> mods,
{
{
if(modifiedKey.getValue())
{
}
else
{
}
}
}
boolean setIndexEntryLimit(int indexEntryLimit)
{
final boolean rebuildRequired = this.indexEntryLimit < indexEntryLimit && entryLimitExceededCount > 0;
this.indexEntryLimit = indexEntryLimit;
return rebuildRequired;
}
{
}
int getIndexEntryLimit()
{
return indexEntryLimit;
}
{
}
synchronized boolean isTrusted()
{
return trusted;
}
synchronized boolean isRebuildRunning()
{
return rebuildRunning;
}
synchronized void setRebuildStatus(boolean rebuildRunning)
{
this.rebuildRunning = rebuildRunning;
}
boolean getMaintainCount()
{
return maintainCount;
}
}