001/*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License").  You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * docs/licenses/cddl.txt
011 * or http://www.opensource.org/licenses/cddl1.php.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * docs/licenses/cddl.txt.  If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 *      Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 *      Portions Copyright 2010-2023 Ping Identity Corporation
026 */
027package com.unboundid.directory.sdk.ds.api;
028
029
030
031import java.util.Collections;
032import java.util.List;
033import java.util.Map;
034import java.util.Set;
035
036import com.unboundid.directory.sdk.broker.internal.BrokerExtension;
037import com.unboundid.directory.sdk.common.internal.ExampleUsageProvider;
038import com.unboundid.directory.sdk.common.internal.Reconfigurable;
039import com.unboundid.directory.sdk.common.internal.UnboundIDExtension;
040import com.unboundid.directory.sdk.common.operation.AddRequest;
041import com.unboundid.directory.sdk.common.operation.AddResult;
042import com.unboundid.directory.sdk.common.operation.BindResult;
043import com.unboundid.directory.sdk.common.operation.CompareRequest;
044import com.unboundid.directory.sdk.common.operation.CompareResult;
045import com.unboundid.directory.sdk.common.operation.DeleteRequest;
046import com.unboundid.directory.sdk.common.operation.DeleteResult;
047import com.unboundid.directory.sdk.common.operation.ExtendedRequest;
048import com.unboundid.directory.sdk.common.operation.ExtendedResult;
049import com.unboundid.directory.sdk.common.operation.ModifyRequest;
050import com.unboundid.directory.sdk.common.operation.ModifyResult;
051import com.unboundid.directory.sdk.common.operation.ModifyDNRequest;
052import com.unboundid.directory.sdk.common.operation.ModifyDNResult;
053import com.unboundid.directory.sdk.common.operation.SASLBindRequest;
054import com.unboundid.directory.sdk.common.operation.SearchRequest;
055import com.unboundid.directory.sdk.common.operation.SearchResult;
056import com.unboundid.directory.sdk.common.operation.SimpleBindRequest;
057import com.unboundid.directory.sdk.common.operation.UpdatableAbandonRequest;
058import com.unboundid.directory.sdk.common.operation.UpdatableAddRequest;
059import com.unboundid.directory.sdk.common.operation.UpdatableAddResult;
060import com.unboundid.directory.sdk.common.operation.UpdatableBindResult;
061import com.unboundid.directory.sdk.common.operation.UpdatableCompareRequest;
062import com.unboundid.directory.sdk.common.operation.UpdatableCompareResult;
063import com.unboundid.directory.sdk.common.operation.UpdatableDeleteRequest;
064import com.unboundid.directory.sdk.common.operation.UpdatableDeleteResult;
065import com.unboundid.directory.sdk.common.operation.UpdatableExtendedRequest;
066import com.unboundid.directory.sdk.common.operation.UpdatableExtendedResult;
067import com.unboundid.directory.sdk.common.operation.UpdatableGenericResult;
068import com.unboundid.directory.sdk.common.operation.UpdatableModifyRequest;
069import com.unboundid.directory.sdk.common.operation.UpdatableModifyResult;
070import com.unboundid.directory.sdk.common.operation.UpdatableModifyDNRequest;
071import com.unboundid.directory.sdk.common.operation.UpdatableModifyDNResult;
072import com.unboundid.directory.sdk.common.operation.UpdatableSASLBindRequest;
073import com.unboundid.directory.sdk.common.operation.UpdatableSearchRequest;
074import com.unboundid.directory.sdk.common.operation.UpdatableSearchResult;
075import com.unboundid.directory.sdk.common.operation.UpdatableSimpleBindRequest;
076import com.unboundid.directory.sdk.common.operation.UpdatableUnbindRequest;
077import com.unboundid.directory.sdk.common.types.ActiveOperationContext;
078import com.unboundid.directory.sdk.common.types.ActiveSearchOperationContext;
079import com.unboundid.directory.sdk.common.types.CompletedOperationContext;
080import com.unboundid.directory.sdk.common.types.CompletedSearchOperationContext;
081import com.unboundid.directory.sdk.common.types.ClientContext;
082import com.unboundid.directory.sdk.common.types.DisconnectReason;
083import com.unboundid.directory.sdk.common.types.Entry;
084import com.unboundid.directory.sdk.common.types.UpdatableEntry;
085import com.unboundid.directory.sdk.ds.config.PluginConfig;
086import com.unboundid.directory.sdk.ds.internal.DirectoryServerExtension;
087import com.unboundid.directory.sdk.ds.types.DirectoryServerContext;
088import com.unboundid.directory.sdk.ds.types.IntermediateResponsePluginResult;
089import com.unboundid.directory.sdk.ds.types.LDIFPluginResult;
090import com.unboundid.directory.sdk.ds.types.PostConnectPluginResult;
091import com.unboundid.directory.sdk.ds.types.PostDisconnectPluginResult;
092import com.unboundid.directory.sdk.ds.types.PostOperationPluginResult;
093import com.unboundid.directory.sdk.ds.types.PostResponsePluginResult;
094import com.unboundid.directory.sdk.ds.types.PreOperationPluginResult;
095import com.unboundid.directory.sdk.ds.types.PreParsePluginResult;
096import com.unboundid.directory.sdk.ds.types.SearchEntryPluginResult;
097import com.unboundid.directory.sdk.ds.types.SearchReferencePluginResult;
098import com.unboundid.directory.sdk.ds.types.StartupDependency;
099import com.unboundid.directory.sdk.ds.types.StartupPluginResult;
100import com.unboundid.directory.sdk.ds.types.SubordinateModifyDNPluginResult;
101import com.unboundid.directory.sdk.metrics.internal.MetricsEngineExtension;
102import com.unboundid.directory.sdk.proxy.internal.DirectoryProxyServerExtension;
103import com.unboundid.directory.sdk.sync.internal.SynchronizationServerExtension;
104import com.unboundid.ldap.sdk.Control;
105import com.unboundid.ldap.sdk.IntermediateResponse;
106import com.unboundid.ldap.sdk.LDAPException;
107import com.unboundid.ldap.sdk.Modification;
108import com.unboundid.ldap.sdk.ResultCode;
109import com.unboundid.util.Extensible;
110import com.unboundid.util.ThreadSafety;
111import com.unboundid.util.ThreadSafetyLevel;
112import com.unboundid.util.args.ArgumentException;
113import com.unboundid.util.args.ArgumentParser;
114
115
116
117/**
118 * This class defines an API that must be implemented by extensions which act as
119 * server plugins.  There are several different kinds of plugins which may be
120 * invoked for different purposes, including:
121 * <UL>
122 *   <LI>startup -- Startup plugins may be used to perform custom processing
123 *       when the server is in the process of staring up.  By default, the
124 *       processing will be performed near the end of the startup phase just
125 *       before the server begins to accept connections from external clients,
126 *       but if one or more startup dependencies are defined, then the plugin
127 *       may be invoked earlier in the startup process as soon as all declared
128 *       dependencies have been satisfied.</LI>
129 *   <LI>shutdown -- Shutdown plugins may be used to perform custom processing
130 *       when the server is in the process of shutting down.  This will occur
131 *       near the beginning of the shutdown process, just after the server stops
132 *       accepting new client connections and terminates existing connections
133 *       but before shutting down any other components.  Note that shutdown
134 *       plugins may not always be invoked in some unusual shutdown scenarios
135 *       (e.g., if the server process is forcefully killed, or in the event of a
136 *       hardware, OS, or JVM failure).</LI>
137 *   <LI>LDIF import -- LDIF import plugins are invoked for each entry read from
138 *       an LDIF file to be imported into a backend.  It is possible to alter
139 *       the contents of the entry or to cause the entry to be excluded from the
140 *       import.</LI>
141 *   <LI>LDIF export -- LDIF export plugins are invoked for each entry exported
142 *       from a backend to be written to an LDIF file.  It is possible to alter
143 *       the contents of the entry or to cause the entry to be excluded from the
144 *       export.</LI>
145 *   <LI>post-connect -- Post-connect plugins are invoked during the course of
146 *       accepting a new client connection.  They may access information about
147 *       the client and may optionally terminate the client connection if it is
148 *       deemed appropriate.</LI>
149 *   <LI>post-disconnect -- Post-disconnect plugins are invoked after a client
150 *       connection has been closed, regardless of whether the closure was
151 *       initiated by the client (e.g., because of an unbind request or simply
152 *       closing the socket) or by the server (e.g., because the connection had
153 *       been idle for too long or because the client violated some server-side
154 *       constraint.</LI>
155 *   <LI>pre-parse -- Pre-parse plugins are invoked just after the server has
156 *       received an abandon, add, bind, compare, delete, extended, modify,
157 *       modify DN, search, or unbind request.  They may be used to obtain
158 *       information about the requests, alter the contents of the request or
159 *       prevent the server from processing the request.
160 *   <LI>pre-operation -- Pre-operation plugins are invoked for add, bind,
161 *       compare, delete, extended, modify, modify DN, and search operations
162 *       after some level of validation has been performed but just before the
163 *       core processing for the operation.  They may not be used to alter the
164 *       request, but they may still be used to obtain information about the
165 *       request or to prevent the operation from being processed.</LI>
166 *   <LI>post-operation -- Post-operation plugins are invoked for add, bind,
167 *       compare, delete, extended, modify, modify DN, and search operations
168 *       after most processing has completed for the operation but before the
169 *       result has been returned to the client.  They may be used to obtain
170 *       information about the result or to alter the contents of the result to
171 *       be returned.</LI>
172 *   <LI>post-response -- Post-response plugins are invoked for add, bind,
173 *       compare, delete, extended, modify, modify DN, and search operations
174 *       after the response has already been sent to the client.  They may be
175 *       used to perform processing for operations without delaying the response
176 *       to the client.</LI>
177 *   <LI>post-replication -- Post-replication plugins are invoked for add,
178 *       delete, modify, and modify DN operations that have been received and
179 *       processed via replication.  They may be used to obtain information or
180 *       perform processing for replicated changes, but may not alter those
181 *       changes.</LI>
182 *   <LI>search result entry -- Search result entry plugins are invoked for each
183 *       entry to be returned to the client during the course of processing a
184 *       search operation.  They may obtain information about the entry to be
185 *       returned, alter the entry contents, or prevent the entry from being
186 *       returned.</LI>
187 *   <LI>search result reference -- Search result reference plugins are invoked
188 *       for each reference to be returned to the client during the course of
189 *       processing a search operation.  They may obtain information about the
190 *       reference to be returned, alter the referral URLs to be returned, or
191 *       prevent the reference from being returned.</LI>
192 *   <LI>subordinate modify DN -- Subordinate modify DN plugins are invoked for
193 *       each entry below the target entry being renamed in the course of a
194 *       modify DN operation.  They may be used to obtain information about the
195 *       subordinate entry to be renamed and optionally to alter the contents
196 *       of that entry.</LI>
197 *   <LI>intermediate response -- Intermediate response plugins are invoked for
198 *       each intermediate response to be returned to the client.  They may be
199 *       used to obtain information about the response or to prevent it from
200 *       being returned to the client.</LI>
201 * </UL>
202 * <BR><BR>
203 * A single plugin instance may be configured to act in any combination of these
204 * contexts.  For example, a plugin may be configured to operate during both
205 * LDIF import and pre-parse add contexts so that it can transform the contents
206 * of entries whether regardless of the way they are inserted into the backend.
207 * <BR>
208 * <H2>Configuring Plugins</H2>
209 * In order to configure a plugin created using this API, use a command like:
210 * <PRE>
211 *      dsconfig create-plugin \
212 *           --plugin-name "<I>{plugin-name}</I>" \
213 *           --type third-party \
214 *           --set enabled:true \
215 *           --set plugin-type:{plugin-type} \
216 *           --set "extension-class:<I>{class-name}</I>" \
217 *           --set "extension-argument:<I>{name=value}</I>"
218 * </PRE>
219 * where "<I>{plugin-name}</I>" is the name to use for the plugin instance,
220 * "<I>{plugin-type}</I>" is the name of a plugin type for which the plugin
221 * should be invoked,  "<I>{class-name}</I>" is the fully-qualified name of the
222 * Java class that extends {@code com.unboundid.directory.sdk.ds.api.Plugin},
223 * and "<I>{name=value}</I>" represents name-value pairs for any arguments to
224 * provide to the plugin.  If the plugin should be invoked for multiple plugin
225 * types, then the "<CODE>--set plugin-type:<I>{plugin-type}</I></CODE>"
226 * option should be provided multiple times.  Similarly, if multiple arguments
227 * should be provided to the plugin, then the
228 * "<CODE>--set extension-argument:<I>{name=value}</I></CODE>" option should be
229 * provided multiple times.
230 *
231 * @see  com.unboundid.directory.sdk.ds.scripting.ScriptedPlugin
232 */
233@Extensible()
234@DirectoryServerExtension()
235@DirectoryProxyServerExtension(appliesToLocalContent=true,
236     appliesToRemoteContent=true,
237     notes="Some plugin types will not be invoked for proxied operations, " +
238          "including pre-operation, post-operation, search result entry, " +
239          "search result reference, intermediate response, and subordinate " +
240          "modify DN.  A proxy transformation may be used to achieve the " +
241          "same result in many cases.")
242@SynchronizationServerExtension(appliesToLocalContent=true,
243     appliesToSynchronizedContent=false,
244     notes="This extension type is primarily useful within the " +
245          "Data Sync Server to have custom code run at server " +
246          "startup or shutdown using the 'startup' and 'shutdown' plugin " +
247          "types.")
248@MetricsEngineExtension(
249     notes="This extension type is primarily useful within the " +
250          "Data Metrics Server to have custom code run at server " +
251          "startup or shutdown using the 'startup' and 'shutdown' plugin " +
252          "types.")
253@BrokerExtension(
254     notes="This extension type is primarily useful within the " +
255          "PingAuthorize Server to have custom code run at server startup " +
256          "or shutdown using the 'startup' and 'shutdown' plugin types.")
257@ThreadSafety(level=ThreadSafetyLevel.INTERFACE_THREADSAFE)
258public abstract class Plugin
259       implements UnboundIDExtension, Reconfigurable<PluginConfig>,
260                  ExampleUsageProvider
261{
262  /**
263   * Creates a new instance of this plugin.  All plugin implementations must
264   * include a default constructor, but any initialization should generally be
265   * done in the {@code initializePlugin} method.
266   */
267  public Plugin()
268  {
269    // No implementation is required.
270  }
271
272
273
274  /**
275   * {@inheritDoc}
276   */
277  public abstract String getExtensionName();
278
279
280
281  /**
282   * {@inheritDoc}
283   */
284  public abstract String[] getExtensionDescription();
285
286
287
288  /**
289   * {@inheritDoc}
290   */
291  public void defineConfigArguments(final ArgumentParser parser)
292         throws ArgumentException
293  {
294    // No arguments will be allowed by default.
295  }
296
297
298
299  /**
300   * Initializes this plugin.
301   *
302   * @param  serverContext  A handle to the server context for the server in
303   *                        which this extension is running.
304   * @param  config         The general configuration for this plugin.
305   * @param  parser         The argument parser which has been initialized from
306   *                        the configuration for this plugin.
307   *
308   * @throws  LDAPException  If a problem occurs while initializing this plugin.
309   */
310  public void initializePlugin(final DirectoryServerContext serverContext,
311                               final PluginConfig config,
312                               final ArgumentParser parser)
313         throws LDAPException
314  {
315    // No initialization will be performed by default.
316  }
317
318
319
320  /**
321   * {@inheritDoc}
322   */
323  public boolean isConfigurationAcceptable(final PluginConfig config,
324                      final ArgumentParser parser,
325                      final List<String> unacceptableReasons)
326  {
327    // No extended validation will be performed by default.
328    return true;
329  }
330
331
332
333  /**
334   * {@inheritDoc}
335   */
336  public ResultCode applyConfiguration(final PluginConfig config,
337                                       final ArgumentParser parser,
338                                       final List<String> adminActionsRequired,
339                                       final List<String> messages)
340  {
341    // By default, no configuration changes will be applied.  If there are any
342    // arguments, then add an admin action message indicating that the extension
343    // needs to be restarted for any changes to take effect.
344    if (! parser.getNamedArguments().isEmpty())
345    {
346      adminActionsRequired.add(
347           "No configuration change has actually been applied.  The new " +
348                "configuration will not take effect until this plugin is " +
349                "disabled and re-enabled or until the server is restarted.");
350    }
351
352    return ResultCode.SUCCESS;
353  }
354
355
356
357  /**
358   * Performs any cleanup which may be necessary when this plugin is to be taken
359   * out of service.
360   */
361  public void finalizePlugin()
362  {
363    // No implementation is required.
364  }
365
366
367
368  /**
369   * Retrieves the set of startup dependencies which must be resolved in order
370   * for this plugin to be invoked at server startup.  This is only applicable
371   * for startup plugins, in which case it may be possible to have the plugin
372   * startup processing invoked as early as possible.  If it returns
373   * {@code null} then startup processing for this plugin will be performed at
374   * the default time during startup.
375   *
376   * @return  The set of startup dependencies for this plugin, or {@code null}
377   *          if it is not a startup plugin, or if startup processing should be
378   *          invoked at the default time during server startup.
379   */
380  public Set<StartupDependency> getStartupDependencies()
381  {
382    return null;
383  }
384
385
386
387  /**
388   * Performs any processing which may be necessary when the server is starting.
389   *
390   * @return  Information about the result of the plugin processing.
391   */
392  public StartupPluginResult doStartup()
393  {
394    // No processing is performed by default.
395    return StartupPluginResult.SUCCESS;
396  }
397
398
399
400  /**
401   * Performs any processing which may be necessary when the server is shutting
402   * down.
403   *
404   * @param  shutdownReason  A message which may provide information about the
405   *                         reason the server is shutting down.
406   */
407  public void doShutdown(final String shutdownReason)
408  {
409    // No processing is performed by default.
410  }
411
412
413
414  /**
415   * Performs any processing which may be necessary for the provided entry to
416   * be imported into the server.
417   *
418   * @param  entry  The entry to be imported.  It may be altered if desired.
419   *
420   * @return  Information about the result of the plugin processing.
421   */
422  public LDIFPluginResult doLDIFImport(final UpdatableEntry entry)
423  {
424    // No processing is performed by default.
425    return LDIFPluginResult.SUCCESS;
426  }
427
428
429
430  /**
431   * Performs any processing which may be necessary for the provided entry to
432   * be exported from the server.
433   *
434   * @param  entry  The entry to be exported.  It may be altered if desired.
435   *
436   * @return  Information about the result of the plugin processing.
437   */
438  public LDIFPluginResult doLDIFExport(final UpdatableEntry entry)
439  {
440    // No processing is performed by default.
441    return LDIFPluginResult.SUCCESS;
442  }
443
444
445
446  /**
447   * Performs any processing which may be necessary when the server has accepted
448   * a new client connection.
449   *
450   * @param  clientContext  Information about the client connection that has
451   *                        been established.
452   *
453   * @return  Information about the result of the plugin processing.
454   */
455  public PostConnectPluginResult doPostConnect(
456                                      final ClientContext clientContext)
457  {
458    // No processing is performed by default.
459    return PostConnectPluginResult.SUCCESS;
460  }
461
462
463
464  /**
465   * Performs any processing which may be necessary when the server has
466   * terminated a client connection.
467   *
468   * @param  clientContext     Information about the client connection that has
469   *                           been established.
470   * @param  disconnectReason  A general reason for the disconnect.
471   * @param  message           A message which may provide additional
472   *                           information about the disconnect.  It may be
473   *                           {@code null} if none is available.
474   *
475   * @return  Information about the result of the plugin processing.
476   */
477  public PostDisconnectPluginResult doPostDisconnect(
478              final ClientContext clientContext,
479              final DisconnectReason disconnectReason, final String message)
480  {
481    // No processing is performed by default.
482    return PostDisconnectPluginResult.SUCCESS;
483  }
484
485
486
487  /**
488   * Performs any processing which may be necessary before the server starts
489   * processing for an abandon request.
490   *
491   * @param  operationContext  The context for the abandon operation.
492   * @param  request           The abandon request to be processed.  It may be
493   *                           altered if desired.
494   *
495   * @return  Information about the result of the plugin processing.
496   */
497  public PreParsePluginResult doPreParse(
498              final ActiveOperationContext operationContext,
499              final UpdatableAbandonRequest request)
500  {
501    // No processing is performed by default.
502    return PreParsePluginResult.SUCCESS;
503  }
504
505
506
507  /**
508   * Performs any processing which may be necessary before the server starts
509   * processing for an add request.  This will be invoked only for add
510   * operations requested directly by clients, but not for add operations
511   * received from another server via replication.
512   *
513   * @param  operationContext  The context for the add operation.
514   * @param  request           The add request to be processed.  It may be
515   *                           altered if desired.
516   * @param  result            The result that will be returned to the client if
517   *                           the plugin result indicates that processing on
518   *                           the operation should be interrupted.  It may be
519   *                           altered if desired.
520   *
521   * @return  Information about the result of the plugin processing.
522   */
523  public PreParsePluginResult doPreParse(
524              final ActiveOperationContext operationContext,
525              final UpdatableAddRequest request,
526              final UpdatableAddResult result)
527  {
528    // No processing is performed by default.
529    return PreParsePluginResult.SUCCESS;
530  }
531
532
533
534  /**
535   * Performs any processing which may be necessary before the server actually
536   * attempts to add an entry to the appropriate backend.  This will be invoked
537   * only for add operations requested directly by clients, but not for add
538   * operations received from another server via replication.
539   *
540   * @param  operationContext  The context for the add operation.
541   * @param  request           The add request to be processed.
542   * @param  result            The result that will be returned to the client if
543   *                           the plugin result indicates that processing on
544   *                           the operation should be interrupted.  It may be
545   *                           altered if desired.
546   *
547   * @return  Information about the result of the plugin processing.
548   */
549  public PreOperationPluginResult doPreOperation(
550              final ActiveOperationContext operationContext,
551              final AddRequest request, final UpdatableAddResult result)
552  {
553    // No processing is performed by default.
554    return PreOperationPluginResult.SUCCESS;
555  }
556
557
558
559  /**
560   * Performs any processing which may be necessary before the server sends a
561   * response for an add operation.  This will be invoked only for add
562   * operations requested directly by clients, but not for add operations
563   * received from another server via replication.
564   *
565   * @param  operationContext  The context for the add operation.
566   * @param  request           The add request that was processed.
567   * @param  result            The result to be returned to the client.  It may
568   *                           be altered if desired.
569   *
570   * @return  Information about the result of the plugin processing.
571   */
572  public PostOperationPluginResult doPostOperation(
573              final ActiveOperationContext operationContext,
574              final AddRequest request, final UpdatableAddResult result)
575  {
576    // No processing is performed by default.
577    return PostOperationPluginResult.SUCCESS;
578  }
579
580
581
582  /**
583   * Performs any processing which may be necessary after all other processing
584   * has been completed for an add operation and the response has been sent to
585   * the client.  This will be invoked only for add operations requested
586   * directly by clients, but not for add operations received from another
587   * server via replication.
588   *
589   * @param  operationContext  The context for the add operation.
590   * @param  request           The add request that was processed.
591   * @param  result            The result that was returned to the client.
592   *
593   * @return  Information about the result of the plugin processing.
594   */
595  public PostResponsePluginResult doPostResponse(
596              final CompletedOperationContext operationContext,
597              final AddRequest request, final AddResult result)
598  {
599    // No processing is performed by default.
600    return PostResponsePluginResult.SUCCESS;
601  }
602
603
604
605  /**
606   * Performs any processing which may be necessary after all other processing
607   * has been completed for an add operation which has been received from
608   * another server via replication.
609   *
610   * @param  operationContext  The context for the add operation.
611   * @param  request           The add request that was processed.
612   * @param  result            The result that was returned to the client.
613   */
614  public void doPostReplication(
615                   final CompletedOperationContext operationContext,
616                   final AddRequest request, final AddResult result)
617  {
618    // No processing is performed by default.
619  }
620
621
622
623  /**
624   * Performs any processing which may be necessary before the server starts
625   * processing for a simple bind request.
626   *
627   * @param  operationContext  The context for the bind operation.
628   * @param  request           The bind request to be processed.  It may be
629   *                           altered if desired.
630   * @param  result            The result that will be returned to the client if
631   *                           the plugin result indicates that processing on
632   *                           the operation should be interrupted.  It may be
633   *                           altered if desired.
634   *
635   * @return  Information about the result of the plugin processing.
636   */
637  public PreParsePluginResult doPreParse(
638              final ActiveOperationContext operationContext,
639              final UpdatableSimpleBindRequest request,
640              final UpdatableBindResult result)
641  {
642    // No processing is performed by default.
643    return PreParsePluginResult.SUCCESS;
644  }
645
646
647
648  /**
649   * Performs any processing which may be necessary before the server actually
650   * attempts to perform the authentication for a simple bind request.
651   *
652   * @param  operationContext  The context for the bind operation.
653   * @param  request           The bind request to be processed.
654   * @param  result            The result that will be returned to the client if
655   *                           the plugin result indicates that processing on
656   *                           the operation should be interrupted.  It may be
657   *                           altered if desired.
658   *
659   * @return  Information about the result of the plugin processing.
660   */
661  public PreOperationPluginResult doPreOperation(
662              final ActiveOperationContext operationContext,
663              final SimpleBindRequest request,
664              final UpdatableBindResult result)
665  {
666    // No processing is performed by default.
667    return PreOperationPluginResult.SUCCESS;
668  }
669
670
671
672  /**
673   * Performs any processing which may be necessary before the server sends a
674   * response for a simple bind operation.
675   *
676   * @param  operationContext  The context for the bind operation.
677   * @param  request           The bind request that was processed.
678   * @param  result            The result to be returned to the client.  It may
679   *                           be altered if desired.
680   *
681   * @return  Information about the result of the plugin processing.
682   */
683  public PostOperationPluginResult doPostOperation(
684              final ActiveOperationContext operationContext,
685              final SimpleBindRequest request, final UpdatableBindResult result)
686  {
687    // No processing is performed by default.
688    return PostOperationPluginResult.SUCCESS;
689  }
690
691
692
693  /**
694   * Performs any processing which may be necessary after all other processing
695   * has been completed for a simple bind operation and the response has been
696   * sent to the client.
697   *
698   * @param  operationContext  The context for the bind operation.
699   * @param  request           The bind request that was processed.
700   * @param  result            The result that was returned to the client.
701   *
702   * @return  Information about the result of the plugin processing.
703   */
704  public PostResponsePluginResult doPostResponse(
705              final CompletedOperationContext operationContext,
706              final SimpleBindRequest request, final BindResult result)
707  {
708    // No processing is performed by default.
709    return PostResponsePluginResult.SUCCESS;
710  }
711
712
713
714  /**
715   * Performs any processing which may be necessary before the server starts
716   * processing for a SASL bind request.
717   *
718   * @param  operationContext  The context for the bind operation.
719   * @param  request           The bind request to be processed.  It may be
720   *                           altered if desired.
721   * @param  result            The result that will be returned to the client if
722   *                           the plugin result indicates that processing on
723   *                           the operation should be interrupted.  It may be
724   *                           altered if desired.
725   *
726   * @return  Information about the result of the plugin processing.
727   */
728  public PreParsePluginResult doPreParse(
729              final ActiveOperationContext operationContext,
730              final UpdatableSASLBindRequest request,
731              final UpdatableBindResult result)
732  {
733    // No processing is performed by default.
734    return PreParsePluginResult.SUCCESS;
735  }
736
737
738
739  /**
740   * Performs any processing which may be necessary before the server actually
741   * attempts to perform the authentication for a SASL bind request.
742   *
743   * @param  operationContext  The context for the bind operation.
744   * @param  request           The bind request to be processed.
745   * @param  result            The result that will be returned to the client if
746   *                           the plugin result indicates that processing on
747   *                           the operation should be interrupted.  It may be
748   *                           altered if desired.
749   *
750   * @return  Information about the result of the plugin processing.
751   */
752  public PreOperationPluginResult doPreOperation(
753              final ActiveOperationContext operationContext,
754              final SASLBindRequest request, final UpdatableBindResult result)
755  {
756    // No processing is performed by default.
757    return PreOperationPluginResult.SUCCESS;
758  }
759
760
761
762  /**
763   * Performs any processing which may be necessary before the server sends a
764   * response for a SASL bind operation.
765   *
766   * @param  operationContext  The context for the bind operation.
767   * @param  request           The bind request that was processed.
768   * @param  result            The result to be returned to the client.  It may
769   *                           be altered if desired.
770   *
771   * @return  Information about the result of the plugin processing.
772   */
773  public PostOperationPluginResult doPostOperation(
774              final ActiveOperationContext operationContext,
775              final SASLBindRequest request, final UpdatableBindResult result)
776  {
777    // No processing is performed by default.
778    return PostOperationPluginResult.SUCCESS;
779  }
780
781
782
783  /**
784   * Performs any processing which may be necessary after all other processing
785   * has been completed for a SASL bind operation and the response has been
786   * sent to the client.
787   *
788   * @param  operationContext  The context for the bind operation.
789   * @param  request           The bind request that was processed.
790   * @param  result            The result that was returned to the client.
791   *
792   * @return  Information about the result of the plugin processing.
793   */
794  public PostResponsePluginResult doPostResponse(
795              final CompletedOperationContext operationContext,
796              final SASLBindRequest request, final BindResult result)
797  {
798    // No processing is performed by default.
799    return PostResponsePluginResult.SUCCESS;
800  }
801
802
803
804  /**
805   * Performs any processing which may be necessary before the server starts
806   * processing for a compare request.
807   *
808   * @param  operationContext  The context for the compare operation.
809   * @param  request           The compare request to be processed.  It may be
810   *                           altered if desired.
811   * @param  result            The result that will be returned to the client if
812   *                           the plugin result indicates that processing on
813   *                           the operation should be interrupted.  It may be
814   *                           altered if desired.
815   *
816   * @return  Information about the result of the plugin processing.
817   */
818  public PreParsePluginResult doPreParse(
819              final ActiveOperationContext operationContext,
820              final UpdatableCompareRequest request,
821              final UpdatableCompareResult result)
822  {
823    // No processing is performed by default.
824    return PreParsePluginResult.SUCCESS;
825  }
826
827
828
829  /**
830   * Performs any processing which may be necessary before the server actually
831   * attempts to perform the core processing for the compare.
832   *
833   * @param  operationContext  The context for the compare operation.
834   * @param  request           The compare request to be processed.
835   * @param  result            The result that will be returned to the client if
836   *                           the plugin result indicates that processing on
837   *                           the operation should be interrupted.  It may be
838   *                           altered if desired.
839   * @param  entry             The entry targeted by the compare operation.
840   *
841   * @return  Information about the result of the plugin processing.
842   */
843  public PreOperationPluginResult doPreOperation(
844              final ActiveOperationContext operationContext,
845              final CompareRequest request, final UpdatableCompareResult result,
846              final Entry entry)
847  {
848    // No processing is performed by default.
849    return PreOperationPluginResult.SUCCESS;
850  }
851
852
853
854  /**
855   * Performs any processing which may be necessary before the server sends a
856   * response for a compare operation.
857   *
858   * @param  operationContext  The context for the compare operation.
859   * @param  request           The compare request that was processed.
860   * @param  result            The result to be returned to the client.  It may
861   *                           be altered if desired.
862   * @param  entry             The entry targeted by the compare operation, if
863   *                           it exists.
864   *
865   * @return  Information about the result of the plugin processing.
866   */
867  public PostOperationPluginResult doPostOperation(
868              final ActiveOperationContext operationContext,
869              final CompareRequest request, final UpdatableCompareResult result,
870              final Entry entry)
871  {
872    // No processing is performed by default.
873    return PostOperationPluginResult.SUCCESS;
874  }
875
876
877
878  /**
879   * Performs any processing which may be necessary after all other processing
880   * has been completed for a compare operation and the response has been sent
881   * to the client.
882   *
883   * @param  operationContext  The context for the compare operation.
884   * @param  request           The compare request that was processed.
885   * @param  result            The result that was returned to the client.
886   *
887   * @return  Information about the result of the plugin processing.
888   */
889  public PostResponsePluginResult doPostResponse(
890              final CompletedOperationContext operationContext,
891              final CompareRequest request, final CompareResult result)
892  {
893    // No processing is performed by default.
894    return PostResponsePluginResult.SUCCESS;
895  }
896
897
898
899  /**
900   * Performs any processing which may be necessary before the server starts
901   * processing for a delete request.  This will be invoked only for delete
902   * operations requested directly by clients, but not for delete operations
903   * received from another server via replication.
904   *
905   * @param  operationContext  The context for the delete operation.
906   * @param  request           The delete request to be processed.  It may be
907   *                           altered if desired.
908   * @param  result            The result that will be returned to the client if
909   *                           the plugin result indicates that processing on
910   *                           the operation should be interrupted.  It may be
911   *                           altered if desired.
912   *
913   * @return  Information about the result of the plugin processing.
914   */
915  public PreParsePluginResult doPreParse(
916              final ActiveOperationContext operationContext,
917              final UpdatableDeleteRequest request,
918              final UpdatableDeleteResult result)
919  {
920    // No processing is performed by default.
921    return PreParsePluginResult.SUCCESS;
922  }
923
924
925
926  /**
927   * Performs any processing which may be necessary before the server actually
928   * attempts to remove the entry from the server.  This will be invoked only
929   * for delete operations requested directly by clients, but not for delete
930   * operations received from another server via replication.
931
932   *
933   * @param  operationContext  The context for the delete operation.
934   * @param  request           The delete request to be processed.
935   * @param  result            The result that will be returned to the client if
936   *                           the plugin result indicates that processing on
937   *                           the operation should be interrupted.  It may be
938   *                           altered if desired.
939   * @param  entry             The entry targeted by the delete operation.
940   *
941   * @return  Information about the result of the plugin processing.
942   */
943  public PreOperationPluginResult doPreOperation(
944              final ActiveOperationContext operationContext,
945              final DeleteRequest request, final UpdatableDeleteResult result,
946              final Entry entry)
947  {
948    // No processing is performed by default.
949    return PreOperationPluginResult.SUCCESS;
950  }
951
952
953
954  /**
955   * Performs any processing which may be necessary before the server sends a
956   * response for a delete operation.  This will be invoked only for delete
957   * operations requested directly by clients, but not for delete operations
958   * received from another server via replication.
959
960   *
961   * @param  operationContext  The context for the delete operation.
962   * @param  request           The delete request that was processed.
963   * @param  result            The result to be returned to the client.  It may
964   *                           be altered if desired.
965   * @param  entry             The entry targeted by the delete operation, if
966   *                           it exists.
967   *
968   * @return  Information about the result of the plugin processing.
969   */
970  public PostOperationPluginResult doPostOperation(
971              final ActiveOperationContext operationContext,
972              final DeleteRequest request, final UpdatableDeleteResult result,
973              final Entry entry)
974  {
975    // No processing is performed by default.
976    return PostOperationPluginResult.SUCCESS;
977  }
978
979
980
981  /**
982   * Performs any processing which may be necessary after all other processing
983   * has been completed for a delete operation and the response has been sent
984   * to the client.  This will be invoked only for delete operations requested
985   * directly by clients, but not for delete operations received from another
986   * server via replication.
987
988   *
989   * @param  operationContext  The context for the delete operation.
990   * @param  request           The delete request that was processed.
991   * @param  result            The result that was returned to the client.
992   *
993   * @return  Information about the result of the plugin processing.
994   */
995  public PostResponsePluginResult doPostResponse(
996              final CompletedOperationContext operationContext,
997              final DeleteRequest request, final DeleteResult result)
998  {
999    // No processing is performed by default.
1000    return PostResponsePluginResult.SUCCESS;
1001  }
1002
1003
1004
1005  /**
1006   * Performs any processing which may be necessary after all other processing
1007   * has been completed for a delete operation which has been received from
1008   * another server via replication.
1009   *
1010   * @param  operationContext  The context for the delete operation.
1011   * @param  request           The delete request that was processed.
1012   * @param  result            The result that was returned to the client.
1013   */
1014  public void doPostReplication(
1015                   final CompletedOperationContext operationContext,
1016                   final DeleteRequest request, final DeleteResult result)
1017  {
1018    // No processing is performed by default.
1019  }
1020
1021
1022
1023  /**
1024   * Performs any processing which may be necessary before the server starts
1025   * processing for an extended request.
1026   *
1027   * @param  operationContext  The context for the extended operation.
1028   * @param  request           The extended request to be processed.  It may be
1029   *                           altered if desired.
1030   * @param  result            The result that will be returned to the client if
1031   *                           the plugin result indicates that processing on
1032   *                           the operation should be interrupted.  It may be
1033   *                           altered if desired.
1034   *
1035   * @return  Information about the result of the plugin processing.
1036   */
1037  public PreParsePluginResult doPreParse(
1038              final ActiveOperationContext operationContext,
1039              final UpdatableExtendedRequest request,
1040              final UpdatableExtendedResult result)
1041  {
1042    // No processing is performed by default.
1043    return PreParsePluginResult.SUCCESS;
1044  }
1045
1046
1047
1048  /**
1049   * Performs any processing which may be necessary before the server actually
1050   * attempts to perform the core processing for the extended operation.
1051   *
1052   * @param  operationContext  The context for the extended operation.
1053   * @param  request           The extended request to be processed.
1054   * @param  result            The result that will be returned to the client if
1055   *                           the plugin result indicates that processing on
1056   *                           the operation should be interrupted.  It may be
1057   *                           altered if desired.
1058   *
1059   * @return  Information about the result of the plugin processing.
1060   */
1061  public PreOperationPluginResult doPreOperation(
1062              final ActiveOperationContext operationContext,
1063              final ExtendedRequest request,
1064              final UpdatableExtendedResult result)
1065  {
1066    // No processing is performed by default.
1067    return PreOperationPluginResult.SUCCESS;
1068  }
1069
1070
1071
1072  /**
1073   * Performs any processing which may be necessary before the server sends a
1074   * response for an extended operation.
1075   *
1076   * @param  operationContext  The context for the extended operation.
1077   * @param  request           The extended request that was processed.
1078   * @param  result            The result to be returned to the client.  It may
1079   *                           be altered if desired.
1080   *
1081   * @return  Information about the result of the plugin processing.
1082   */
1083  public PostOperationPluginResult doPostOperation(
1084              final ActiveOperationContext operationContext,
1085              final ExtendedRequest request,
1086              final UpdatableExtendedResult result)
1087  {
1088    // No processing is performed by default.
1089    return PostOperationPluginResult.SUCCESS;
1090  }
1091
1092
1093
1094  /**
1095   * Performs any processing which may be necessary after all other processing
1096   * has been completed for an extended operation and the response has been sent
1097   * to the client.
1098   *
1099   * @param  operationContext  The context for the extended operation.
1100   * @param  request           The extended request that was processed.
1101   * @param  result            The result that was returned to the client.
1102   *
1103   * @return  Information about the result of the plugin processing.
1104   */
1105  public PostResponsePluginResult doPostResponse(
1106              final CompletedOperationContext operationContext,
1107              final ExtendedRequest request, final ExtendedResult result)
1108  {
1109    // No processing is performed by default.
1110    return PostResponsePluginResult.SUCCESS;
1111  }
1112
1113
1114
1115  /**
1116   * Performs any processing which may be necessary before the server starts
1117   * processing for a modify request.  This will be invoked only for modify
1118   * operations requested directly by clients, but not for modify operations
1119   * received from another server via replication.
1120   *
1121   * @param  operationContext  The context for the modify operation.
1122   * @param  request           The modify request to be processed.  It may be
1123   *                           altered if desired.
1124   * @param  result            The result that will be returned to the client if
1125   *                           the plugin result indicates that processing on
1126   *                           the operation should be interrupted.  It may be
1127   *                           altered if desired.
1128   *
1129   * @return  Information about the result of the plugin processing.
1130   */
1131  public PreParsePluginResult doPreParse(
1132              final ActiveOperationContext operationContext,
1133              final UpdatableModifyRequest request,
1134              final UpdatableModifyResult result)
1135  {
1136    // No processing is performed by default.
1137    return PreParsePluginResult.SUCCESS;
1138  }
1139
1140
1141
1142  /**
1143   * Performs any processing which may be necessary before the server actually
1144   * attempts to update the entry in the backend.  This will be invoked only for
1145   * modify operations requested directly by clients, but not for modify
1146   * operations received from another server via replication.
1147   *
1148   * @param  operationContext  The context for the modify operation.
1149   * @param  request           The modify request to be processed.
1150   * @param  result            The result that will be returned to the client if
1151   *                           the plugin result indicates that processing on
1152   *                           the operation should be interrupted.  It may be
1153   *                           altered if desired.
1154   * @param  oldEntry          The entry as it appeared before the modifications
1155   *                           were applied.
1156   * @param  newEntry          The updated entry as it will appear after the
1157   *                           modifications have been applied.
1158   *
1159   * @return  Information about the result of the plugin processing.
1160   */
1161  public PreOperationPluginResult doPreOperation(
1162              final ActiveOperationContext operationContext,
1163              final ModifyRequest request, final UpdatableModifyResult result,
1164              final Entry oldEntry, final Entry newEntry)
1165  {
1166    // No processing is performed by default.
1167    return PreOperationPluginResult.SUCCESS;
1168  }
1169
1170
1171
1172  /**
1173   * Performs any processing which may be necessary before the server sends a
1174   * response for a modify operation.  This will be invoked only for modify
1175   * operations requested directly by clients, but not for modify operations
1176   * received from another server via replication.
1177   *
1178   * @param  operationContext  The context for the modify operation.
1179   * @param  request           The modify request that was processed.
1180   * @param  result            The result to be returned to the client.  It may
1181   *                           be altered if desired.
1182   * @param  oldEntry          The entry as it appeared before the modifications
1183   *                           were applied, if it exists. .
1184   * @param  newEntry          The entry as it appears after the modifications
1185   *                           have been applied, if it exists. .
1186   *
1187   * @return  Information about the result of the plugin processing.
1188   */
1189  public PostOperationPluginResult doPostOperation(
1190              final ActiveOperationContext operationContext,
1191              final ModifyRequest request, final UpdatableModifyResult result,
1192              final Entry oldEntry, final Entry newEntry)
1193  {
1194    // No processing is performed by default.
1195    return PostOperationPluginResult.SUCCESS;
1196  }
1197
1198
1199
1200  /**
1201   * Performs any processing which may be necessary after all other processing
1202   * has been completed for a modify operation and the response has been sent
1203   * to the client.  This will be invoked only for modify operations requested
1204   * directly by clients, but not for modify operations received from another
1205   * server via replication.
1206   *
1207   * @param  operationContext  The context for the modify operation.
1208   * @param  request           The modify request that was processed.
1209   * @param  result            The result that was returned to the client.
1210   *
1211   * @return  Information about the result of the plugin processing.
1212   */
1213  public PostResponsePluginResult doPostResponse(
1214              final CompletedOperationContext operationContext,
1215              final ModifyRequest request, final ModifyResult result)
1216  {
1217    // No processing is performed by default.
1218    return PostResponsePluginResult.SUCCESS;
1219  }
1220
1221
1222
1223  /**
1224   * Performs any processing which may be necessary after all other processing
1225   * has been completed for a modify operation which has been received from
1226   * another server via replication.
1227   *
1228   * @param  operationContext  The context for the modify operation.
1229   * @param  request           The modify request that was processed.
1230   * @param  result            The result that was returned to the client.
1231   */
1232  public void doPostReplication(
1233                   final CompletedOperationContext operationContext,
1234                   final ModifyRequest request, final ModifyResult result)
1235  {
1236    // No processing is performed by default.
1237  }
1238
1239
1240
1241  /**
1242   * Performs any processing which may be necessary before the server starts
1243   * processing for a modify DN request.  This will be invoked only for modify
1244   * DN operations requested directly by clients, but not for modify DN
1245   * operations received from another server via replication.
1246   *
1247   * @param  operationContext  The context for the modify DN operation.
1248   * @param  request           The modify DN request to be processed.  It may be
1249   *                           altered if desired.
1250   * @param  result            The result that will be returned to the client if
1251   *                           the plugin result indicates that processing on
1252   *                           the operation should be interrupted.  It may be
1253   *                           altered if desired.
1254   *
1255   * @return  Information about the result of the plugin processing.
1256   */
1257  public PreParsePluginResult doPreParse(
1258              final ActiveOperationContext operationContext,
1259              final UpdatableModifyDNRequest request,
1260              final UpdatableModifyDNResult result)
1261  {
1262    // No processing is performed by default.
1263    return PreParsePluginResult.SUCCESS;
1264  }
1265
1266
1267
1268  /**
1269   * Performs any processing which may be necessary before the server actually
1270   * attempts to update the entry in the backend.  This will be invoked only for
1271   * modify DN operations requested directly by clients, but not for modify DN
1272   * operations received from another server via replication.
1273   *
1274   * @param  operationContext  The context for the modify DN operation.
1275   * @param  request           The modify DN request to be processed.
1276   * @param  result            The result that will be returned to the client if
1277   *                           the plugin result indicates that processing on
1278   *                           the operation should be interrupted.  It may be
1279   *                           altered if desired.
1280   * @param  oldEntry          The entry as it appeared before being renamed.
1281   * @param  newEntry          The updated entry as it will appear after it has
1282   *                           been renamed.
1283   *
1284   * @return  Information about the result of the plugin processing.
1285   */
1286  public PreOperationPluginResult doPreOperation(
1287              final ActiveOperationContext operationContext,
1288              final ModifyDNRequest request,
1289              final UpdatableModifyDNResult result, final Entry oldEntry,
1290              final Entry newEntry)
1291  {
1292    // No processing is performed by default.
1293    return PreOperationPluginResult.SUCCESS;
1294  }
1295
1296
1297
1298  /**
1299   * Performs any processing which may be necessary during the course of
1300   * renaming an entry which is subordinate to an entry targeted by a modify DN
1301   * operation.  This will be invoked only for both modify DN operations
1302   * requested by clients and for modify DN operations received from another
1303   * server via replication.
1304   *
1305   * @param  operationContext         The context for the modify DN operation.
1306   * @param  request                  The modify DN request being processed.
1307   * @param  result                   The result that will be returned to the
1308   *                                  client if the plugin result indicates that
1309   *                                  processing on the operation should be
1310   *                                  interrupted.  It may be altered if
1311   *                                  desired.
1312   * @param  oldSubordinateEntry      The subordinate entry as it appeared
1313   *                                  before being renamed.
1314   * @param  newSubordinateEntry      The subordinate entry as it will appear
1315   *                                  after being renamed.
1316   * @param  additionalModifications  A list of additional modifications that
1317   *                                  should be applied to the entry as it is
1318   *                                  renamed.  This list may be altered if
1319   *                                  desired.
1320   *
1321   * @return  Information about the result of the plugin processing.
1322   */
1323  public SubordinateModifyDNPluginResult doSubordinateModifyDN(
1324              final ActiveOperationContext operationContext,
1325              final ModifyDNRequest request,
1326              final UpdatableModifyDNResult result,
1327              final Entry oldSubordinateEntry,
1328              final Entry newSubordinateEntry,
1329              final List<Modification> additionalModifications)
1330  {
1331    // No processing is performed by default.
1332    return SubordinateModifyDNPluginResult.SUCCESS;
1333  }
1334
1335
1336
1337  /**
1338   * Performs any processing which may be necessary before the server sends a
1339   * response for a modify DN operation.  This will be invoked only for modify
1340   * DN operations requested directly by clients, but not for modify DN
1341   * operations received from another server via replication.
1342   *
1343   * @param  operationContext  The context for the modify DN operation.
1344   * @param  request           The modify DN request that was processed.
1345   * @param  result            The result to be returned to the client.  It may
1346   *                           be altered if desired.
1347   * @param  oldEntry          The entry as it appeared before it was renamed,
1348   *                           if it exists.
1349   * @param  newEntry          The entry as it appears after it was renamed, if
1350   *                           it exists. .
1351   *
1352   * @return  Information about the result of the plugin processing.
1353   */
1354  public PostOperationPluginResult doPostOperation(
1355              final ActiveOperationContext operationContext,
1356              final ModifyDNRequest request,
1357              final UpdatableModifyDNResult result, final Entry oldEntry,
1358              final Entry newEntry)
1359  {
1360    // No processing is performed by default.
1361    return PostOperationPluginResult.SUCCESS;
1362  }
1363
1364
1365
1366  /**
1367   * Performs any processing which may be necessary after all other processing
1368   * has been completed for a modify DN operation and the response has been
1369   * sent to the client.  This will be invoked only for modify DN operations
1370   * requested directly by clients, but not for modify DN operations received
1371   * from another server via replication.
1372   *
1373   * @param  operationContext  The context for the modify DN operation.
1374   * @param  request           The modify DN request that was processed.
1375   * @param  result            The result that was returned to the client.
1376   *
1377   * @return  Information about the result of the plugin processing.
1378   */
1379  public PostResponsePluginResult doPostResponse(
1380              final CompletedOperationContext operationContext,
1381              final ModifyDNRequest request, final ModifyDNResult result)
1382  {
1383    // No processing is performed by default.
1384    return PostResponsePluginResult.SUCCESS;
1385  }
1386
1387
1388
1389  /**
1390   * Performs any processing which may be necessary after all other processing
1391   * has been completed for a modify DN operation which has been received from
1392   * another server via replication.
1393   *
1394   * @param  operationContext  The context for the modify DN operation.
1395   * @param  request           The modify DN request that was processed.
1396   * @param  result            The result that was returned to the client.
1397   */
1398  public void doPostReplication(
1399                   final CompletedOperationContext operationContext,
1400                   final ModifyDNRequest request, final ModifyDNResult result)
1401  {
1402    // No processing is performed by default.
1403  }
1404
1405
1406
1407  /**
1408   * Performs any processing which may be necessary before the server starts
1409   * processing for a search request.
1410   *
1411   * @param  operationContext  The context for the search operation.
1412   * @param  request           The search request to be processed.  It may be
1413   *                           altered if desired.
1414   * @param  result            The result that will be returned to the client if
1415   *                           the plugin result indicates that processing on
1416   *                           the operation should be interrupted.  It may be
1417   *                           altered if desired.
1418   *
1419   * @return  Information about the result of the plugin processing.
1420   */
1421  public PreParsePluginResult doPreParse(
1422              final ActiveSearchOperationContext operationContext,
1423              final UpdatableSearchRequest request,
1424              final UpdatableSearchResult result)
1425  {
1426    // No processing is performed by default.
1427    return PreParsePluginResult.SUCCESS;
1428  }
1429
1430
1431
1432  /**
1433   * Performs any processing which may be necessary before the server actually
1434   * attempts to process the search in the backend.
1435   *
1436   * @param  operationContext  The context for the search operation.
1437   * @param  request           The search request to be processed.
1438   * @param  result            The result that will be returned to the client if
1439   *                           the plugin result indicates that processing on
1440   *                           the operation should be interrupted.  It may be
1441   *                           altered if desired.
1442   *
1443   * @return  Information about the result of the plugin processing.
1444   */
1445  public PreOperationPluginResult doPreOperation(
1446              final ActiveSearchOperationContext operationContext,
1447              final SearchRequest request, final UpdatableSearchResult result)
1448  {
1449    // No processing is performed by default.
1450    return PreOperationPluginResult.SUCCESS;
1451  }
1452
1453
1454
1455  /**
1456   * Performs any processing which may be necessary before the server sends a
1457   * search result entry to the client.
1458   *
1459   * @param  operationContext  The context for the search operation.
1460   * @param  request           The search request being processed.
1461   * @param  result            The result that will be returned to the client if
1462   *                           the plugin result indicates that processing on
1463   *                           the operation should be interrupted.  It may be
1464   *                           altered if desired.
1465   * @param  entry             The entry to be returned to the client.  It may
1466   *                           be altered if desired.
1467   * @param  controls          The set of controls to be included with the
1468   *                           entry.  It may be altered if desired.
1469   *
1470   * @return  Information about the result of the plugin processing.
1471   */
1472  public SearchEntryPluginResult doSearchEntry(
1473              final ActiveSearchOperationContext operationContext,
1474              final SearchRequest request, final UpdatableSearchResult result,
1475              final UpdatableEntry entry, final List<Control> controls)
1476  {
1477    // No processing is performed by default.
1478    return SearchEntryPluginResult.SUCCESS;
1479  }
1480
1481
1482
1483  /**
1484   * Performs any processing which may be necessary before the server sends a
1485   * search result reference to the client.
1486   *
1487   * @param  operationContext  The context for the search operation.
1488   * @param  request           The search request being processed.
1489   * @param  result            The result that will be returned to the client if
1490   *                           the plugin result indicates that processing on
1491   *                           the operation should be interrupted.  It may be
1492   *                           altered if desired.
1493   * @param  referralURLs      The set of referral URLs to be returned to the
1494   *                           client.  It may be altered if desired.
1495   * @param  controls          The set of controls to be included with the
1496   *                           reference.  It may be altered if desired.
1497   *
1498   * @return  Information about the result of the plugin processing.
1499   */
1500  public SearchReferencePluginResult doSearchReference(
1501              final ActiveSearchOperationContext operationContext,
1502              final SearchRequest request, final UpdatableSearchResult result,
1503              final List<String> referralURLs, final List<Control> controls)
1504  {
1505    // No processing is performed by default.
1506    return SearchReferencePluginResult.SUCCESS;
1507  }
1508
1509
1510
1511  /**
1512   * Performs any processing which may be necessary before the server sends a
1513   * response for a search operation.
1514   *
1515   * @param  operationContext  The context for the search operation.
1516   * @param  request           The search request that was processed.
1517   * @param  result            The result to be returned to the client.  It may
1518   *                           be altered if desired.
1519   *
1520   * @return  Information about the result of the plugin processing.
1521   */
1522  public PostOperationPluginResult doPostOperation(
1523              final ActiveSearchOperationContext operationContext,
1524              final SearchRequest request, final UpdatableSearchResult result)
1525  {
1526    // No processing is performed by default.
1527    return PostOperationPluginResult.SUCCESS;
1528  }
1529
1530
1531
1532  /**
1533   * Performs any processing which may be necessary after all other processing
1534   * has been completed for a search operation and the response has been sent to
1535   * the client.
1536   *
1537   * @param  operationContext  The context for the search operation.
1538   * @param  request           The search request that was processed.
1539   * @param  result            The result that was returned to the client.
1540   *
1541   * @return  Information about the result of the plugin processing.
1542   */
1543  public PostResponsePluginResult doPostResponse(
1544              final CompletedSearchOperationContext operationContext,
1545              final SearchRequest request, final SearchResult result)
1546  {
1547    // No processing is performed by default.
1548    return PostResponsePluginResult.SUCCESS;
1549  }
1550
1551
1552
1553  /**
1554   * Performs any processing which may be necessary before the server starts
1555   * processing for an unbind request.
1556   *
1557   * @param  operationContext  The context for the unbind operation.
1558   * @param  request           The unbind request to be processed.  It may be
1559   *                           altered if desired.
1560   *
1561   * @return  Information about the result of the plugin processing.
1562   */
1563  public PreParsePluginResult doPreParse(
1564              final ActiveOperationContext operationContext,
1565              final UpdatableUnbindRequest request)
1566  {
1567    // No processing is performed by default.
1568    return PreParsePluginResult.SUCCESS;
1569  }
1570
1571
1572
1573  /**
1574   * Performs any processing which may be necessary before the server sends an
1575   * intermediate response to the client.
1576   *
1577   * @param  operationContext      The context for the associated operation.
1578   * @param  result                The result that will be returned to the
1579   *                               client if the plugin result indicates that
1580   *                               processing on the operation should be
1581   *                               interrupted.  It may be altered if desired.
1582   * @param  intermediateResponse  The intermediate response to be returned to
1583   *                               the client.  It may be altered if desired.
1584   *
1585   * @return  Information about the result of the plugin processing.
1586   */
1587  public IntermediateResponsePluginResult doIntermediateResponse(
1588              final ActiveOperationContext operationContext,
1589              final UpdatableGenericResult result,
1590              final IntermediateResponse intermediateResponse)
1591  {
1592    // No processing is performed by default.
1593    return IntermediateResponsePluginResult.SUCCESS;
1594  }
1595
1596
1597
1598  /**
1599   * {@inheritDoc}
1600   */
1601  public Map<List<String>,String> getExamplesArgumentSets()
1602  {
1603    return Collections.emptyMap();
1604  }
1605}