/*
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. 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 2011-2012 ForgeRock AS
|
*/
|
package org.opends.server.core;
|
|
|
|
import java.lang.reflect.Method;
|
import java.util.*;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.locks.ReentrantLock;
|
|
import org.opends.messages.Message;
|
import org.opends.messages.MessageBuilder;
|
import org.opends.server.admin.ClassPropertyDefinition;
|
import org.opends.server.admin.server.ConfigurationAddListener;
|
import org.opends.server.admin.server.ConfigurationChangeListener;
|
import org.opends.server.admin.server.ConfigurationDeleteListener;
|
import org.opends.server.admin.server.ServerManagementContext;
|
import org.opends.server.admin.std.meta.PluginCfgDefn;
|
import org.opends.server.admin.std.server.PluginCfg;
|
import org.opends.server.admin.std.server.PluginRootCfg;
|
import org.opends.server.admin.std.server.RootCfg;
|
import org.opends.server.api.ClientConnection;
|
import org.opends.server.api.plugin.*;
|
import org.opends.server.config.ConfigException;
|
import org.opends.server.loggers.debug.DebugTracer;
|
import org.opends.server.types.*;
|
import org.opends.server.types.operation.*;
|
import org.opends.server.workflowelement.localbackend.*;
|
|
import static org.opends.messages.ConfigMessages.*;
|
import static org.opends.messages.PluginMessages.*;
|
import static org.opends.server.loggers.ErrorLogger.*;
|
import static org.opends.server.loggers.debug.DebugLogger.*;
|
import static org.opends.server.util.StaticUtils.*;
|
|
|
|
/**
|
* This class defines a utility that will be used to manage the configuration
|
* for the set of plugins defined in the Directory Server. It will perform the
|
* necessary initialization of those plugins when the server is first started,
|
* and then will manage any changes to them while the server is running. It
|
* also provides methods for invoking all the plugins of a given type.
|
*/
|
public class PluginConfigManager
|
implements ConfigurationAddListener<PluginCfg>,
|
ConfigurationDeleteListener<PluginCfg>,
|
ConfigurationChangeListener<PluginCfg>
|
{
|
/**
|
* The tracer object for the debug logger.
|
*/
|
private static final DebugTracer TRACER = getTracer();
|
|
// Arrays for holding the plugins of each type.
|
private DirectoryServerPlugin[] startupPlugins;
|
private DirectoryServerPlugin[] shutdownPlugins;
|
private DirectoryServerPlugin[] postConnectPlugins;
|
private DirectoryServerPlugin[] postDisconnectPlugins;
|
private DirectoryServerPlugin[] ldifImportPlugins;
|
private DirectoryServerPlugin[] ldifImportEndPlugins;
|
private DirectoryServerPlugin[] ldifImportBeginPlugins;
|
private DirectoryServerPlugin[] ldifExportPlugins;
|
private DirectoryServerPlugin[] preParseAbandonPlugins;
|
private DirectoryServerPlugin[] preParseAddPlugins;
|
private DirectoryServerPlugin[] preParseBindPlugins;
|
private DirectoryServerPlugin[] preParseComparePlugins;
|
private DirectoryServerPlugin[] preParseDeletePlugins;
|
private DirectoryServerPlugin[] preParseExtendedPlugins;
|
private DirectoryServerPlugin[] preParseModifyPlugins;
|
private DirectoryServerPlugin[] preParseModifyDNPlugins;
|
private DirectoryServerPlugin[] preParseSearchPlugins;
|
private DirectoryServerPlugin[] preParseUnbindPlugins;
|
private DirectoryServerPlugin[] preOperationAddPlugins;
|
private DirectoryServerPlugin[] preOperationBindPlugins;
|
private DirectoryServerPlugin[] preOperationComparePlugins;
|
private DirectoryServerPlugin[] preOperationDeletePlugins;
|
private DirectoryServerPlugin[] preOperationExtendedPlugins;
|
private DirectoryServerPlugin[] preOperationModifyPlugins;
|
private DirectoryServerPlugin[] preOperationModifyDNPlugins;
|
private DirectoryServerPlugin[] preOperationSearchPlugins;
|
private DirectoryServerPlugin[] postOperationAbandonPlugins;
|
private DirectoryServerPlugin[] postOperationAddPlugins;
|
private DirectoryServerPlugin[] postOperationBindPlugins;
|
private DirectoryServerPlugin[] postOperationComparePlugins;
|
private DirectoryServerPlugin[] postOperationDeletePlugins;
|
private DirectoryServerPlugin[] postOperationExtendedPlugins;
|
private DirectoryServerPlugin[] postOperationModifyPlugins;
|
private DirectoryServerPlugin[] postOperationModifyDNPlugins;
|
private DirectoryServerPlugin[] postOperationSearchPlugins;
|
private DirectoryServerPlugin[] postOperationUnbindPlugins;
|
private DirectoryServerPlugin[] postResponseAddPlugins;
|
private DirectoryServerPlugin[] postResponseBindPlugins;
|
private DirectoryServerPlugin[] postResponseComparePlugins;
|
private DirectoryServerPlugin[] postResponseDeletePlugins;
|
private DirectoryServerPlugin[] postResponseExtendedPlugins;
|
private DirectoryServerPlugin[] postResponseModifyPlugins;
|
private DirectoryServerPlugin[] postResponseModifyDNPlugins;
|
private DirectoryServerPlugin[] postResponseSearchPlugins;
|
private DirectoryServerPlugin[] postSynchronizationAddPlugins;
|
private DirectoryServerPlugin[] postSynchronizationDeletePlugins;
|
private DirectoryServerPlugin[] postSynchronizationModifyPlugins;
|
private DirectoryServerPlugin[] postSynchronizationModifyDNPlugins;
|
private DirectoryServerPlugin[] searchResultEntryPlugins;
|
private DirectoryServerPlugin[] searchResultReferencePlugins;
|
private DirectoryServerPlugin[] subordinateModifyDNPlugins;
|
private DirectoryServerPlugin[] subordinateDeletePlugins;
|
private DirectoryServerPlugin[] intermediateResponsePlugins;
|
|
|
// The mapping between the DN of a plugin entry and the plugin instance loaded
|
// from that entry.
|
private ConcurrentHashMap<DN,
|
DirectoryServerPlugin<? extends PluginCfg>>
|
registeredPlugins;
|
|
// The mapping between an operation and a set of post operation plugins
|
// it should skip. This pairs up pre and post operation plugin processing
|
// such that only plugins that successfully execute its pre op plugin will
|
// have its post op plugin executed on a per operation basis. If an
|
// operation is not registered on this list then all all pre op plugins
|
// executed successfully for this operation so all post op plugins should
|
// execute.
|
private ConcurrentHashMap<PluginOperation, ArrayList<DirectoryServerPlugin>>
|
skippedPreOperationPlugins;
|
|
// The plugin root configuration read at server startup.
|
private PluginRootCfg pluginRootConfig;
|
|
// The lock that will provide threadsafe access to the sets of registered
|
// plugins.
|
private ReentrantLock pluginLock;
|
|
|
|
/**
|
* Creates a new instance of this plugin config manager.
|
*/
|
public PluginConfigManager()
|
{
|
pluginLock = new ReentrantLock();
|
|
startupPlugins = new DirectoryServerPlugin[0];
|
shutdownPlugins = new DirectoryServerPlugin[0];
|
postConnectPlugins = new DirectoryServerPlugin[0];
|
postDisconnectPlugins = new DirectoryServerPlugin[0];
|
ldifImportPlugins = new DirectoryServerPlugin[0];
|
ldifImportEndPlugins = new DirectoryServerPlugin[0];
|
ldifImportBeginPlugins = new DirectoryServerPlugin[0];
|
ldifExportPlugins = new DirectoryServerPlugin[0];
|
preParseAbandonPlugins = new DirectoryServerPlugin[0];
|
preParseAddPlugins = new DirectoryServerPlugin[0];
|
preParseBindPlugins = new DirectoryServerPlugin[0];
|
preParseComparePlugins = new DirectoryServerPlugin[0];
|
preParseDeletePlugins = new DirectoryServerPlugin[0];
|
preParseExtendedPlugins = new DirectoryServerPlugin[0];
|
preParseModifyPlugins = new DirectoryServerPlugin[0];
|
preParseModifyDNPlugins = new DirectoryServerPlugin[0];
|
preParseSearchPlugins = new DirectoryServerPlugin[0];
|
preParseUnbindPlugins = new DirectoryServerPlugin[0];
|
preOperationAddPlugins = new DirectoryServerPlugin[0];
|
preOperationBindPlugins = new DirectoryServerPlugin[0];
|
preOperationComparePlugins = new DirectoryServerPlugin[0];
|
preOperationDeletePlugins = new DirectoryServerPlugin[0];
|
preOperationExtendedPlugins = new DirectoryServerPlugin[0];
|
preOperationModifyPlugins = new DirectoryServerPlugin[0];
|
preOperationModifyDNPlugins = new DirectoryServerPlugin[0];
|
preOperationSearchPlugins = new DirectoryServerPlugin[0];
|
postOperationAbandonPlugins = new DirectoryServerPlugin[0];
|
postOperationAddPlugins = new DirectoryServerPlugin[0];
|
postOperationBindPlugins = new DirectoryServerPlugin[0];
|
postOperationComparePlugins = new DirectoryServerPlugin[0];
|
postOperationDeletePlugins = new DirectoryServerPlugin[0];
|
postOperationExtendedPlugins = new DirectoryServerPlugin[0];
|
postOperationModifyPlugins = new DirectoryServerPlugin[0];
|
postOperationModifyDNPlugins = new DirectoryServerPlugin[0];
|
postOperationSearchPlugins = new DirectoryServerPlugin[0];
|
postOperationUnbindPlugins = new DirectoryServerPlugin[0];
|
postResponseAddPlugins = new DirectoryServerPlugin[0];
|
postResponseBindPlugins = new DirectoryServerPlugin[0];
|
postResponseComparePlugins = new DirectoryServerPlugin[0];
|
postResponseDeletePlugins = new DirectoryServerPlugin[0];
|
postResponseExtendedPlugins = new DirectoryServerPlugin[0];
|
postResponseModifyPlugins = new DirectoryServerPlugin[0];
|
postResponseModifyDNPlugins = new DirectoryServerPlugin[0];
|
postResponseSearchPlugins = new DirectoryServerPlugin[0];
|
postSynchronizationAddPlugins = new DirectoryServerPlugin[0];
|
postSynchronizationDeletePlugins = new DirectoryServerPlugin[0];
|
postSynchronizationModifyPlugins = new DirectoryServerPlugin[0];
|
postSynchronizationModifyDNPlugins = new DirectoryServerPlugin[0];
|
searchResultEntryPlugins = new DirectoryServerPlugin[0];
|
searchResultReferencePlugins = new DirectoryServerPlugin[0];
|
subordinateModifyDNPlugins = new DirectoryServerPlugin[0];
|
subordinateDeletePlugins = new DirectoryServerPlugin[0];
|
intermediateResponsePlugins = new DirectoryServerPlugin[0];
|
registeredPlugins =
|
new ConcurrentHashMap<DN,
|
DirectoryServerPlugin<? extends PluginCfg>>();
|
skippedPreOperationPlugins =
|
new ConcurrentHashMap<PluginOperation,
|
ArrayList<DirectoryServerPlugin>>();
|
}
|
|
|
|
/**
|
* Initializes this plugin configuration manager. This should only
|
* be called at Directory Server startup and before user plugins are
|
* loaded.
|
*
|
* @throws ConfigException
|
* If a critical configuration problem prevents the plugin
|
* initialization from succeeding.
|
*/
|
public void initializePluginConfigManager() throws ConfigException
|
{
|
registeredPlugins.clear();
|
|
// Get the root configuration object.
|
ServerManagementContext managementContext =
|
ServerManagementContext.getInstance();
|
RootCfg rootConfiguration =
|
managementContext.getRootConfiguration();
|
|
// Get the plugin root configuration and register with it as an add and
|
// delete listener so we can be notified if any plugin entries are added or
|
// removed.
|
pluginRootConfig = rootConfiguration.getPluginRoot();
|
pluginRootConfig.addPluginAddListener(this);
|
pluginRootConfig.addPluginDeleteListener(this);
|
}
|
|
|
|
/**
|
* Initializes any plugins defined in the directory server
|
* configuration. This should only be called at Directory Server
|
* startup and after this plugin configuration manager has been
|
* initialized.
|
*
|
* @param pluginTypes
|
* The set of plugin types for the plugins to initialize, or
|
* <CODE>null</CODE> to initialize all types of plugins
|
* defined in the server configuration. In general, this
|
* should only be non-null for cases in which the server is
|
* running in a special mode that only uses a minimal set of
|
* plugins (e.g., LDIF import or export).
|
* @throws ConfigException
|
* If a critical configuration problem prevents the plugin
|
* initialization from succeeding.
|
* @throws InitializationException
|
* If a problem occurs while initializing the plugins that
|
* is not related to the server configuration.
|
*/
|
public void initializeUserPlugins(Set<PluginType> pluginTypes)
|
throws ConfigException, InitializationException
|
{
|
//Initialize the user plugins.
|
for (String pluginName : pluginRootConfig.listPlugins())
|
{
|
PluginCfg pluginConfiguration = pluginRootConfig.getPlugin(pluginName);
|
pluginConfiguration.addChangeListener(this);
|
|
if (! pluginConfiguration.isEnabled())
|
{
|
continue;
|
}
|
|
// Create a set of plugin types for the plugin.
|
HashSet<PluginType> initTypes = new HashSet<PluginType>();
|
for (PluginCfgDefn.PluginType pluginType :
|
pluginConfiguration.getPluginType())
|
{
|
PluginType t = getPluginType(pluginType);
|
if ((pluginTypes == null) || pluginTypes.contains(t))
|
{
|
initTypes.add(t);
|
}
|
}
|
|
if (initTypes.isEmpty())
|
{
|
continue;
|
}
|
|
try
|
{
|
DirectoryServerPlugin<? extends PluginCfg> plugin =
|
loadPlugin(pluginConfiguration.getJavaClass(), initTypes,
|
pluginConfiguration, true);
|
registerPlugin(plugin, pluginConfiguration.dn(), initTypes);
|
}
|
catch (InitializationException ie)
|
{
|
logError(ie.getMessageObject());
|
continue;
|
}
|
}
|
}
|
|
|
|
/**
|
* Loads the specified class, instantiates it as a plugin, and optionally
|
* initializes that plugin.
|
*
|
* @param className The fully-qualified name of the plugin class to
|
* load, instantiate, and initialize.
|
* @param pluginTypes The set of plugin types for the plugins to
|
* initialize, or {@code null} to initialize all types
|
* of plugins defined in the server configuration. In
|
* general, this should only be non-null for cases in
|
* which the server is running in a special mode that
|
* only uses a minimal set of plugins (e.g., LDIF
|
* import or export).
|
* @param configuration The configuration to use to initialize the plugin.
|
* It must not be {@code null}.
|
* @param initialize Indicates whether the plugin instance should be
|
* initialized.
|
*
|
* @return The possibly initialized plugin.
|
*
|
* @throws InitializationException If a problem occurred while attempting to
|
* initialize the plugin.
|
*/
|
private DirectoryServerPlugin<? extends PluginCfg>
|
loadPlugin(String className, Set<PluginType> pluginTypes,
|
PluginCfg configuration, boolean initialize)
|
throws InitializationException
|
{
|
try
|
{
|
PluginCfgDefn definition =
|
PluginCfgDefn.getInstance();
|
ClassPropertyDefinition propertyDefinition =
|
definition.getJavaClassPropertyDefinition();
|
Class<? extends DirectoryServerPlugin> pluginClass =
|
propertyDefinition.loadClass(className, DirectoryServerPlugin.class);
|
DirectoryServerPlugin<? extends PluginCfg> plugin =
|
pluginClass.newInstance();
|
|
if (initialize)
|
{
|
plugin.initializeInternal(configuration.dn(), pluginTypes,
|
configuration.isInvokeForInternalOperations());
|
|
Method method =
|
plugin.getClass().getMethod("initializePlugin", Set.class,
|
configuration.configurationClass());
|
method.invoke(plugin, pluginTypes, configuration);
|
}
|
else
|
{
|
Method method = plugin.getClass().getMethod("isConfigurationAcceptable",
|
PluginCfg.class,
|
List.class);
|
|
List<Message> unacceptableReasons = new ArrayList<Message>();
|
Boolean acceptable = (Boolean) method.invoke(plugin, configuration,
|
unacceptableReasons);
|
if (! acceptable)
|
{
|
MessageBuilder buffer = new MessageBuilder();
|
if (! unacceptableReasons.isEmpty())
|
{
|
Iterator<Message> iterator = unacceptableReasons.iterator();
|
buffer.append(iterator.next());
|
while (iterator.hasNext())
|
{
|
buffer.append(". ");
|
buffer.append(iterator.next());
|
}
|
}
|
|
Message message = ERR_CONFIG_PLUGIN_CONFIG_NOT_ACCEPTABLE.get(
|
String.valueOf(configuration.dn()), buffer.toString());
|
throw new InitializationException(message);
|
}
|
}
|
|
return plugin;
|
}
|
catch (Exception e)
|
{
|
Message message = ERR_CONFIG_PLUGIN_CANNOT_INITIALIZE.
|
get(className, String.valueOf(configuration.dn()),
|
stackTraceToSingleLineString(e));
|
throw new InitializationException(message, e);
|
}
|
}
|
|
|
|
/**
|
* Gets the OpenDS plugin type object that corresponds to the configuration
|
* counterpart.
|
*
|
* @param configPluginType The configuration plugin type for which to
|
* retrieve the OpenDS plugin type.
|
*/
|
private PluginType getPluginType(PluginCfgDefn.PluginType
|
configPluginType)
|
{
|
switch (configPluginType)
|
{
|
case STARTUP: return PluginType.STARTUP;
|
case SHUTDOWN: return PluginType.SHUTDOWN;
|
case POSTCONNECT: return PluginType.POST_CONNECT;
|
case POSTDISCONNECT: return PluginType.POST_DISCONNECT;
|
case LDIFIMPORT: return PluginType.LDIF_IMPORT;
|
case LDIFIMPORTEND: return PluginType.LDIF_IMPORT_END;
|
case LDIFIMPORTBEGIN: return PluginType.LDIF_IMPORT_BEGIN;
|
case LDIFEXPORT: return PluginType.LDIF_EXPORT;
|
case PREPARSEABANDON: return PluginType.PRE_PARSE_ABANDON;
|
case PREPARSEADD: return PluginType.PRE_PARSE_ADD;
|
case PREPARSEBIND: return PluginType.PRE_PARSE_BIND;
|
case PREPARSECOMPARE: return PluginType.PRE_PARSE_COMPARE;
|
case PREPARSEDELETE: return PluginType.PRE_PARSE_DELETE;
|
case PREPARSEEXTENDED: return PluginType.PRE_PARSE_EXTENDED;
|
case PREPARSEMODIFY: return PluginType.PRE_PARSE_MODIFY;
|
case PREPARSEMODIFYDN: return PluginType.PRE_PARSE_MODIFY_DN;
|
case PREPARSESEARCH: return PluginType.PRE_PARSE_SEARCH;
|
case PREPARSEUNBIND: return PluginType.PRE_PARSE_UNBIND;
|
case PREOPERATIONADD: return PluginType.PRE_OPERATION_ADD;
|
case PREOPERATIONBIND: return PluginType.PRE_OPERATION_BIND;
|
case PREOPERATIONCOMPARE: return PluginType.PRE_OPERATION_COMPARE;
|
case PREOPERATIONDELETE: return PluginType.PRE_OPERATION_DELETE;
|
case PREOPERATIONEXTENDED: return PluginType.PRE_OPERATION_EXTENDED;
|
case PREOPERATIONMODIFY: return PluginType.PRE_OPERATION_MODIFY;
|
case PREOPERATIONMODIFYDN: return PluginType.PRE_OPERATION_MODIFY_DN;
|
case PREOPERATIONSEARCH: return PluginType.PRE_OPERATION_SEARCH;
|
case POSTOPERATIONABANDON: return PluginType.POST_OPERATION_ABANDON;
|
case POSTOPERATIONADD: return PluginType.POST_OPERATION_ADD;
|
case POSTOPERATIONBIND: return PluginType.POST_OPERATION_BIND;
|
case POSTOPERATIONCOMPARE: return PluginType.POST_OPERATION_COMPARE;
|
case POSTOPERATIONDELETE: return PluginType.POST_OPERATION_DELETE;
|
case POSTOPERATIONEXTENDED: return PluginType.POST_OPERATION_EXTENDED;
|
case POSTOPERATIONMODIFY: return PluginType.POST_OPERATION_MODIFY;
|
case POSTOPERATIONMODIFYDN: return PluginType.POST_OPERATION_MODIFY_DN;
|
case POSTOPERATIONSEARCH: return PluginType.POST_OPERATION_SEARCH;
|
case POSTOPERATIONUNBIND: return PluginType.POST_OPERATION_UNBIND;
|
case POSTRESPONSEADD: return PluginType.POST_RESPONSE_ADD;
|
case POSTRESPONSEBIND: return PluginType.POST_RESPONSE_BIND;
|
case POSTRESPONSECOMPARE: return PluginType.POST_RESPONSE_COMPARE;
|
case POSTRESPONSEDELETE: return PluginType.POST_RESPONSE_DELETE;
|
case POSTRESPONSEEXTENDED: return PluginType.POST_RESPONSE_EXTENDED;
|
case POSTRESPONSEMODIFY: return PluginType.POST_RESPONSE_MODIFY;
|
case POSTRESPONSEMODIFYDN: return PluginType.POST_RESPONSE_MODIFY_DN;
|
case POSTRESPONSESEARCH: return PluginType.POST_RESPONSE_SEARCH;
|
case SEARCHRESULTENTRY: return PluginType.SEARCH_RESULT_ENTRY;
|
case SEARCHRESULTREFERENCE: return PluginType.SEARCH_RESULT_REFERENCE;
|
case SUBORDINATEMODIFYDN: return PluginType.SUBORDINATE_MODIFY_DN;
|
case SUBORDINATEDELETE: return PluginType.SUBORDINATE_DELETE;
|
case INTERMEDIATERESPONSE: return PluginType.INTERMEDIATE_RESPONSE;
|
case POSTSYNCHRONIZATIONADD:
|
return PluginType.POST_SYNCHRONIZATION_ADD;
|
case POSTSYNCHRONIZATIONDELETE:
|
return PluginType.POST_SYNCHRONIZATION_DELETE;
|
case POSTSYNCHRONIZATIONMODIFY:
|
return PluginType.POST_SYNCHRONIZATION_MODIFY;
|
case POSTSYNCHRONIZATIONMODIFYDN:
|
return PluginType.POST_SYNCHRONIZATION_MODIFY_DN;
|
default: return null;
|
}
|
}
|
|
|
|
/**
|
* Finalizes all plugins that are registered with the Directory Server.
|
*/
|
public void finalizePlugins()
|
{
|
pluginLock.lock();
|
|
try
|
{
|
Iterator<DirectoryServerPlugin<? extends PluginCfg>> iterator =
|
registeredPlugins.values().iterator();
|
while (iterator.hasNext())
|
{
|
try
|
{
|
iterator.next().finalizePlugin();
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
}
|
}
|
|
registeredPlugins.clear();
|
}
|
finally
|
{
|
pluginLock.unlock();
|
}
|
}
|
|
|
|
/**
|
* Retrieves the set of plugins that have been registered with the Directory
|
* Server.
|
*
|
* @return The set of plugins that have been registered with the Directory
|
* Server.
|
*/
|
public ConcurrentHashMap<DN,
|
DirectoryServerPlugin<? extends PluginCfg>>
|
getRegisteredPlugins()
|
{
|
return registeredPlugins;
|
}
|
|
|
|
/**
|
* Retrieves the plugin with the specified configuration entry DN.
|
*
|
* @param pluginDN The DN of the configuration entry for the plugin to
|
* retrieve.
|
*
|
* @return The requested plugin, or <CODE>null</CODE> if there is no such
|
* plugin.
|
*/
|
public DirectoryServerPlugin getRegisteredPlugin(DN pluginDN)
|
{
|
return registeredPlugins.get(pluginDN);
|
}
|
|
|
|
/**
|
* Registers the provided internal plugin with this plugin config
|
* manager and ensures that it will be invoked in the specified ways.
|
*
|
* @param plugin
|
* The internal plugin to register with the server. The
|
* plugin must specify a configuration entry which is
|
* guaranteed to be unique.
|
*/
|
void registerInternalPlugin(InternalDirectoryServerPlugin plugin)
|
{
|
pluginLock.lock();
|
try
|
{
|
registerPlugin0(plugin, plugin.getPluginTypes());
|
}
|
finally
|
{
|
pluginLock.unlock();
|
}
|
}
|
|
|
|
/**
|
* Register a plugin in the appropriate tables.
|
*
|
* @param plugin
|
* The plugin to register with the server.
|
* @param pluginTypes
|
* The plugin types that will be used to control the points
|
* at which the provided plugin is invoked.
|
*/
|
private void registerPlugin0(
|
DirectoryServerPlugin<? extends PluginCfg> plugin,
|
Set<PluginType> pluginTypes)
|
{
|
for (PluginType t : pluginTypes)
|
{
|
switch (t)
|
{
|
case STARTUP:
|
startupPlugins =
|
addPlugin(startupPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderStartup());
|
break;
|
case SHUTDOWN:
|
shutdownPlugins =
|
addPlugin(shutdownPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderShutdown());
|
break;
|
case POST_CONNECT:
|
postConnectPlugins =
|
addPlugin(postConnectPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderPostConnect());
|
break;
|
case POST_DISCONNECT:
|
postDisconnectPlugins =
|
addPlugin(postDisconnectPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostDisconnect());
|
break;
|
case LDIF_IMPORT:
|
ldifImportPlugins =
|
addPlugin(ldifImportPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderLDIFImport());
|
break;
|
case LDIF_IMPORT_END:
|
ldifImportEndPlugins =
|
addPlugin(ldifImportEndPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderLDIFImportEnd());
|
break;
|
case LDIF_IMPORT_BEGIN:
|
ldifImportBeginPlugins =
|
addPlugin(ldifImportBeginPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderLDIFImportBegin());
|
break;
|
case LDIF_EXPORT:
|
ldifExportPlugins =
|
addPlugin(ldifExportPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderLDIFExport());
|
break;
|
case PRE_PARSE_ABANDON:
|
preParseAbandonPlugins =
|
addPlugin(preParseAbandonPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseAbandon());
|
break;
|
case PRE_PARSE_ADD:
|
preParseAddPlugins =
|
addPlugin(preParseAddPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderPreParseAdd());
|
break;
|
case PRE_PARSE_BIND:
|
preParseBindPlugins =
|
addPlugin(preParseBindPlugins, plugin, t, pluginRootConfig
|
.getPluginOrderPreParseBind());
|
break;
|
case PRE_PARSE_COMPARE:
|
preParseComparePlugins =
|
addPlugin(preParseComparePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseCompare());
|
break;
|
case PRE_PARSE_DELETE:
|
preParseDeletePlugins =
|
addPlugin(preParseDeletePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseDelete());
|
break;
|
case PRE_PARSE_EXTENDED:
|
preParseExtendedPlugins =
|
addPlugin(preParseExtendedPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseExtended());
|
break;
|
case PRE_PARSE_MODIFY:
|
preParseModifyPlugins =
|
addPlugin(preParseModifyPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseModify());
|
break;
|
case PRE_PARSE_MODIFY_DN:
|
preParseModifyDNPlugins =
|
addPlugin(preParseModifyDNPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseModifyDN());
|
break;
|
case PRE_PARSE_SEARCH:
|
preParseSearchPlugins =
|
addPlugin(preParseSearchPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseSearch());
|
break;
|
case PRE_PARSE_UNBIND:
|
preParseUnbindPlugins =
|
addPlugin(preParseUnbindPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreParseUnbind());
|
break;
|
case PRE_OPERATION_ADD:
|
preOperationAddPlugins =
|
addPlugin(preOperationAddPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationAdd());
|
break;
|
case PRE_OPERATION_BIND:
|
preOperationBindPlugins =
|
addPlugin(preOperationBindPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationBind());
|
break;
|
case PRE_OPERATION_COMPARE:
|
preOperationComparePlugins =
|
addPlugin(preOperationComparePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationCompare());
|
break;
|
case PRE_OPERATION_DELETE:
|
preOperationDeletePlugins =
|
addPlugin(preOperationDeletePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationDelete());
|
break;
|
case PRE_OPERATION_EXTENDED:
|
preOperationExtendedPlugins =
|
addPlugin(preOperationExtendedPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationExtended());
|
break;
|
case PRE_OPERATION_MODIFY:
|
preOperationModifyPlugins =
|
addPlugin(preOperationModifyPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationModify());
|
break;
|
case PRE_OPERATION_MODIFY_DN:
|
preOperationModifyDNPlugins =
|
addPlugin(preOperationModifyDNPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationModifyDN());
|
break;
|
case PRE_OPERATION_SEARCH:
|
preOperationSearchPlugins =
|
addPlugin(preOperationSearchPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPreOperationSearch());
|
break;
|
case POST_OPERATION_ABANDON:
|
postOperationAbandonPlugins =
|
addPlugin(postOperationAbandonPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationAbandon());
|
break;
|
case POST_OPERATION_ADD:
|
postOperationAddPlugins =
|
addPlugin(postOperationAddPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationAdd());
|
break;
|
case POST_OPERATION_BIND:
|
postOperationBindPlugins =
|
addPlugin(postOperationBindPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationBind());
|
break;
|
case POST_OPERATION_COMPARE:
|
postOperationComparePlugins =
|
addPlugin(postOperationComparePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationCompare());
|
break;
|
case POST_OPERATION_DELETE:
|
postOperationDeletePlugins =
|
addPlugin(postOperationDeletePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationDelete());
|
break;
|
case POST_OPERATION_EXTENDED:
|
postOperationExtendedPlugins =
|
addPlugin(postOperationExtendedPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationExtended());
|
break;
|
case POST_OPERATION_MODIFY:
|
postOperationModifyPlugins =
|
addPlugin(postOperationModifyPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationModify());
|
break;
|
case POST_OPERATION_MODIFY_DN:
|
postOperationModifyDNPlugins =
|
addPlugin(postOperationModifyDNPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationModifyDN());
|
break;
|
case POST_OPERATION_SEARCH:
|
postOperationSearchPlugins =
|
addPlugin(postOperationSearchPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationSearch());
|
break;
|
case POST_OPERATION_UNBIND:
|
postOperationUnbindPlugins =
|
addPlugin(postOperationUnbindPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostOperationUnbind());
|
break;
|
case POST_RESPONSE_ADD:
|
postResponseAddPlugins =
|
addPlugin(postResponseAddPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseAdd());
|
break;
|
case POST_RESPONSE_BIND:
|
postResponseBindPlugins =
|
addPlugin(postResponseBindPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseBind());
|
break;
|
case POST_RESPONSE_COMPARE:
|
postResponseComparePlugins =
|
addPlugin(postResponseComparePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseCompare());
|
break;
|
case POST_RESPONSE_DELETE:
|
postResponseDeletePlugins =
|
addPlugin(postResponseDeletePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseDelete());
|
break;
|
case POST_RESPONSE_EXTENDED:
|
postResponseExtendedPlugins =
|
addPlugin(postResponseExtendedPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseExtended());
|
break;
|
case POST_RESPONSE_MODIFY:
|
postResponseModifyPlugins =
|
addPlugin(postResponseModifyPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseModify());
|
break;
|
case POST_RESPONSE_MODIFY_DN:
|
postResponseModifyDNPlugins =
|
addPlugin(postResponseModifyDNPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseModifyDN());
|
break;
|
case POST_RESPONSE_SEARCH:
|
postResponseSearchPlugins =
|
addPlugin(postResponseSearchPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostResponseSearch());
|
break;
|
case POST_SYNCHRONIZATION_ADD:
|
postSynchronizationAddPlugins =
|
addPlugin(postSynchronizationAddPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderPostSynchronizationAdd());
|
break;
|
case POST_SYNCHRONIZATION_DELETE:
|
postSynchronizationDeletePlugins =
|
addPlugin(postSynchronizationDeletePlugins, plugin, t,
|
pluginRootConfig
|
.getPluginOrderPostSynchronizationDelete());
|
break;
|
case POST_SYNCHRONIZATION_MODIFY:
|
postSynchronizationModifyPlugins =
|
addPlugin(postSynchronizationModifyPlugins, plugin, t,
|
pluginRootConfig
|
.getPluginOrderPostSynchronizationModify());
|
break;
|
case POST_SYNCHRONIZATION_MODIFY_DN:
|
postSynchronizationModifyDNPlugins =
|
addPlugin(postSynchronizationModifyDNPlugins, plugin, t,
|
pluginRootConfig
|
.getPluginOrderPostSynchronizationModifyDN());
|
break;
|
case SEARCH_RESULT_ENTRY:
|
searchResultEntryPlugins =
|
addPlugin(searchResultEntryPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderSearchResultEntry());
|
break;
|
case SEARCH_RESULT_REFERENCE:
|
searchResultReferencePlugins =
|
addPlugin(searchResultReferencePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderSearchResultReference());
|
break;
|
case SUBORDINATE_MODIFY_DN:
|
subordinateModifyDNPlugins =
|
addPlugin(subordinateModifyDNPlugins, plugin, t,
|
pluginRootConfig.getPluginOrderSubordinateModifyDN());
|
break;
|
case SUBORDINATE_DELETE:
|
subordinateDeletePlugins =
|
addPlugin(subordinateDeletePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderSubordinateDelete());
|
break;
|
case INTERMEDIATE_RESPONSE:
|
intermediateResponsePlugins =
|
addPlugin(intermediateResponsePlugins, plugin, t,
|
pluginRootConfig.getPluginOrderIntermediateResponse());
|
break;
|
default:
|
}
|
}
|
}
|
|
|
|
/**
|
* Registers the provided plugin with this plugin config manager and
|
* ensures that it will be invoked in the specified ways.
|
*
|
* @param plugin
|
* The plugin to register with the server.
|
* @param pluginEntryDN
|
* The DN of the configuration entry for the provided plugin.
|
* @param pluginTypes
|
* The plugin types that will be used to control the points
|
* at which the provided plugin is invoked.
|
*/
|
private void registerPlugin(
|
DirectoryServerPlugin<? extends PluginCfg> plugin,
|
DN pluginEntryDN, Set<PluginType> pluginTypes)
|
{
|
pluginLock.lock();
|
try
|
{
|
registeredPlugins.put(pluginEntryDN, plugin);
|
registerPlugin0(plugin, pluginTypes);
|
}
|
finally
|
{
|
pluginLock.unlock();
|
}
|
}
|
|
|
|
/**
|
* Adds the provided plugin to the given array. The provided array will not
|
* itself be modified, but rather a new array will be created with one
|
* additional element. The provided plugin will be the last element in the
|
* new array.
|
* <BR><BR>
|
* Note that the only use of this method outside of this class should be for
|
* testing purposes.
|
*
|
* @param pluginArray The array containing the existing set of plugins.
|
* @param plugin The plugin to be added to the array.
|
* @param pluginType The plugin type for the plugin being registered.
|
* @param pluginOrder A string that represents the order in which plugins of
|
* this type should be invoked, or {@code null} if the
|
* order is not considered important.
|
*
|
* @return The new array containing the new set of plugins.
|
*/
|
static DirectoryServerPlugin[] addPlugin(DirectoryServerPlugin[] pluginArray,
|
DirectoryServerPlugin plugin,
|
PluginType pluginType,
|
String pluginOrder)
|
{
|
// If the provided plugin order string is null, empty, or contains only a
|
// wildcard, then simply add the new plugin to the end of the list.
|
// Otherwise, parse the order string and figure out where to put the
|
// provided plugin.
|
if ((pluginOrder == null) ||
|
((pluginOrder = pluginOrder.trim()).length() == 0) ||
|
pluginOrder.equals("*"))
|
{
|
DirectoryServerPlugin[] newPlugins =
|
new DirectoryServerPlugin[pluginArray.length+1];
|
System.arraycopy(pluginArray, 0, newPlugins, 0, pluginArray.length);
|
newPlugins[pluginArray.length] = plugin;
|
|
return newPlugins;
|
}
|
else
|
{
|
// Parse the plugin order into initial and final plugin names.
|
boolean starFound = false;
|
LinkedHashSet<String> initialPluginNames = new LinkedHashSet<String>();
|
LinkedHashSet<String> finalPluginNames = new LinkedHashSet<String>();
|
|
StringTokenizer tokenizer = new StringTokenizer(pluginOrder, ",");
|
while (tokenizer.hasMoreTokens())
|
{
|
String token = tokenizer.nextToken().trim();
|
if (token.length() == 0)
|
{
|
// Only log the warning once per plugin type. The plugin array will
|
// be empty the first time through, so we can use that to make the
|
// determination.
|
if (pluginArray.length == 0)
|
{
|
Message message = WARN_CONFIG_PLUGIN_EMPTY_ELEMENT_IN_ORDER.get(
|
pluginType.getName());
|
logError(message);
|
}
|
}
|
else if (token.equals("*"))
|
{
|
if (starFound)
|
{
|
// Only log the warning once per plugin type. The plugin array will
|
// be empty the first time through, so we can use that to make the
|
// determination.
|
if (pluginArray.length == 0)
|
{
|
Message message = WARN_CONFIG_PLUGIN_MULTIPLE_WILDCARDS_IN_ORDER.
|
get(pluginType.getName());
|
logError(message);
|
}
|
}
|
else
|
{
|
starFound = true;
|
}
|
}
|
else
|
{
|
String lowerName = toLowerCase(token);
|
if (starFound)
|
{
|
if (initialPluginNames.contains(lowerName) ||
|
finalPluginNames.contains(lowerName))
|
{
|
// Only log the warning once per plugin type. The plugin array
|
// will be empty the first time through, so we can use that to
|
// make the determination.
|
if (pluginArray.length == 0)
|
{
|
Message message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get(
|
pluginType.getName(), token);
|
logError(message);
|
}
|
}
|
|
finalPluginNames.add(lowerName);
|
}
|
else
|
{
|
if (initialPluginNames.contains(lowerName))
|
{
|
// Only log the warning once per plugin type. The plugin array
|
// will be empty the first time through, so we can use that to
|
// make the determination.
|
if (pluginArray.length == 0)
|
{
|
Message message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get(
|
pluginType.getName(), token);
|
logError(message);
|
}
|
}
|
|
initialPluginNames.add(lowerName);
|
}
|
}
|
}
|
|
if (! starFound)
|
{
|
// Only log the warning once per plugin type. The plugin array will be
|
// empty the first time through, so we can use that to make the
|
// determination.
|
if (pluginArray.length == 0)
|
{
|
Message message =
|
WARN_CONFIG_PLUGIN_ORDER_NO_WILDCARD.get(pluginType.getName());
|
logError(message);
|
}
|
}
|
|
|
// Parse the array of already registered plugins to sort them accordingly.
|
HashMap<String,DirectoryServerPlugin> initialPlugins =
|
new HashMap<String,DirectoryServerPlugin>(initialPluginNames.size());
|
HashMap<String,DirectoryServerPlugin> finalPlugins =
|
new HashMap<String,DirectoryServerPlugin>(finalPluginNames.size());
|
ArrayList<DirectoryServerPlugin> otherPlugins =
|
new ArrayList<DirectoryServerPlugin>();
|
for (DirectoryServerPlugin p : pluginArray)
|
{
|
DN dn = p.getPluginEntryDN();
|
String lowerName =
|
toLowerCase(dn.getRDN().getAttributeValue(0).getValue().toString());
|
if (initialPluginNames.contains(lowerName))
|
{
|
initialPlugins.put(lowerName, p);
|
}
|
else if (finalPluginNames.contains(lowerName))
|
{
|
finalPlugins.put(lowerName, p);
|
}
|
else
|
{
|
otherPlugins.add(p);
|
}
|
}
|
|
|
// Get the name of the provided plugin from its RDN value and put it in
|
// the correct category.
|
DN dn = plugin.getPluginEntryDN();
|
String lowerName =
|
toLowerCase(dn.getRDN().getAttributeValue(0).getValue().toString());
|
if (initialPluginNames.contains(lowerName))
|
{
|
initialPlugins.put(lowerName, plugin);
|
}
|
else if (finalPluginNames.contains(lowerName))
|
{
|
finalPlugins.put(lowerName, plugin);
|
}
|
else
|
{
|
otherPlugins.add(plugin);
|
}
|
|
|
// Compile a list of all the plugins in the correct order, convert it to
|
// an array, and return it.
|
ArrayList<DirectoryServerPlugin> newList =
|
new ArrayList<DirectoryServerPlugin>(pluginArray.length+1);
|
for (String name : initialPluginNames)
|
{
|
DirectoryServerPlugin p = initialPlugins.get(name);
|
if (p != null)
|
{
|
newList.add(p);
|
}
|
}
|
|
newList.addAll(otherPlugins);
|
|
for (String name : finalPluginNames)
|
{
|
DirectoryServerPlugin p = finalPlugins.get(name);
|
if (p != null)
|
{
|
newList.add(p);
|
}
|
}
|
|
DirectoryServerPlugin[] newPlugins =
|
new DirectoryServerPlugin[newList.size()];
|
newList.toArray(newPlugins);
|
return newPlugins;
|
}
|
}
|
|
|
|
/**
|
* Deregisters the provided internal plugin.
|
*
|
* @param plugin
|
* The internal plugin to deregister from the server.
|
*/
|
void deregisterInternalPlugin(InternalDirectoryServerPlugin plugin)
|
{
|
pluginLock.lock();
|
try
|
{
|
deregisterPlugin0(plugin);
|
plugin.finalizePlugin();
|
}
|
finally
|
{
|
pluginLock.unlock();
|
}
|
}
|
|
|
|
/**
|
* Deregisters the plugin with the provided configuration entry DN.
|
*
|
* @param configEntryDN
|
* The DN of the configuration entry for the plugin to
|
* deregister.
|
*/
|
private void deregisterPlugin(DN configEntryDN)
|
{
|
pluginLock.lock();
|
DirectoryServerPlugin<? extends PluginCfg> plugin;
|
try
|
{
|
plugin = registeredPlugins.remove(configEntryDN);
|
if (plugin != null)
|
{
|
deregisterPlugin0(plugin);
|
plugin.finalizePlugin();
|
}
|
}
|
finally
|
{
|
pluginLock.unlock();
|
}
|
}
|
|
|
|
/**
|
* Deregisters the provided plugin.
|
*
|
* @param plugin
|
* The plugin to deregister from the server.
|
*/
|
private void deregisterPlugin0(
|
DirectoryServerPlugin<? extends PluginCfg> plugin)
|
{
|
for (PluginType t : plugin.getPluginTypes())
|
{
|
switch (t)
|
{
|
case STARTUP:
|
startupPlugins = removePlugin(startupPlugins, plugin);
|
break;
|
case SHUTDOWN:
|
shutdownPlugins = removePlugin(shutdownPlugins, plugin);
|
break;
|
case POST_CONNECT:
|
postConnectPlugins = removePlugin(postConnectPlugins, plugin);
|
break;
|
case POST_DISCONNECT:
|
postDisconnectPlugins = removePlugin(postDisconnectPlugins, plugin);
|
break;
|
case LDIF_IMPORT:
|
ldifImportPlugins = removePlugin(ldifImportPlugins, plugin);
|
break;
|
case LDIF_IMPORT_END:
|
ldifImportEndPlugins = removePlugin(ldifImportEndPlugins, plugin);
|
break;
|
case LDIF_IMPORT_BEGIN:
|
ldifImportBeginPlugins =
|
removePlugin(ldifImportBeginPlugins, plugin);
|
break;
|
case LDIF_EXPORT:
|
ldifExportPlugins = removePlugin(ldifExportPlugins, plugin);
|
break;
|
case PRE_PARSE_ABANDON:
|
preParseAbandonPlugins = removePlugin(preParseAbandonPlugins,
|
plugin);
|
break;
|
case PRE_PARSE_ADD:
|
preParseAddPlugins = removePlugin(preParseAddPlugins, plugin);
|
break;
|
case PRE_PARSE_BIND:
|
preParseBindPlugins = removePlugin(preParseBindPlugins, plugin);
|
break;
|
case PRE_PARSE_COMPARE:
|
preParseComparePlugins = removePlugin(preParseComparePlugins,
|
plugin);
|
break;
|
case PRE_PARSE_DELETE:
|
preParseDeletePlugins = removePlugin(preParseDeletePlugins, plugin);
|
break;
|
case PRE_PARSE_EXTENDED:
|
preParseExtendedPlugins = removePlugin(preParseExtendedPlugins,
|
plugin);
|
break;
|
case PRE_PARSE_MODIFY:
|
preParseModifyPlugins = removePlugin(preParseModifyPlugins, plugin);
|
break;
|
case PRE_PARSE_MODIFY_DN:
|
preParseModifyDNPlugins = removePlugin(preParseModifyDNPlugins,
|
plugin);
|
break;
|
case PRE_PARSE_SEARCH:
|
preParseSearchPlugins = removePlugin(preParseSearchPlugins, plugin);
|
break;
|
case PRE_PARSE_UNBIND:
|
preParseUnbindPlugins = removePlugin(preParseUnbindPlugins, plugin);
|
break;
|
case PRE_OPERATION_ADD:
|
preOperationAddPlugins = removePlugin(preOperationAddPlugins,
|
plugin);
|
break;
|
case PRE_OPERATION_BIND:
|
preOperationBindPlugins = removePlugin(preOperationBindPlugins,
|
plugin);
|
break;
|
case PRE_OPERATION_COMPARE:
|
preOperationComparePlugins =
|
removePlugin(preOperationComparePlugins, plugin);
|
break;
|
case PRE_OPERATION_DELETE:
|
preOperationDeletePlugins = removePlugin(preOperationDeletePlugins,
|
plugin);
|
break;
|
case PRE_OPERATION_EXTENDED:
|
preOperationExtendedPlugins =
|
removePlugin(preOperationExtendedPlugins, plugin);
|
break;
|
case PRE_OPERATION_MODIFY:
|
preOperationModifyPlugins = removePlugin(preOperationModifyPlugins,
|
plugin);
|
break;
|
case PRE_OPERATION_MODIFY_DN:
|
preOperationModifyDNPlugins =
|
removePlugin(preOperationModifyDNPlugins, plugin);
|
break;
|
case PRE_OPERATION_SEARCH:
|
preOperationSearchPlugins = removePlugin(preOperationSearchPlugins,
|
plugin);
|
break;
|
case POST_OPERATION_ABANDON:
|
postOperationAbandonPlugins =
|
removePlugin(postOperationAbandonPlugins, plugin);
|
break;
|
case POST_OPERATION_ADD:
|
postOperationAddPlugins = removePlugin(postOperationAddPlugins,
|
plugin);
|
break;
|
case POST_OPERATION_BIND:
|
postOperationBindPlugins = removePlugin(postOperationBindPlugins,
|
plugin);
|
break;
|
case POST_OPERATION_COMPARE:
|
postOperationComparePlugins =
|
removePlugin(postOperationComparePlugins, plugin);
|
break;
|
case POST_OPERATION_DELETE:
|
postOperationDeletePlugins =
|
removePlugin(postOperationDeletePlugins, plugin);
|
break;
|
case POST_OPERATION_EXTENDED:
|
postOperationExtendedPlugins =
|
removePlugin(postOperationExtendedPlugins, plugin);
|
break;
|
case POST_OPERATION_MODIFY:
|
postOperationModifyPlugins =
|
removePlugin(postOperationModifyPlugins, plugin);
|
break;
|
case POST_OPERATION_MODIFY_DN:
|
postOperationModifyDNPlugins =
|
removePlugin(postOperationModifyDNPlugins, plugin);
|
break;
|
case POST_OPERATION_SEARCH:
|
postOperationSearchPlugins =
|
removePlugin(postOperationSearchPlugins, plugin);
|
break;
|
case POST_OPERATION_UNBIND:
|
postOperationUnbindPlugins =
|
removePlugin(postOperationUnbindPlugins, plugin);
|
break;
|
case POST_RESPONSE_ADD:
|
postResponseAddPlugins = removePlugin(postResponseAddPlugins,
|
plugin);
|
break;
|
case POST_RESPONSE_BIND:
|
postResponseBindPlugins = removePlugin(postResponseBindPlugins,
|
plugin);
|
break;
|
case POST_RESPONSE_COMPARE:
|
postResponseComparePlugins =
|
removePlugin(postResponseComparePlugins, plugin);
|
break;
|
case POST_RESPONSE_DELETE:
|
postResponseDeletePlugins = removePlugin(postResponseDeletePlugins,
|
plugin);
|
break;
|
case POST_RESPONSE_EXTENDED:
|
postResponseExtendedPlugins =
|
removePlugin(postResponseExtendedPlugins, plugin);
|
break;
|
case POST_RESPONSE_MODIFY:
|
postResponseModifyPlugins = removePlugin(postResponseModifyPlugins,
|
plugin);
|
break;
|
case POST_RESPONSE_MODIFY_DN:
|
postResponseModifyDNPlugins =
|
removePlugin(postResponseModifyDNPlugins, plugin);
|
break;
|
case POST_RESPONSE_SEARCH:
|
postResponseSearchPlugins = removePlugin(postResponseSearchPlugins,
|
plugin);
|
break;
|
case POST_SYNCHRONIZATION_ADD:
|
postSynchronizationAddPlugins =
|
removePlugin(postSynchronizationAddPlugins, plugin);
|
break;
|
case POST_SYNCHRONIZATION_DELETE:
|
postSynchronizationDeletePlugins =
|
removePlugin(postSynchronizationDeletePlugins, plugin);
|
break;
|
case POST_SYNCHRONIZATION_MODIFY:
|
postSynchronizationModifyPlugins =
|
removePlugin(postSynchronizationModifyPlugins, plugin);
|
break;
|
case POST_SYNCHRONIZATION_MODIFY_DN:
|
postSynchronizationModifyDNPlugins =
|
removePlugin(postSynchronizationModifyDNPlugins, plugin);
|
break;
|
case SEARCH_RESULT_ENTRY:
|
searchResultEntryPlugins = removePlugin(searchResultEntryPlugins,
|
plugin);
|
break;
|
case SEARCH_RESULT_REFERENCE:
|
searchResultReferencePlugins =
|
removePlugin(searchResultReferencePlugins, plugin);
|
break;
|
case SUBORDINATE_MODIFY_DN:
|
subordinateModifyDNPlugins =
|
removePlugin(subordinateModifyDNPlugins, plugin);
|
break;
|
case SUBORDINATE_DELETE:
|
subordinateDeletePlugins =
|
removePlugin(subordinateDeletePlugins, plugin);
|
break;
|
case INTERMEDIATE_RESPONSE:
|
intermediateResponsePlugins =
|
removePlugin(intermediateResponsePlugins, plugin);
|
break;
|
default:
|
}
|
}
|
}
|
|
|
|
/**
|
* Removes the provided plugin from the given array. The provided array will
|
* not itself be modified, but rather a new array will be created with one
|
* fewer element (assuming that the specified plugin was found).
|
*
|
* @param pluginArray The array containing the existing set of plugins.
|
* @param plugin The plugin to be removed from the array.
|
*
|
* @return The new array containing the new set of plugins.
|
*/
|
private DirectoryServerPlugin[]
|
removePlugin(DirectoryServerPlugin[] pluginArray,
|
DirectoryServerPlugin plugin)
|
{
|
int slot = -1;
|
int length = pluginArray.length;
|
for (int i=0; i < length; i++)
|
{
|
if (pluginArray[i].getPluginEntryDN().equals(plugin.getPluginEntryDN()))
|
{
|
slot = i;
|
break;
|
}
|
}
|
|
if (slot < 0)
|
{
|
// The plugin wasn't found in the list, so return the same list.
|
return pluginArray;
|
}
|
|
|
// If it was the only element in the array, then return an empty array.
|
if (length == 0)
|
{
|
return new DirectoryServerPlugin[0];
|
}
|
|
|
// Create an array that's one element smaller and copy the remaining "good"
|
// elements into it.
|
DirectoryServerPlugin[] newPlugins = new DirectoryServerPlugin[length-1];
|
if (slot > 0)
|
{
|
System.arraycopy(pluginArray, 0, newPlugins, 0, slot);
|
}
|
|
if (slot < (length-1))
|
{
|
System.arraycopy(pluginArray, slot+1, newPlugins, slot, (length-slot-1));
|
}
|
|
return newPlugins;
|
}
|
|
|
|
/**
|
* Invokes the set of startup plugins that have been registered with the
|
* Directory Server.
|
*
|
* @return The result of processing the startup plugins.
|
*/
|
public PluginResult.Startup invokeStartupPlugins()
|
{
|
PluginResult.Startup result = null;
|
|
for (DirectoryServerPlugin p : startupPlugins)
|
{
|
try
|
{
|
result = p.doStartup();
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_STARTUP_PLUGIN_EXCEPTION.get(
|
String.valueOf(p.getPluginEntryDN()),
|
stackTraceToSingleLineString(e));
|
|
return PluginResult.Startup.stopStartup(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_STARTUP_PLUGIN_RETURNED_NULL.get(
|
String.valueOf(p.getPluginEntryDN()));
|
logError(message);
|
return PluginResult.Startup.stopStartup(message);
|
}
|
else if (! result.continueProcessing())
|
{
|
Message message = ERR_PLUGIN_STARTUP_PLUGIN_FAIL_ABORT.
|
get(String.valueOf(p.getPluginEntryDN()),
|
result.getErrorMessage(),
|
result.getErrorMessage().getDescriptor().getId());
|
logError(message);
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no startup plugins registered,
|
// which is fine.
|
result = PluginResult.Startup.continueStartup();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of shutdown plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param reason The human-readable reason for the shutdown.
|
*/
|
public void invokeShutdownPlugins(Message reason)
|
{
|
for (DirectoryServerPlugin p : shutdownPlugins)
|
{
|
try
|
{
|
p.doShutdown(reason);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_SHUTDOWN_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of post-connect plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param clientConnection The client connection that has been established.
|
*
|
* @return The result of processing the post-connect plugins.
|
*/
|
public PluginResult.PostConnect invokePostConnectPlugins(ClientConnection
|
clientConnection)
|
{
|
PluginResult.PostConnect result = null;
|
|
for (DirectoryServerPlugin p : postConnectPlugins)
|
{
|
try
|
{
|
result = p.doPostConnect(clientConnection);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_CONNECT_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
clientConnection.getConnectionID(),
|
clientConnection.getClientAddress(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.PostConnect.disconnectClient(
|
DisconnectReason.SERVER_ERROR, true, message);
|
}
|
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_CONNECT_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
clientConnection.getConnectionID(),
|
clientConnection.getClientAddress());
|
logError(message);
|
|
return PluginResult.PostConnect.disconnectClient(
|
DisconnectReason.SERVER_ERROR, true, message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-connect plugins
|
// registered, which is fine.
|
result = PluginResult.PostConnect.continueConnectProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-disconnect plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param clientConnection The client connection that has been closed.
|
* @param disconnectReason The general reason that the connection was
|
* closed.
|
* @param message A human-readable message that may provide
|
* additional information about the closure.
|
*
|
* @return The result of processing the post-connect plugins.
|
*/
|
public PluginResult.PostDisconnect invokePostDisconnectPlugins(
|
ClientConnection clientConnection,
|
DisconnectReason disconnectReason,
|
Message message)
|
{
|
PluginResult.PostDisconnect result = null;
|
|
for (DirectoryServerPlugin p : postDisconnectPlugins)
|
{
|
try
|
{
|
result = p.doPostDisconnect(clientConnection, disconnectReason,
|
message);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message msg = ERR_PLUGIN_POST_DISCONNECT_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
clientConnection.getConnectionID(),
|
clientConnection.getClientAddress(),
|
stackTraceToSingleLineString(e));
|
logError(msg);
|
}
|
|
|
if (result == null)
|
{
|
Message msg = ERR_PLUGIN_POST_DISCONNECT_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
clientConnection.getConnectionID(),
|
clientConnection.getClientAddress());
|
logError(msg);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-disconnect plugins
|
// registered, which is fine.
|
result = PluginResult.PostDisconnect.continueDisconnectProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of LDIF import plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param importConfig The LDIF import configuration used to read the
|
* associated entry.
|
* @param entry The entry that has been read from LDIF.
|
*
|
* @return The result of processing the LDIF import plugins.
|
*/
|
public PluginResult.ImportLDIF invokeLDIFImportPlugins(
|
LDIFImportConfig importConfig, Entry entry)
|
{
|
PluginResult.ImportLDIF result = null;
|
|
for (DirectoryServerPlugin p : ldifImportPlugins)
|
{
|
try
|
{
|
result = p.doLDIFImport(importConfig, entry);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_LDIF_IMPORT_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
String.valueOf(entry.getDN()), stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.ImportLDIF.stopEntryProcessing(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_LDIF_IMPORT_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
String.valueOf(entry.getDN()));
|
logError(message);
|
|
return PluginResult.ImportLDIF.stopEntryProcessing(message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no LDIF import plugins
|
// registered, which is fine.
|
result = PluginResult.ImportLDIF.continueEntryProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the LDIF import session finalization of LDIF import plugins that
|
* have been configured in the Directory Server.
|
*
|
* @param importConfig The LDIF import configuration used for the LDIF
|
* import session.
|
*/
|
public void invokeLDIFImportEndPlugins(
|
LDIFImportConfig importConfig)
|
{
|
for (DirectoryServerPlugin p : ldifImportEndPlugins)
|
{
|
p.doLDIFImportEnd(importConfig);
|
}
|
}
|
|
|
|
/**
|
* Invokes the LDIF import session initialization of LDIF import plugins that
|
* have been configured in the Directory Server.
|
*
|
* @param importConfig The LDIF import configuration used for the LDIF
|
* import session.
|
*/
|
public void invokeLDIFImportBeginPlugins(
|
LDIFImportConfig importConfig)
|
{
|
for (DirectoryServerPlugin p : ldifImportBeginPlugins)
|
{
|
p.doLDIFImportBegin(importConfig);
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of LDIF export plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param exportConfig The LDIF export configuration used to read the
|
* associated entry.
|
* @param entry The entry that has been read from LDIF.
|
*
|
* @return The result of processing the LDIF export plugins.
|
*/
|
public PluginResult.ImportLDIF invokeLDIFExportPlugins(
|
LDIFExportConfig exportConfig, Entry entry)
|
{
|
PluginResult.ImportLDIF result = null;
|
|
for (DirectoryServerPlugin p : ldifExportPlugins)
|
{
|
try
|
{
|
result = p.doLDIFExport(exportConfig, entry);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_LDIF_EXPORT_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
String.valueOf(entry.getDN()), stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.ImportLDIF.stopEntryProcessing(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_LDIF_EXPORT_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
String.valueOf(entry.getDN()));
|
logError(message);
|
|
return PluginResult.ImportLDIF.stopEntryProcessing(message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no LDIF export plugins
|
// registered, which is fine.
|
result = PluginResult.ImportLDIF.continueEntryProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse abandon plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param abandonOperation The abandon operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse abandon plugins.
|
*/
|
public PluginResult.PreParse invokePreParseAbandonPlugins(
|
PreParseAbandonOperation abandonOperation)
|
{
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseAbandonPlugins)
|
{
|
if (abandonOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(abandonOperation);
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, abandonOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(abandonOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse abandon plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
private PluginResult.PreParse handlePreParseException(
|
Exception e, PreParseOperation operation, DirectoryServerPlugin plugin)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message =
|
ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION.get(operation.getOperationType()
|
.getOperationName(), String.valueOf(plugin.getPluginEntryDN()),
|
operation.getConnectionID(), operation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.PreParse.stopProcessing(DirectoryServer
|
.getServerErrorResultCode(), message);
|
}
|
|
private PluginResult.PreParse handlePreParseResult(
|
PreParseOperation operation, DirectoryServerPlugin plugin)
|
{
|
Message message =
|
ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL.get(operation
|
.getOperationType().getOperationName(), String.valueOf(plugin
|
.getPluginEntryDN()), operation.getConnectionID(), String
|
.valueOf(operation.getOperationID()));
|
logError(message);
|
|
return PluginResult.PreParse.stopProcessing(DirectoryServer
|
.getServerErrorResultCode(), message);
|
}
|
|
|
/**
|
* Invokes the set of pre-parse add plugins that have been configured in the
|
* Directory Server.
|
*
|
* @param addOperation The add operation for which to invoke the pre-parse
|
* plugins.
|
*
|
* @return The result of processing the pre-parse add plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseAddPlugins(
|
PreParseAddOperation addOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseAddPlugins)
|
{
|
if (addOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(addOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, addOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(addOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse add plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse bind plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param bindOperation The bind operation for which to invoke the pre-parse
|
* plugins.
|
*
|
* @return The result of processing the pre-parse bind plugins.
|
*/
|
public PluginResult.PreParse invokePreParseBindPlugins(
|
PreParseBindOperation bindOperation)
|
{
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseBindPlugins)
|
{
|
if (bindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(bindOperation);
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, bindOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(bindOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse bind plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse compare plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param compareOperation The compare operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse compare plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseComparePlugins(
|
PreParseCompareOperation compareOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseComparePlugins)
|
{
|
if (compareOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(compareOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, compareOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(compareOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse compare plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse delete plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param deleteOperation The delete operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse delete plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseDeletePlugins(
|
PreParseDeleteOperation deleteOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseDeletePlugins)
|
{
|
if (deleteOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(deleteOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, deleteOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(deleteOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse delete plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse extended plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param extendedOperation The extended operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse extended plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseExtendedPlugins(
|
PreParseExtendedOperation extendedOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseExtendedPlugins)
|
{
|
if (extendedOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(extendedOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, extendedOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(extendedOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse extended plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse modify plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param modifyOperation The modify operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse modify plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseModifyPlugins(
|
PreParseModifyOperation modifyOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseModifyPlugins)
|
{
|
if (modifyOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(modifyOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, modifyOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(modifyOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse modify plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse modify DN plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse modify DN plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseModifyDNPlugins(
|
PreParseModifyDNOperation modifyDNOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseModifyDNPlugins)
|
{
|
if (modifyDNOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(modifyDNOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, modifyDNOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(modifyDNOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse modify DN plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse search plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse search plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreParse invokePreParseSearchPlugins(
|
PreParseSearchOperation searchOperation)
|
throws CanceledOperationException {
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseSearchPlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(searchOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, searchOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(searchOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse search plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-parse unbind plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param unbindOperation The unbind operation for which to invoke the
|
* pre-parse plugins.
|
*
|
* @return The result of processing the pre-parse unbind plugins.
|
*/
|
public PluginResult.PreParse invokePreParseUnbindPlugins(
|
PreParseUnbindOperation unbindOperation)
|
{
|
PluginResult.PreParse result = null;
|
|
for (DirectoryServerPlugin p : preParseUnbindPlugins)
|
{
|
if (unbindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreParse(unbindOperation);
|
}
|
catch (Exception e)
|
{
|
return handlePreParseException(e, unbindOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreParseResult(unbindOperation, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-parse unbind plugins
|
// registered, which is fine.
|
result = PluginResult.PreParse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation add plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param addOperation The add operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation add plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationAddPlugins(
|
PreOperationAddOperation addOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationAddPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationAddPlugins[i];
|
if (addOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(addOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationAddPlugins,
|
addOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(addOperation, i, preOperationAddPlugins,
|
p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationAddPlugins,
|
addOperation);
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation bind plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param bindOperation The bind operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation bind plugins.
|
*/
|
public PluginResult.PreOperation invokePreOperationBindPlugins(
|
PreOperationBindOperation bindOperation)
|
{
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationBindPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationBindPlugins[i];
|
if (bindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(bindOperation);
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationBindPlugins,
|
bindOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(bindOperation, i,
|
preOperationBindPlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationBindPlugins,
|
bindOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation compare plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param compareOperation The compare operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation compare plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationComparePlugins(
|
PreOperationCompareOperation compareOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationComparePlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationComparePlugins[i];
|
if (compareOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(compareOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationComparePlugins,
|
compareOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(compareOperation, i,
|
preOperationComparePlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation delete plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param deleteOperation The delete operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation delete plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationDeletePlugins(
|
PreOperationDeleteOperation deleteOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationDeletePlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationDeletePlugins[i];
|
if (deleteOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(deleteOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationDeletePlugins,
|
deleteOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(deleteOperation, i,
|
preOperationDeletePlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationDeletePlugins,
|
deleteOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
private PluginResult.PreOperation handlePreOperationException(Exception e,
|
int i, DirectoryServerPlugin[] plugins, PreOperationOperation operation,
|
DirectoryServerPlugin plugin)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message =
|
ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION.get(operation
|
.getOperationType().getOperationName(), String.valueOf(plugin
|
.getPluginEntryDN()), operation.getConnectionID(), operation
|
.getOperationID(), stackTraceToSingleLineString(e));
|
logError(message);
|
|
registerSkippedPreOperationPlugins(i, plugins, operation);
|
|
return PluginResult.PreOperation.stopProcessing(DirectoryServer
|
.getServerErrorResultCode(), message);
|
}
|
|
private PluginResult.PreOperation handlePreOperationResult(
|
PreOperationOperation operation, int i, DirectoryServerPlugin[] plugins,
|
DirectoryServerPlugin plugin)
|
{
|
Message message =
|
ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL.get(operation
|
.getOperationType().getOperationName(), String.valueOf(plugin
|
.getPluginEntryDN()), operation.getConnectionID(), operation
|
.getOperationID());
|
logError(message);
|
|
registerSkippedPreOperationPlugins(i, plugins, operation);
|
|
return PluginResult.PreOperation.stopProcessing(DirectoryServer
|
.getServerErrorResultCode(), message);
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation extended plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param extendedOperation The extended operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation extended plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationExtendedPlugins(
|
PreOperationExtendedOperation extendedOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationExtendedPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationExtendedPlugins[i];
|
if (extendedOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
registerSkippedPreOperationPlugin(p, extendedOperation);
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(extendedOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationExtendedPlugins,
|
extendedOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(extendedOperation, i,
|
preOperationExtendedPlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationExtendedPlugins,
|
extendedOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation modify plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param modifyOperation The modify operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation modify plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationModifyPlugins(
|
PreOperationModifyOperation modifyOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationModifyPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationModifyPlugins[i];
|
if (modifyOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(modifyOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationModifyPlugins,
|
modifyOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(modifyOperation, i,
|
preOperationModifyPlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationModifyPlugins,
|
modifyOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation modify DN plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation modify DN plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationModifyDNPlugins(
|
PreOperationModifyDNOperation modifyDNOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationModifyDNPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationModifyDNPlugins[i];
|
if (modifyDNOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(modifyDNOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationModifyDNPlugins,
|
modifyDNOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(modifyDNOperation, i,
|
preOperationModifyDNPlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationModifyDNPlugins,
|
modifyDNOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of pre-operation search plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* pre-operation plugins.
|
*
|
* @return The result of processing the pre-operation search plugins.
|
*
|
* @throws CanceledOperationException if the operation should be canceled.
|
*/
|
public PluginResult.PreOperation invokePreOperationSearchPlugins(
|
PreOperationSearchOperation searchOperation)
|
throws CanceledOperationException {
|
PluginResult.PreOperation result = null;
|
|
for (int i = 0; i < preOperationSearchPlugins.length; i++)
|
{
|
DirectoryServerPlugin p = preOperationSearchPlugins[i];
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPreOperation(searchOperation);
|
}
|
catch (CanceledOperationException coe)
|
{
|
throw coe;
|
}
|
catch (Exception e)
|
{
|
return handlePreOperationException(e, i, preOperationSearchPlugins,
|
searchOperation, p);
|
}
|
|
if (result == null)
|
{
|
return handlePreOperationResult(searchOperation, i,
|
preOperationSearchPlugins, p);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
registerSkippedPreOperationPlugins(i, preOperationSearchPlugins,
|
searchOperation);
|
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no pre-operation add plugins
|
// registered, which is fine.
|
result = PluginResult.PreOperation.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation abandon plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param abandonOperation The abandon operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation abandon plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationAbandonPlugins(
|
PostOperationAbandonOperation abandonOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
for (DirectoryServerPlugin p : postOperationAbandonPlugins)
|
{
|
if (abandonOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(abandonOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(abandonOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
abandonOperation.getConnectionID(),
|
abandonOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(abandonOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
abandonOperation.getConnectionID(),
|
abandonOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation add plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param addOperation The add operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation add plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationAddPlugins(
|
PostOperationAddOperation addOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(addOperation);
|
|
for (DirectoryServerPlugin p : postOperationAddPlugins)
|
{
|
if (addOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(addOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(addOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
addOperation.getConnectionID(), addOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(addOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
addOperation.getConnectionID(), addOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation bind plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param bindOperation The bind operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation bind plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationBindPlugins(
|
PostOperationBindOperation bindOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(bindOperation);
|
|
for (DirectoryServerPlugin p : postOperationBindPlugins)
|
{
|
if (bindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(bindOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(bindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
bindOperation.getConnectionID(), bindOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(bindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
bindOperation.getConnectionID(),
|
bindOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation compare plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param compareOperation The compare operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation compare plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationComparePlugins(
|
PostOperationCompareOperation compareOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(compareOperation);
|
|
for (DirectoryServerPlugin p : postOperationComparePlugins)
|
{
|
if (compareOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(compareOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(compareOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
compareOperation.getConnectionID(),
|
compareOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(compareOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
compareOperation.getConnectionID(),
|
compareOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation delete plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param deleteOperation The delete operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation delete plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationDeletePlugins(
|
PostOperationDeleteOperation deleteOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(deleteOperation);
|
|
for (DirectoryServerPlugin p : postOperationDeletePlugins)
|
{
|
if (deleteOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(deleteOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(deleteOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(deleteOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation extended plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param extendedOperation The extended operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation extended plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationExtendedPlugins(
|
PostOperationExtendedOperation extendedOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(extendedOperation);
|
|
for (DirectoryServerPlugin p : postOperationExtendedPlugins)
|
{
|
if (extendedOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(extendedOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(extendedOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
extendedOperation.getConnectionID(),
|
extendedOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(extendedOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
extendedOperation.getConnectionID(),
|
extendedOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation modify plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param modifyOperation The modify operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation modify plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationModifyPlugins(
|
PostOperationModifyOperation modifyOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(modifyOperation);
|
|
for (DirectoryServerPlugin p : postOperationModifyPlugins)
|
{
|
if (modifyOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(modifyOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(modifyOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyOperation.getConnectionID(),
|
modifyOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(modifyOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyOperation.getConnectionID(),
|
modifyOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation modify DN plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation modify DN plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationModifyDNPlugins(
|
PostOperationModifyDNOperation modifyDNOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(modifyDNOperation);
|
|
for (DirectoryServerPlugin p : postOperationModifyDNPlugins)
|
{
|
if (modifyDNOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(modifyDNOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(modifyDNOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(modifyDNOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation search plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation search plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationSearchPlugins(
|
PostOperationSearchOperation searchOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(searchOperation);
|
|
for (DirectoryServerPlugin p : postOperationSearchPlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(searchOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(searchOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(searchOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-operation unbind plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param unbindOperation The unbind operation for which to invoke the
|
* post-operation plugins.
|
*
|
* @return The result of processing the post-operation unbind plugins.
|
*/
|
public PluginResult.PostOperation invokePostOperationUnbindPlugins(
|
PostOperationUnbindOperation unbindOperation)
|
{
|
PluginResult.PostOperation result = null;
|
PluginResult.PostOperation finalResult = null;
|
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
skippedPreOperationPlugins.remove(unbindOperation);
|
|
for (DirectoryServerPlugin p : postOperationUnbindPlugins)
|
{
|
if (unbindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if(skippedPlugins != null && skippedPlugins.contains(p))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostOperation(unbindOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION.
|
get(unbindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
unbindOperation.getConnectionID(),
|
unbindOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL.
|
get(unbindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
unbindOperation.getConnectionID(),
|
unbindOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continueProcessing())
|
{
|
// This plugin requested operation processing to stop. However, we
|
// still have to invoke all the post op plugins that successfully
|
// invoked its pre op plugins. We will just take this plugin's
|
// results as the final result.
|
finalResult = result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-operation add plugins
|
// registered, which is fine.
|
finalResult = PluginResult.PostOperation.continueOperationProcessing();
|
}
|
else if(finalResult == null)
|
{
|
// None of the plugins requested processing to stop so all results
|
// have equal priority. Just return the last one.
|
finalResult = result;
|
}
|
|
return finalResult;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response add plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param addOperation The add operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response add plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseAddPlugins(
|
PostResponseAddOperation addOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseAddPlugins)
|
{
|
if (addOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(addOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(addOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
addOperation.getConnectionID(), addOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(addOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
addOperation.getConnectionID(), addOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response bind plugins that have been configured in
|
* the Directory Server.
|
*
|
* @param bindOperation The bind operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response bind plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseBindPlugins(
|
PostResponseBindOperation bindOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseBindPlugins)
|
{
|
if (bindOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(bindOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(bindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
bindOperation.getConnectionID(), bindOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(bindOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
bindOperation.getConnectionID(),
|
bindOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response compare plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param compareOperation The compare operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response compare plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseComparePlugins(
|
PostResponseCompareOperation compareOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseComparePlugins)
|
{
|
if (compareOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(compareOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(compareOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
compareOperation.getConnectionID(),
|
compareOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(compareOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
compareOperation.getConnectionID(),
|
compareOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response delete plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param deleteOperation The delete operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response delete plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseDeletePlugins(
|
PostResponseDeleteOperation deleteOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseDeletePlugins)
|
{
|
if (deleteOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(deleteOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(deleteOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(deleteOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response extended plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param extendedOperation The extended operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response extended plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseExtendedPlugins(
|
PostResponseExtendedOperation extendedOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseExtendedPlugins)
|
{
|
if (extendedOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(extendedOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(extendedOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
extendedOperation.getConnectionID(),
|
extendedOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(extendedOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
extendedOperation.getConnectionID(),
|
extendedOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response modify plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param modifyOperation The modify operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response modify plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseModifyPlugins(
|
PostResponseModifyOperation modifyOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseModifyPlugins)
|
{
|
if (modifyOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(modifyOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(modifyOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyOperation.getConnectionID(),
|
modifyOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(modifyOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyOperation.getConnectionID(),
|
modifyOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response modify DN plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response modify DN plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseModifyDNPlugins(
|
PostResponseModifyDNOperation modifyDNOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseModifyDNPlugins)
|
{
|
if (modifyDNOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(modifyDNOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(modifyDNOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(modifyDNOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-response search plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* post-response plugins.
|
*
|
* @return The result of processing the post-response search plugins.
|
*/
|
public PluginResult.PostResponse invokePostResponseSearchPlugins(
|
PostResponseSearchOperation searchOperation)
|
{
|
PluginResult.PostResponse result = null;
|
|
for (DirectoryServerPlugin p : postResponseSearchPlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.doPostResponse(searchOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION.
|
get(searchOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(searchOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID());
|
logError(message);
|
}
|
else if (!result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no post-response add plugins
|
// registered, which is fine.
|
result = PluginResult.PostResponse.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of post-synchronization add plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param addOperation The add operation for which to invoke the
|
* post-synchronization plugins.
|
*/
|
public void invokePostSynchronizationAddPlugins(
|
PostSynchronizationAddOperation addOperation)
|
{
|
for (DirectoryServerPlugin p : postSynchronizationAddPlugins)
|
{
|
try
|
{
|
p.doPostSynchronization(addOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION.
|
get(addOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
addOperation.getConnectionID(), addOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of post-synchronization delete plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param deleteOperation The delete operation for which to invoke the
|
* post-synchronization plugins.
|
*/
|
public void invokePostSynchronizationDeletePlugins(
|
PostSynchronizationDeleteOperation deleteOperation)
|
{
|
for (DirectoryServerPlugin p : postSynchronizationDeletePlugins)
|
{
|
try
|
{
|
p.doPostSynchronization(deleteOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION.
|
get(deleteOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of post-synchronization modify plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param modifyOperation The modify operation for which to invoke the
|
* post-synchronization plugins.
|
*/
|
public void invokePostSynchronizationModifyPlugins(
|
PostSynchronizationModifyOperation modifyOperation)
|
{
|
for (DirectoryServerPlugin p : postSynchronizationModifyPlugins)
|
{
|
try
|
{
|
p.doPostSynchronization(modifyOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION.
|
get(modifyOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyOperation.getConnectionID(),
|
modifyOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of post-synchronization modify DN plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation for which to invoke the
|
* post-synchronization plugins.
|
*/
|
public void invokePostSynchronizationModifyDNPlugins(
|
PostSynchronizationModifyDNOperation modifyDNOperation)
|
{
|
for (DirectoryServerPlugin p : postSynchronizationModifyDNPlugins)
|
{
|
try
|
{
|
p.doPostSynchronization(modifyDNOperation);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION.
|
get(modifyDNOperation.getOperationType().getOperationName(),
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
}
|
}
|
}
|
|
|
|
/**
|
* Invokes the set of search result entry plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* search result entry plugins.
|
* @param searchEntry The search result entry to be processed.
|
*
|
* @return The result of processing the search result entry plugins.
|
*/
|
public PluginResult.IntermediateResponse invokeSearchResultEntryPlugins(
|
LocalBackendSearchOperation searchOperation,
|
SearchResultEntry searchEntry)
|
{
|
PluginResult.IntermediateResponse result = null;
|
|
for (DirectoryServerPlugin p : searchResultEntryPlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSearchEntry(searchOperation, searchEntry);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
String.valueOf(searchEntry.getDN()),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
String.valueOf(searchEntry.getDN()));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no search result entry plugins
|
// registered, which is fine.
|
result = PluginResult.IntermediateResponse.
|
continueOperationProcessing(true);
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of search result entry plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* search result entry plugins.
|
* @param searchEntry The search result entry to be processed.
|
*
|
* @return The result of processing the search result entry plugins.
|
*/
|
public PluginResult.IntermediateResponse invokeSearchResultEntryPlugins(
|
SearchEntrySearchOperation searchOperation,
|
SearchResultEntry searchEntry)
|
{
|
PluginResult.IntermediateResponse result = null;
|
|
for (DirectoryServerPlugin p : searchResultEntryPlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSearchEntry(searchOperation, searchEntry);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
String.valueOf(searchEntry.getDN()),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
String.valueOf(searchEntry.getDN()));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no search result entry plugins
|
// registered, which is fine.
|
result =
|
PluginResult.IntermediateResponse.continueOperationProcessing(true);
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of search result reference plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* search result reference plugins.
|
* @param searchReference The search result reference to be processed.
|
*
|
* @return The result of processing the search result reference plugins.
|
*/
|
public PluginResult.IntermediateResponse invokeSearchResultReferencePlugins(
|
LocalBackendSearchOperation searchOperation,
|
SearchResultReference searchReference)
|
{
|
PluginResult.IntermediateResponse result = null;
|
|
for (DirectoryServerPlugin p : searchResultReferencePlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSearchReference(searchOperation, searchReference);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
searchReference.getReferralURLString(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
searchReference.getReferralURLString());
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no search result reference
|
// plugins registered, which is fine.
|
result =
|
PluginResult.IntermediateResponse.continueOperationProcessing(true);
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of search result reference plugins that have been
|
* configured in the Directory Server.
|
*
|
* @param searchOperation The search operation for which to invoke the
|
* search result reference plugins.
|
* @param searchReference The search result reference to be processed.
|
*
|
* @return The result of processing the search result reference plugins.
|
*/
|
public PluginResult.IntermediateResponse invokeSearchResultReferencePlugins(
|
SearchReferenceSearchOperation searchOperation,
|
SearchResultReference searchReference)
|
{
|
PluginResult.IntermediateResponse result = null;
|
|
for (DirectoryServerPlugin p : searchResultReferencePlugins)
|
{
|
if (searchOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSearchReference(searchOperation, searchReference);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
searchReference.getReferralURLString(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
searchOperation.getConnectionID(),
|
searchOperation.getOperationID(),
|
searchReference.getReferralURLString());
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing(false,
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no search result reference
|
// plugins registered, which is fine.
|
result =
|
PluginResult.IntermediateResponse.continueOperationProcessing(true);
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of subordinate modify DN plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param modifyDNOperation The modify DN operation with which the
|
* subordinate entry is associated.
|
* @param oldEntry The subordinate entry prior to the move/rename
|
* operation.
|
* @param newEntry The subordinate entry after the move/rename
|
* operation.
|
* @param modifications A list into which any modifications made to the
|
* target entry should be placed.
|
*
|
* @return The result of processing the subordinate modify DN plugins.
|
*/
|
public PluginResult.SubordinateModifyDN invokeSubordinateModifyDNPlugins(
|
SubordinateModifyDNOperation modifyDNOperation, Entry oldEntry,
|
Entry newEntry, List<Modification> modifications)
|
{
|
PluginResult.SubordinateModifyDN result = null;
|
|
for (DirectoryServerPlugin p : subordinateModifyDNPlugins)
|
{
|
if (modifyDNOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSubordinateModifyDN(modifyDNOperation, oldEntry,
|
newEntry, modifications);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message =
|
ERR_PLUGIN_SUBORDINATE_MODIFY_DN_PLUGIN_EXCEPTION.get(
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
modifyDNOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.SubordinateModifyDN.stopProcessing(
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message =
|
ERR_PLUGIN_SUBORDINATE_MODIFY_DN_PLUGIN_RETURNED_NULL.get(
|
String.valueOf(p.getPluginEntryDN()),
|
modifyDNOperation.getConnectionID(),
|
String.valueOf(modifyDNOperation.getOperationID()));
|
logError(message);
|
|
return PluginResult.SubordinateModifyDN.stopProcessing(
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no subordinate modify DN plugins
|
// registered, which is fine.
|
result = PluginResult.SubordinateModifyDN.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of subordinate delete plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param deleteOperation The delete operation with which the
|
* subordinate entry is associated.
|
* @param entry The subordinate entry being deleted.
|
*
|
* @return The result of processing the subordinate delete plugins.
|
*/
|
public PluginResult.SubordinateDelete invokeSubordinateDeletePlugins(
|
DeleteOperation deleteOperation, Entry entry)
|
{
|
PluginResult.SubordinateDelete result = null;
|
|
for (DirectoryServerPlugin p : subordinateDeletePlugins)
|
{
|
if (deleteOperation.isInternalOperation() &&
|
(! p.invokeForInternalOperations()))
|
{
|
continue;
|
}
|
|
try
|
{
|
result = p.processSubordinateDelete(deleteOperation, entry);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message =
|
ERR_PLUGIN_SUBORDINATE_DELETE_PLUGIN_EXCEPTION.get(
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
deleteOperation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.SubordinateDelete.stopProcessing(
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message =
|
ERR_PLUGIN_SUBORDINATE_DELETE_PLUGIN_RETURNED_NULL.get(
|
String.valueOf(p.getPluginEntryDN()),
|
deleteOperation.getConnectionID(),
|
String.valueOf(deleteOperation.getOperationID()));
|
logError(message);
|
|
return PluginResult.SubordinateDelete.stopProcessing(
|
DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no subordinate modify DN plugins
|
// registered, which is fine.
|
result = PluginResult.SubordinateDelete.continueOperationProcessing();
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* Invokes the set of intermediate response plugins that have been configured
|
* in the Directory Server.
|
*
|
* @param intermediateResponse The intermediate response for which to invoke
|
* the intermediate response plugins.
|
*
|
* @return The result of processing the intermediate response plugins.
|
*/
|
public PluginResult.IntermediateResponse
|
invokeIntermediateResponsePlugins(
|
IntermediateResponse intermediateResponse)
|
{
|
PluginResult.IntermediateResponse result = null;
|
Operation operation = intermediateResponse.getOperation();
|
|
for (DirectoryServerPlugin p : intermediateResponsePlugins)
|
{
|
try
|
{
|
result = p.processIntermediateResponse(intermediateResponse);
|
}
|
catch (Exception e)
|
{
|
if (debugEnabled())
|
{
|
TRACER.debugCaught(DebugLogLevel.ERROR, e);
|
}
|
|
Message message = ERR_PLUGIN_INTERMEDIATE_RESPONSE_PLUGIN_EXCEPTION.
|
get(String.valueOf(p.getPluginEntryDN()),
|
operation.getConnectionID(), operation.getOperationID(),
|
stackTraceToSingleLineString(e));
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing
|
(false, DirectoryServer.getServerErrorResultCode(), message);
|
}
|
|
if (result == null)
|
{
|
Message message = ERR_PLUGIN_INTERMEDIATE_RESPONSE_PLUGIN_RETURNED_NULL.
|
get(String.valueOf(p.getPluginEntryDN()),
|
operation.getConnectionID(), operation.getOperationID());
|
logError(message);
|
|
return PluginResult.IntermediateResponse.stopProcessing
|
(false, DirectoryServer.getServerErrorResultCode(), message);
|
}
|
else if (! result.continuePluginProcessing())
|
{
|
return result;
|
}
|
}
|
|
if (result == null)
|
{
|
// This should only happen if there were no intermediate response plugins
|
// registered, which is fine.
|
result =
|
PluginResult.IntermediateResponse.continueOperationProcessing(true);
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public boolean isConfigurationAddAcceptable(PluginCfg configuration,
|
List<Message> unacceptableReasons)
|
{
|
if (configuration.isEnabled())
|
{
|
// Create a set of plugin types for the plugin.
|
HashSet<PluginType> pluginTypes = new HashSet<PluginType>();
|
for (PluginCfgDefn.PluginType pluginType :
|
configuration.getPluginType())
|
{
|
pluginTypes.add(getPluginType(pluginType));
|
}
|
|
// Get the name of the class and make sure we can instantiate it as a
|
// plugin.
|
String className = configuration.getJavaClass();
|
try
|
{
|
loadPlugin(className, pluginTypes, configuration, false);
|
}
|
catch (InitializationException ie)
|
{
|
unacceptableReasons.add(ie.getMessageObject());
|
return false;
|
}
|
}
|
|
// If we've gotten here, then it's fine.
|
return true;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public ConfigChangeResult applyConfigurationAdd(
|
PluginCfg configuration)
|
{
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
ArrayList<Message> messages = new ArrayList<Message>();
|
|
configuration.addChangeListener(this);
|
|
if (! configuration.isEnabled())
|
{
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
// Create a set of plugin types for the plugin.
|
HashSet<PluginType> pluginTypes = new HashSet<PluginType>();
|
for (PluginCfgDefn.PluginType pluginType :
|
configuration.getPluginType())
|
{
|
pluginTypes.add(getPluginType(pluginType));
|
}
|
|
// Get the name of the class and make sure we can instantiate it as a
|
// plugin.
|
DirectoryServerPlugin<? extends PluginCfg> plugin = null;
|
String className = configuration.getJavaClass();
|
try
|
{
|
plugin = loadPlugin(className, pluginTypes, configuration, true);
|
}
|
catch (InitializationException ie)
|
{
|
if (resultCode == ResultCode.SUCCESS)
|
{
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
}
|
|
messages.add(ie.getMessageObject());
|
}
|
|
if (resultCode == ResultCode.SUCCESS)
|
{
|
registerPlugin(plugin, configuration.dn(), pluginTypes);
|
}
|
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public boolean isConfigurationDeleteAcceptable(
|
PluginCfg configuration,
|
List<Message> unacceptableReasons)
|
{
|
// We will always allow plugins to be removed.
|
return true;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public ConfigChangeResult applyConfigurationDelete(
|
PluginCfg configuration)
|
{
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
ArrayList<Message> messages = new ArrayList<Message>();
|
|
deregisterPlugin(configuration.dn());
|
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public boolean isConfigurationChangeAcceptable(
|
PluginCfg configuration,
|
List<Message> unacceptableReasons)
|
{
|
if (configuration.isEnabled())
|
{
|
// Create a set of plugin types for the plugin.
|
HashSet<PluginType> pluginTypes = new HashSet<PluginType>();
|
for (PluginCfgDefn.PluginType pluginType :
|
configuration.getPluginType())
|
{
|
pluginTypes.add(getPluginType(pluginType));
|
}
|
|
// Get the name of the class and make sure we can instantiate it as a
|
// plugin.
|
String className = configuration.getJavaClass();
|
try
|
{
|
loadPlugin(className, pluginTypes, configuration, false);
|
}
|
catch (InitializationException ie)
|
{
|
unacceptableReasons.add(ie.getMessageObject());
|
return false;
|
}
|
}
|
|
// If we've gotten here, then it's fine.
|
return true;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public ConfigChangeResult applyConfigurationChange(
|
PluginCfg configuration)
|
{
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
ArrayList<Message> messages = new ArrayList<Message>();
|
|
|
// Get the existing plugin if it's already enabled.
|
DirectoryServerPlugin existingPlugin =
|
registeredPlugins.get(configuration.dn());
|
|
|
// If the new configuration has the plugin disabled, then deregister it if
|
// it is enabled, or do nothing if it's already disabled.
|
if (! configuration.isEnabled())
|
{
|
if (existingPlugin != null)
|
{
|
deregisterPlugin(configuration.dn());
|
}
|
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
|
// Get the class for the identity mapper. If the mapper is already enabled,
|
// then we shouldn't do anything with it although if the class has changed
|
// then we'll at least need to indicate that administrative action is
|
// required. If the mapper is disabled, then instantiate the class and
|
// initialize and register it as an identity mapper. Also, update the
|
// plugin to indicate whether it should be invoked for internal operations.
|
String className = configuration.getJavaClass();
|
if (existingPlugin != null)
|
{
|
if (! className.equals(existingPlugin.getClass().getName()))
|
{
|
adminActionRequired = true;
|
}
|
|
existingPlugin.setInvokeForInternalOperations(
|
configuration.isInvokeForInternalOperations());
|
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
// Create a set of plugin types for the plugin.
|
HashSet<PluginType> pluginTypes = new HashSet<PluginType>();
|
for (PluginCfgDefn.PluginType pluginType :
|
configuration.getPluginType())
|
{
|
pluginTypes.add(getPluginType(pluginType));
|
}
|
|
DirectoryServerPlugin<? extends PluginCfg> plugin = null;
|
try
|
{
|
plugin = loadPlugin(className, pluginTypes, configuration, true);
|
}
|
catch (InitializationException ie)
|
{
|
if (resultCode == ResultCode.SUCCESS)
|
{
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
}
|
|
messages.add(ie.getMessageObject());
|
}
|
|
if (resultCode == ResultCode.SUCCESS)
|
{
|
registerPlugin(plugin, configuration.dn(), pluginTypes);
|
}
|
|
return new ConfigChangeResult(resultCode, adminActionRequired, messages);
|
}
|
|
private void registerSkippedPreOperationPlugins(int i,
|
DirectoryServerPlugin[] plugins,
|
PluginOperation operation)
|
{
|
ArrayList<DirectoryServerPlugin> skippedPlugins =
|
new ArrayList<DirectoryServerPlugin>(plugins.length - i);
|
for(int j = i; j < plugins.length; j++)
|
{
|
skippedPlugins.add(plugins[j]);
|
}
|
skippedPreOperationPlugins.put(operation, skippedPlugins);
|
}
|
|
private void registerSkippedPreOperationPlugin(DirectoryServerPlugin plugin,
|
PluginOperation operation)
|
{
|
ArrayList<DirectoryServerPlugin> existingList =
|
skippedPreOperationPlugins.get(operation);
|
if(existingList == null)
|
{
|
existingList = new ArrayList<DirectoryServerPlugin>();
|
}
|
existingList.add(plugin);
|
skippedPreOperationPlugins.put(operation, existingList);
|
}
|
}
|
