/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions Copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2008-2010 Sun Microsystems, Inc.
|
* Portions Copyright 2011-2016 ForgeRock AS.
|
*/
|
package org.opends.server.extensions;
|
|
import java.util.List;
|
import java.util.SortedMap;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.i18n.slf4j.LocalizedLogger;
|
import org.forgerock.opendj.config.server.ConfigChangeResult;
|
import org.forgerock.opendj.config.server.ConfigException;
|
import org.forgerock.opendj.config.server.ConfigurationChangeListener;
|
import org.forgerock.opendj.server.config.server.EntryCacheCfg;
|
import org.opends.server.api.LocalBackend;
|
import org.opends.server.api.LocalBackendInitializationListener;
|
import org.opends.server.api.EntryCache;
|
import org.opends.server.api.MonitorData;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.core.ServerContext;
|
import org.forgerock.opendj.ldap.DN;
|
import org.opends.server.types.Entry;
|
import org.opends.server.types.InitializationException;
|
|
/**
|
* This class defines the default entry cache which acts as an arbiter for
|
* every entry cache implementation configured and installed within the
|
* Directory Server or acts an an empty cache if no implementation specific
|
* entry cache is configured. It does not actually store any entries, so
|
* all calls to the entry cache public API are routed to underlying entry
|
* cache according to the current configuration order and preferences.
|
*/
|
public class DefaultEntryCache
|
extends EntryCache<EntryCacheCfg>
|
implements ConfigurationChangeListener<EntryCacheCfg>,
|
LocalBackendInitializationListener
|
{
|
private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();
|
|
/**
|
* The entry cache order array reflects all currently configured and
|
* active entry cache implementations in cache level specific order.
|
*/
|
private static EntryCache<? extends EntryCacheCfg>[] cacheOrder =
|
new EntryCache<?>[0];
|
|
/** Creates a new instance of this default entry cache. */
|
public DefaultEntryCache()
|
{
|
super();
|
|
// Register with backend initialization listener to clear cache
|
// entries belonging to given backend that about to go offline.
|
DirectoryServer.getInstance().getServerContext().getBackendConfigManager()
|
.registerLocalBackendInitializationListener(this);
|
}
|
|
@Override
|
public void initializeEntryCache(ServerContext serverContext, EntryCacheCfg configEntry)
|
throws ConfigException, InitializationException
|
{
|
// No implementation required.
|
}
|
|
@Override
|
public void finalizeEntryCache()
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
entryCache.finalizeEntryCache();
|
}
|
// ReInitialize cache order array.
|
cacheOrder = new EntryCache<?>[0];
|
}
|
|
@Override
|
public boolean containsEntry(DN entryDN)
|
{
|
if (entryDN == null) {
|
return false;
|
}
|
|
for (EntryCache<?> entryCache : cacheOrder) {
|
if (entryCache.containsEntry(entryDN)) {
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
@Override
|
public Entry getEntry(String backendID, long entryID)
|
{
|
for (EntryCache<? extends EntryCacheCfg> entryCache : cacheOrder)
|
{
|
Entry entry = entryCache.getEntry(backendID, entryID);
|
if (entry != null)
|
{
|
return entry.duplicate(true);
|
}
|
}
|
|
// Indicate global cache miss.
|
if (cacheOrder.length != 0)
|
{
|
cacheMisses.getAndIncrement();
|
}
|
return null;
|
}
|
|
@Override
|
public Entry getEntry(DN entryDN)
|
{
|
for (EntryCache<? extends EntryCacheCfg> entryCache : cacheOrder)
|
{
|
Entry entry = entryCache.getEntry(entryDN);
|
if (entry != null)
|
{
|
return entry.duplicate(true);
|
}
|
}
|
|
// Indicate global cache miss.
|
if (cacheOrder.length != 0)
|
{
|
cacheMisses.getAndIncrement();
|
}
|
return null;
|
}
|
|
@Override
|
public long getEntryID(DN entryDN)
|
{
|
for (EntryCache<?> entryCache : cacheOrder)
|
{
|
long entryID = entryCache.getEntryID(entryDN);
|
if (entryID != -1)
|
{
|
return entryID;
|
}
|
}
|
return -1;
|
}
|
|
@Override
|
public DN getEntryDN(String backendID, long entryID)
|
{
|
for (EntryCache<?> entryCache : cacheOrder)
|
{
|
DN entryDN = entryCache.getEntryDN(backendID, entryID);
|
if (entryDN != null)
|
{
|
return entryDN;
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public void putEntry(Entry entry, String backendID, long entryID)
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
// The first cache in the order which can take this entry
|
// gets it.
|
if (entryCache.filtersAllowCaching(entry)) {
|
entryCache.putEntry(entry.duplicate(false), backendID, entryID);
|
break;
|
}
|
}
|
}
|
|
@Override
|
public boolean putEntryIfAbsent(Entry entry, String backendID, long entryID)
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
// The first cache in the order which can take this entry
|
// gets it.
|
if (entryCache.filtersAllowCaching(entry)) {
|
return entryCache.putEntryIfAbsent(entry.duplicate(false),
|
backendID, entryID);
|
}
|
}
|
|
return false;
|
}
|
|
@Override
|
public void removeEntry(DN entryDN)
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
if (entryCache.containsEntry(entryDN)) {
|
entryCache.removeEntry(entryDN);
|
break;
|
}
|
}
|
}
|
|
@Override
|
public void clear()
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
entryCache.clear();
|
}
|
}
|
|
@Override
|
public void clearBackend(String backendID)
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
entryCache.clearBackend(backendID);
|
}
|
}
|
|
@Override
|
public void handleLowMemory()
|
{
|
for (EntryCache<?> entryCache : cacheOrder) {
|
entryCache.handleLowMemory();
|
}
|
}
|
|
@Override
|
public boolean isConfigurationChangeAcceptable(
|
EntryCacheCfg configuration,
|
List<LocalizableMessage> unacceptableReasons
|
)
|
{
|
// No implementation required.
|
return true;
|
}
|
|
@Override
|
public ConfigChangeResult applyConfigurationChange(EntryCacheCfg configuration)
|
{
|
// No implementation required.
|
return new ConfigChangeResult();
|
}
|
|
@Override
|
public MonitorData getMonitorData()
|
{
|
// The sum of cache hits of all active entry cache implementations.
|
long entryCacheHits = 0;
|
// Common for all active entry cache implementations.
|
long entryCacheMisses = cacheMisses.longValue();
|
// The sum of cache counts of all active entry cache implementations.
|
long currentEntryCacheCount = 0;
|
|
for (EntryCache<?> entryCache : cacheOrder) {
|
// Get cache hits and counts from every active cache.
|
entryCacheHits += entryCache.getCacheHits();
|
currentEntryCacheCount += entryCache.getCacheCount();
|
}
|
|
try {
|
return EntryCacheCommon.getGenericMonitorData(
|
entryCacheHits,
|
entryCacheMisses,
|
null,
|
null,
|
currentEntryCacheCount,
|
null
|
);
|
} catch (Exception e) {
|
logger.traceException(e);
|
return new MonitorData(0);
|
}
|
}
|
|
@Override
|
public Long getCacheCount()
|
{
|
long cacheCount = 0;
|
for (EntryCache<?> entryCache : cacheOrder) {
|
cacheCount += entryCache.getCacheCount();
|
}
|
return cacheCount;
|
}
|
|
@Override
|
public String toVerboseString()
|
{
|
StringBuilder sb = new StringBuilder();
|
for (EntryCache<?> entryCache : cacheOrder)
|
{
|
String s = entryCache.toVerboseString();
|
if (s != null)
|
{
|
sb.append(s);
|
}
|
}
|
String verboseString = sb.toString();
|
return verboseString.length() > 0 ? verboseString : null;
|
}
|
|
/**
|
* Retrieves the current cache order array.
|
*
|
* @return The current cache order array.
|
*/
|
public final static EntryCache<? extends EntryCacheCfg>[] getCacheOrder()
|
{
|
return DefaultEntryCache.cacheOrder;
|
}
|
|
/**
|
* Sets the current cache order array.
|
*
|
* @param cacheOrderMap The current cache order array.
|
*/
|
public final static void setCacheOrder(
|
SortedMap<Integer,
|
EntryCache<? extends EntryCacheCfg>> cacheOrderMap)
|
{
|
DefaultEntryCache.cacheOrder =
|
cacheOrderMap.values().toArray(new EntryCache<?>[0]);
|
}
|
|
/**
|
* Performs any processing that may be required whenever a backend
|
* is initialized for use in the Directory Server. This method will
|
* be invoked after the backend has been initialized but before it
|
* has been put into service.
|
*
|
* @param backend The backend that has been initialized and is
|
* about to be put into service.
|
*/
|
@Override
|
public void performBackendPreInitializationProcessing(LocalBackend<?> backend)
|
{
|
// Do nothing.
|
}
|
|
/**
|
* Performs any processing that may be required whenever a backend
|
* is finalized. This method will be invoked after the backend has
|
* been taken out of service but before it has been finalized.
|
*
|
* @param backend The backend that has been taken out of service
|
* and is about to be finalized.
|
*/
|
@Override
|
public void performBackendPostFinalizationProcessing(LocalBackend<?> backend)
|
{
|
// Do not clear any backends if the server is shutting down.
|
if (!DirectoryServer.getInstance().isShuttingDown())
|
{
|
clearBackend(backend.getBackendID());
|
}
|
}
|
|
@Override
|
public void performBackendPostInitializationProcessing(LocalBackend<?> backend) {
|
// Nothing to do.
|
}
|
|
@Override
|
public void performBackendPreFinalizationProcessing(LocalBackend<?> backend) {
|
// Nothing to do.
|
}
|
}
|
