/** {@inheritDoc} */
@Override()
public void search(SearchOperation searchOperation)
throws DirectoryException, CanceledOperationException {
readerBegin();
EntryContainer ec;
if (rootContainer != null) {
ec = rootContainer.getEntryContainer(searchOperation.getBaseDN());
} else {
Message message = ERR_ROOT_CONTAINER_NOT_INITIALIZED.get(getBackendID());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
ec.sharedLock.lock();
try {
ec.search(searchOperation);
} catch (DatabaseException e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
throw createDirectoryException(e);
} finally {
ec.sharedLock.unlock();
readerEnd();
}
}
/** {@inheritDoc} */
@Override()
public void replaceEntry(Entry oldEntry, Entry newEntry, ModifyOperation modifyOperation)
throws DirectoryException, CanceledOperationException {
checkDiskSpace(modifyOperation);
writerBegin();
DN entryDN = newEntry.getDN();
EntryContainer ec;
if (rootContainer != null) {
ec = rootContainer.getEntryContainer(entryDN);
} else {
Message message = ERR_ROOT_CONTAINER_NOT_INITIALIZED.get(getBackendID());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
ec.sharedLock.lock();
try {
ec.replaceEntry(oldEntry, newEntry, modifyOperation);
} catch (DatabaseException e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
throw createDirectoryException(e);
} finally {
ec.sharedLock.unlock();
writerEnd();
}
}
/** {@inheritDoc} */
@Override()
public Entry getEntry(DN entryDN) throws DirectoryException {
readerBegin();
EntryContainer ec;
if (rootContainer != null) {
ec = rootContainer.getEntryContainer(entryDN);
} else {
Message message = ERR_ROOT_CONTAINER_NOT_INITIALIZED.get(getBackendID());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
ec.sharedLock.lock();
Entry entry;
try {
entry = ec.getEntry(entryDN);
} catch (DatabaseException e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
throw createDirectoryException(e);
} finally {
ec.sharedLock.unlock();
readerEnd();
}
return entry;
}
/** {@inheritDoc} */
@Override()
public long numSubordinates(DN entryDN, boolean subtree) throws DirectoryException {
EntryContainer ec;
if (rootContainer != null) {
ec = rootContainer.getEntryContainer(entryDN);
} else {
Message message = ERR_ROOT_CONTAINER_NOT_INITIALIZED.get(getBackendID());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
if (ec == null) {
return -1;
}
readerBegin();
ec.sharedLock.lock();
try {
long count = ec.getNumSubordinates(entryDN, subtree);
if (count == Long.MAX_VALUE) {
// The index entry limit has exceeded and there is no count maintained.
return -1;
}
return count;
} catch (DatabaseException e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
throw createDirectoryException(e);
} finally {
ec.sharedLock.unlock();
readerEnd();
}
}
/**
* Sets the trusted status of all of the indexes, vlvIndexes, id2children and id2subtree indexes.
*
* @param trusted True if the indexes should be trusted or false otherwise.
* @throws DatabaseException If an error occurred setting the indexes to trusted.
*/
public void setIndexesTrusted(boolean trusted) throws DatabaseException {
entryContainer.getID2Children().setTrusted(null, trusted);
entryContainer.getID2Subtree().setTrusted(null, trusted);
for (AttributeIndex attributeIndex : entryContainer.getAttributeIndexes()) {
for (Index index : attributeIndex.getAllIndexes()) {
setTrusted(index, trusted);
}
}
for (VLVIndex vlvIdx : entryContainer.getVLVIndexes()) {
vlvIdx.setTrusted(null, trusted);
}
}
/** {@inheritDoc} */
@Override()
public boolean isIndexed(AttributeType attributeType, IndexType indexType) {
try {
EntryContainer ec = rootContainer.getEntryContainer(baseDNs[0]);
AttributeIndex ai = ec.getAttributeIndex(attributeType);
if (ai == null) {
return false;
}
Set<LocalDBIndexCfgDefn.IndexType> indexTypes = ai.getConfiguration().getIndexType();
switch (indexType) {
case PRESENCE:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.PRESENCE);
case EQUALITY:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.EQUALITY);
case SUBSTRING:
case SUBINITIAL:
case SUBANY:
case SUBFINAL:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.SUBSTRING);
case GREATER_OR_EQUAL:
case LESS_OR_EQUAL:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.ORDERING);
case APPROXIMATE:
return indexTypes.contains(LocalDBIndexCfgDefn.IndexType.APPROXIMATE);
default:
return false;
}
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
return false;
}
}
/** {@inheritDoc} */
@Override()
public void renameEntry(DN currentDN, Entry entry, ModifyDNOperation modifyDNOperation)
throws DirectoryException, CanceledOperationException {
checkDiskSpace(modifyDNOperation);
writerBegin();
EntryContainer currentContainer;
if (rootContainer != null) {
currentContainer = rootContainer.getEntryContainer(currentDN);
} else {
Message message = ERR_ROOT_CONTAINER_NOT_INITIALIZED.get(getBackendID());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
EntryContainer container = rootContainer.getEntryContainer(entry.getDN());
if (currentContainer != container) {
// FIXME: No reason why we cannot implement a move between containers
// since the containers share the same database environment.
Message msg = WARN_JEB_FUNCTION_NOT_SUPPORTED.get();
throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, msg);
}
currentContainer.sharedLock.lock();
try {
currentContainer.renameEntry(currentDN, entry, modifyDNOperation);
} catch (DatabaseException e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
throw createDirectoryException(e);
} finally {
currentContainer.sharedLock.unlock();
writerEnd();
}
}
/**
* Creates a suffix instance using the specified parameters.
*
* @param entryContainer The entry container pertaining to the suffix.
* @param srcEntryContainer The original entry container.
* @param includeBranches The include branches.
* @param excludeBranches The exclude branches.
*/
Suffix(
EntryContainer entryContainer,
EntryContainer srcEntryContainer,
List<DN> includeBranches,
List<DN> excludeBranches) {
this.entryContainer = entryContainer;
this.srcEntryContainer = srcEntryContainer;
this.baseDN = entryContainer.getBaseDN();
if (includeBranches != null) {
this.includeBranches = includeBranches;
} else {
this.includeBranches = new ArrayList<>(0);
}
if (excludeBranches != null) {
this.excludeBranches = excludeBranches;
} else {
this.excludeBranches = new ArrayList<>(0);
}
}
/**
* Returns the DN2ID instance pertaining to a suffix instance.
*
* @return A DN2ID instance that can be used to manipulate the DN2ID database.
*/
public DN2ID getDN2ID() {
return entryContainer.getDN2ID();
}
/**
* Return the Attribute Type - Index map used to map an attribute type to an index instance.
*
* @return A suffixes Attribute Type - Index map.
*/
public Map<AttributeType, AttributeIndex> getAttrIndexMap() {
return entryContainer.getAttributeIndexMap();
}
/**
* Returns the DN2URI instance pertaining to a suffix instance.
*
* @return A DN2URI instance that can be used to manipulate the DN2URI database.
*/
public DN2URI getDN2URI() {
return entryContainer.getDN2URI();
}
/**
* Returns the ID2Entry instance pertaining to a suffix instance.
*
* @return A ID2Entry instance that can be used to manipulate the ID2Entry database.
*/
public ID2Entry getID2Entry() {
return entryContainer.getID2Entry();
}
/** {@inheritDoc} */
public ConfigChangeResult applyConfigurationChange(LocalDBBackendCfg newCfg) {
ConfigChangeResult ccr;
ResultCode resultCode = ResultCode.SUCCESS;
ArrayList<Message> messages = new ArrayList<Message>();
try {
if (rootContainer != null) {
DN[] newBaseDNs = new DN[newCfg.getBaseDN().size()];
newBaseDNs = newCfg.getBaseDN().toArray(newBaseDNs);
// Check for changes to the base DNs.
for (DN baseDN : cfg.getBaseDN()) {
boolean found = false;
for (DN dn : newBaseDNs) {
if (dn.equals(baseDN)) {
found = true;
}
}
if (!found) {
// The base DN was deleted.
DirectoryServer.deregisterBaseDN(baseDN);
EntryContainer ec = rootContainer.unregisterEntryContainer(baseDN);
ec.close();
ec.delete();
}
}
for (DN baseDN : newBaseDNs) {
if (!rootContainer.getBaseDNs().contains(baseDN)) {
try {
// The base DN was added.
EntryContainer ec = rootContainer.openEntryContainer(baseDN, null);
rootContainer.registerEntryContainer(baseDN, ec);
DirectoryServer.registerBaseDN(baseDN, this, false);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
resultCode = DirectoryServer.getServerErrorResultCode();
messages.add(
ERR_BACKEND_CANNOT_REGISTER_BASEDN.get(
String.valueOf(baseDN), String.valueOf(e)));
ccr = new ConfigChangeResult(resultCode, false, messages);
return ccr;
}
}
}
baseDNs = newBaseDNs;
}
if (cfg.getDiskFullThreshold() != newCfg.getDiskFullThreshold()
|| cfg.getDiskLowThreshold() != newCfg.getDiskLowThreshold()) {
diskMonitor.setFullThreshold(newCfg.getDiskFullThreshold());
diskMonitor.setLowThreshold(newCfg.getDiskLowThreshold());
}
// Put the new configuration in place.
this.cfg = newCfg;
} catch (Exception e) {
messages.add(Message.raw(stackTraceToSingleLineString(e)));
ccr = new ConfigChangeResult(DirectoryServer.getServerErrorResultCode(), false, messages);
return ccr;
}
ccr = new ConfigChangeResult(resultCode, false, messages);
return ccr;
}
/** {@inheritDoc} */
@Override
public LDIFImportResult importLDIF(
LDIFImportConfig importConfig, RootContainer rootContainer, ServerContext serverContext)
throws DirectoryException {
try {
ScheduledThreadPoolExecutor timerService = new ScheduledThreadPoolExecutor(1);
try {
final LDIFReader reader;
try {
reader = new LDIFReader(importConfig);
} catch (Exception e) {
LocalizableMessage m =
ERR_LDIF_BACKEND_CANNOT_CREATE_LDIF_READER.get(stackTraceToSingleLineString(e));
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), m, e);
}
long importCount = 0;
final long startTime = System.currentTimeMillis();
timerService.scheduleAtFixedRate(
new ImportProgress(reader),
IMPORT_PROGRESS_INTERVAL,
IMPORT_PROGRESS_INTERVAL,
TimeUnit.MILLISECONDS);
while (true) {
final Entry entry;
try {
entry = reader.readEntry();
if (entry == null) {
break;
}
} catch (LDIFException le) {
if (!le.canContinueReading()) {
LocalizableMessage m =
ERR_LDIF_BACKEND_ERROR_READING_LDIF.get(stackTraceToSingleLineString(le));
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), m, le);
}
continue;
}
final DN dn = entry.getName();
final EntryContainer ec = rootContainer.getEntryContainer(dn);
if (ec == null) {
final LocalizableMessage m = ERR_LDIF_SKIP.get(dn);
logger.error(m);
reader.rejectLastEntry(m);
continue;
}
try {
ec.addEntry(entry, null);
importCount++;
} catch (DirectoryException e) {
switch (e.getResultCode().asEnum()) {
case ENTRY_ALREADY_EXISTS:
if (importConfig.replaceExistingEntries()) {
final Entry oldEntry = ec.getEntry(entry.getName());
ec.replaceEntry(oldEntry, entry, null);
} else {
reader.rejectLastEntry(WARN_IMPORT_ENTRY_EXISTS.get());
}
break;
case NO_SUCH_OBJECT:
reader.rejectLastEntry(ERR_IMPORT_PARENT_NOT_FOUND.get(dn.parent()));
break;
default:
// Not sure why it failed.
reader.rejectLastEntry(e.getMessageObject());
break;
}
}
}
final long finishTime = System.currentTimeMillis();
waitForShutdown(timerService);
final long importTime = finishTime - startTime;
float rate = 0;
if (importTime > 0) {
rate = 1000f * reader.getEntriesRead() / importTime;
}
logger.info(
NOTE_IMPORT_FINAL_STATUS,
reader.getEntriesRead(),
importCount,
reader.getEntriesIgnored(),
reader.getEntriesRejected(),
0,
importTime / 1000,
rate);
return new LDIFImportResult(
reader.getEntriesRead(), reader.getEntriesRejected(), reader.getEntriesIgnored());
} finally {
rootContainer.close();
// if not already stopped, then stop it
waitForShutdown(timerService);
}
} catch (DirectoryException e) {
logger.traceException(e);
throw e;
} catch (OpenDsException e) {
logger.traceException(e);
throw new DirectoryException(getServerErrorResultCode(), e.getMessageObject());
} catch (Exception e) {
logger.traceException(e);
throw new DirectoryException(
getServerErrorResultCode(), LocalizableMessage.raw(e.getMessage()));
}
}