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 *      Copyright 2010-2018 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          "Synchronization Server to have custom code run at server startup " +
246          "or shutdown using the 'startup' and 'shutdown' plugin types.")
247@MetricsEngineExtension(
248     notes="This extension type is primarily useful within the " +
249          "Metrics Engine to have custom code run at server startup " +
250          "or shutdown using the 'startup' and 'shutdown' plugin types.")
251@BrokerExtension(
252     notes="This extension type is primarily useful within the " +
253          "Broker to have custom code run at server startup " +
254          "or shutdown using the 'startup' and 'shutdown' plugin types.")
255@ThreadSafety(level=ThreadSafetyLevel.INTERFACE_THREADSAFE)
256public abstract class Plugin
257       implements UnboundIDExtension, Reconfigurable<PluginConfig>,
258                  ExampleUsageProvider
259{
260  /**
261   * Creates a new instance of this plugin.  All plugin implementations must
262   * include a default constructor, but any initialization should generally be
263   * done in the {@code initializePlugin} method.
264   */
265  public Plugin()
266  {
267    // No implementation is required.
268  }
269
270
271
272  /**
273   * {@inheritDoc}
274   */
275  public abstract String getExtensionName();
276
277
278
279  /**
280   * {@inheritDoc}
281   */
282  public abstract String[] getExtensionDescription();
283
284
285
286  /**
287   * {@inheritDoc}
288   */
289  public void defineConfigArguments(final ArgumentParser parser)
290         throws ArgumentException
291  {
292    // No arguments will be allowed by default.
293  }
294
295
296
297  /**
298   * Initializes this plugin.
299   *
300   * @param  serverContext  A handle to the server context for the server in
301   *                        which this extension is running.
302   * @param  config         The general configuration for this plugin.
303   * @param  parser         The argument parser which has been initialized from
304   *                        the configuration for this plugin.
305   *
306   * @throws  LDAPException  If a problem occurs while initializing this plugin.
307   */
308  public void initializePlugin(final DirectoryServerContext serverContext,
309                               final PluginConfig config,
310                               final ArgumentParser parser)
311         throws LDAPException
312  {
313    // No initialization will be performed by default.
314  }
315
316
317
318  /**
319   * {@inheritDoc}
320   */
321  public boolean isConfigurationAcceptable(final PluginConfig config,
322                      final ArgumentParser parser,
323                      final List<String> unacceptableReasons)
324  {
325    // No extended validation will be performed by default.
326    return true;
327  }
328
329
330
331  /**
332   * {@inheritDoc}
333   */
334  public ResultCode applyConfiguration(final PluginConfig config,
335                                       final ArgumentParser parser,
336                                       final List<String> adminActionsRequired,
337                                       final List<String> messages)
338  {
339    // By default, no configuration changes will be applied.  If there are any
340    // arguments, then add an admin action message indicating that the extension
341    // needs to be restarted for any changes to take effect.
342    if (! parser.getNamedArguments().isEmpty())
343    {
344      adminActionsRequired.add(
345           "No configuration change has actually been applied.  The new " +
346                "configuration will not take effect until this plugin is " +
347                "disabled and re-enabled or until the server is restarted.");
348    }
349
350    return ResultCode.SUCCESS;
351  }
352
353
354
355  /**
356   * Performs any cleanup which may be necessary when this plugin is to be taken
357   * out of service.
358   */
359  public void finalizePlugin()
360  {
361    // No implementation is required.
362  }
363
364
365
366  /**
367   * Retrieves the set of startup dependencies which must be resolved in order
368   * for this plugin to be invoked at server startup.  This is only applicable
369   * for startup plugins, in which case it may be possible to have the plugin
370   * startup processing invoked as early as possible.  If it returns
371   * {@code null} then startup processing for this plugin will be performed at
372   * the default time during startup.
373   *
374   * @return  The set of startup dependencies for this plugin, or {@code null}
375   *          if it is not a startup plugin, or if startup processing should be
376   *          invoked at the default time during server startup.
377   */
378  public Set<StartupDependency> getStartupDependencies()
379  {
380    return null;
381  }
382
383
384
385  /**
386   * Performs any processing which may be necessary when the server is starting.
387   *
388   * @return  Information about the result of the plugin processing.
389   */
390  public StartupPluginResult doStartup()
391  {
392    // No processing is performed by default.
393    return StartupPluginResult.SUCCESS;
394  }
395
396
397
398  /**
399   * Performs any processing which may be necessary when the server is shutting
400   * down.
401   *
402   * @param  shutdownReason  A message which may provide information about the
403   *                         reason the server is shutting down.
404   */
405  public void doShutdown(final String shutdownReason)
406  {
407    // No processing is performed by default.
408  }
409
410
411
412  /**
413   * Performs any processing which may be necessary for the provided entry to
414   * be imported into the server.
415   *
416   * @param  entry  The entry to be imported.  It may be altered if desired.
417   *
418   * @return  Information about the result of the plugin processing.
419   */
420  public LDIFPluginResult doLDIFImport(final UpdatableEntry entry)
421  {
422    // No processing is performed by default.
423    return LDIFPluginResult.SUCCESS;
424  }
425
426
427
428  /**
429   * Performs any processing which may be necessary for the provided entry to
430   * be exported from the server.
431   *
432   * @param  entry  The entry to be exported.  It may be altered if desired.
433   *
434   * @return  Information about the result of the plugin processing.
435   */
436  public LDIFPluginResult doLDIFExport(final UpdatableEntry entry)
437  {
438    // No processing is performed by default.
439    return LDIFPluginResult.SUCCESS;
440  }
441
442
443
444  /**
445   * Performs any processing which may be necessary when the server has accepted
446   * a new client connection.
447   *
448   * @param  clientContext  Information about the client connection that has
449   *                        been established.
450   *
451   * @return  Information about the result of the plugin processing.
452   */
453  public PostConnectPluginResult doPostConnect(
454                                      final ClientContext clientContext)
455  {
456    // No processing is performed by default.
457    return PostConnectPluginResult.SUCCESS;
458  }
459
460
461
462  /**
463   * Performs any processing which may be necessary when the server has
464   * terminated a client connection.
465   *
466   * @param  clientContext     Information about the client connection that has
467   *                           been established.
468   * @param  disconnectReason  A general reason for the disconnect.
469   * @param  message           A message which may provide additional
470   *                           information about the disconnect.  It may be
471   *                           {@code null} if none is available.
472   *
473   * @return  Information about the result of the plugin processing.
474   */
475  public PostDisconnectPluginResult doPostDisconnect(
476              final ClientContext clientContext,
477              final DisconnectReason disconnectReason, final String message)
478  {
479    // No processing is performed by default.
480    return PostDisconnectPluginResult.SUCCESS;
481  }
482
483
484
485  /**
486   * Performs any processing which may be necessary before the server starts
487   * processing for an abandon request.
488   *
489   * @param  operationContext  The context for the abandon operation.
490   * @param  request           The abandon request to be processed.  It may be
491   *                           altered if desired.
492   *
493   * @return  Information about the result of the plugin processing.
494   */
495  public PreParsePluginResult doPreParse(
496              final ActiveOperationContext operationContext,
497              final UpdatableAbandonRequest request)
498  {
499    // No processing is performed by default.
500    return PreParsePluginResult.SUCCESS;
501  }
502
503
504
505  /**
506   * Performs any processing which may be necessary before the server starts
507   * processing for an add request.  This will be invoked only for add
508   * operations requested directly by clients, but not for add operations
509   * received from another server via replication.
510   *
511   * @param  operationContext  The context for the add operation.
512   * @param  request           The add request to be processed.  It may be
513   *                           altered if desired.
514   * @param  result            The result that will be returned to the client if
515   *                           the plugin result indicates that processing on
516   *                           the operation should be interrupted.  It may be
517   *                           altered if desired.
518   *
519   * @return  Information about the result of the plugin processing.
520   */
521  public PreParsePluginResult doPreParse(
522              final ActiveOperationContext operationContext,
523              final UpdatableAddRequest request,
524              final UpdatableAddResult result)
525  {
526    // No processing is performed by default.
527    return PreParsePluginResult.SUCCESS;
528  }
529
530
531
532  /**
533   * Performs any processing which may be necessary before the server actually
534   * attempts to add an entry to the appropriate backend.  This will be invoked
535   * only for add operations requested directly by clients, but not for add
536   * operations received from another server via replication.
537   *
538   * @param  operationContext  The context for the add operation.
539   * @param  request           The add request to be processed.
540   * @param  result            The result that will be returned to the client if
541   *                           the plugin result indicates that processing on
542   *                           the operation should be interrupted.  It may be
543   *                           altered if desired.
544   *
545   * @return  Information about the result of the plugin processing.
546   */
547  public PreOperationPluginResult doPreOperation(
548              final ActiveOperationContext operationContext,
549              final AddRequest request, final UpdatableAddResult result)
550  {
551    // No processing is performed by default.
552    return PreOperationPluginResult.SUCCESS;
553  }
554
555
556
557  /**
558   * Performs any processing which may be necessary before the server sends a
559   * response for an add operation.  This will be invoked only for add
560   * operations requested directly by clients, but not for add operations
561   * received from another server via replication.
562   *
563   * @param  operationContext  The context for the add operation.
564   * @param  request           The add request that was processed.
565   * @param  result            The result to be returned to the client.  It may
566   *                           be altered if desired.
567   *
568   * @return  Information about the result of the plugin processing.
569   */
570  public PostOperationPluginResult doPostOperation(
571              final ActiveOperationContext operationContext,
572              final AddRequest request, final UpdatableAddResult result)
573  {
574    // No processing is performed by default.
575    return PostOperationPluginResult.SUCCESS;
576  }
577
578
579
580  /**
581   * Performs any processing which may be necessary after all other processing
582   * has been completed for an add operation and the response has been sent to
583   * the client.  This will be invoked only for add operations requested
584   * directly by clients, but not for add operations received from another
585   * server via replication.
586   *
587   * @param  operationContext  The context for the add operation.
588   * @param  request           The add request that was processed.
589   * @param  result            The result that was returned to the client.
590   *
591   * @return  Information about the result of the plugin processing.
592   */
593  public PostResponsePluginResult doPostResponse(
594              final CompletedOperationContext operationContext,
595              final AddRequest request, final AddResult result)
596  {
597    // No processing is performed by default.
598    return PostResponsePluginResult.SUCCESS;
599  }
600
601
602
603  /**
604   * Performs any processing which may be necessary after all other processing
605   * has been completed for an add operation which has been received from
606   * another server via replication.
607   *
608   * @param  operationContext  The context for the add operation.
609   * @param  request           The add request that was processed.
610   * @param  result            The result that was returned to the client.
611   */
612  public void doPostReplication(
613                   final CompletedOperationContext operationContext,
614                   final AddRequest request, final AddResult result)
615  {
616    // No processing is performed by default.
617  }
618
619
620
621  /**
622   * Performs any processing which may be necessary before the server starts
623   * processing for a simple bind request.
624   *
625   * @param  operationContext  The context for the bind operation.
626   * @param  request           The bind request to be processed.  It may be
627   *                           altered if desired.
628   * @param  result            The result that will be returned to the client if
629   *                           the plugin result indicates that processing on
630   *                           the operation should be interrupted.  It may be
631   *                           altered if desired.
632   *
633   * @return  Information about the result of the plugin processing.
634   */
635  public PreParsePluginResult doPreParse(
636              final ActiveOperationContext operationContext,
637              final UpdatableSimpleBindRequest request,
638              final UpdatableBindResult result)
639  {
640    // No processing is performed by default.
641    return PreParsePluginResult.SUCCESS;
642  }
643
644
645
646  /**
647   * Performs any processing which may be necessary before the server actually
648   * attempts to perform the authentication for a simple bind request.
649   *
650   * @param  operationContext  The context for the bind operation.
651   * @param  request           The bind request to be processed.
652   * @param  result            The result that will be returned to the client if
653   *                           the plugin result indicates that processing on
654   *                           the operation should be interrupted.  It may be
655   *                           altered if desired.
656   *
657   * @return  Information about the result of the plugin processing.
658   */
659  public PreOperationPluginResult doPreOperation(
660              final ActiveOperationContext operationContext,
661              final SimpleBindRequest request,
662              final UpdatableBindResult result)
663  {
664    // No processing is performed by default.
665    return PreOperationPluginResult.SUCCESS;
666  }
667
668
669
670  /**
671   * Performs any processing which may be necessary before the server sends a
672   * response for a simple bind operation.
673   *
674   * @param  operationContext  The context for the bind operation.
675   * @param  request           The bind request that was processed.
676   * @param  result            The result to be returned to the client.  It may
677   *                           be altered if desired.
678   *
679   * @return  Information about the result of the plugin processing.
680   */
681  public PostOperationPluginResult doPostOperation(
682              final ActiveOperationContext operationContext,
683              final SimpleBindRequest request, final UpdatableBindResult result)
684  {
685    // No processing is performed by default.
686    return PostOperationPluginResult.SUCCESS;
687  }
688
689
690
691  /**
692   * Performs any processing which may be necessary after all other processing
693   * has been completed for a simple bind operation and the response has been
694   * sent to the client.
695   *
696   * @param  operationContext  The context for the bind operation.
697   * @param  request           The bind request that was processed.
698   * @param  result            The result that was returned to the client.
699   *
700   * @return  Information about the result of the plugin processing.
701   */
702  public PostResponsePluginResult doPostResponse(
703              final CompletedOperationContext operationContext,
704              final SimpleBindRequest request, final BindResult result)
705  {
706    // No processing is performed by default.
707    return PostResponsePluginResult.SUCCESS;
708  }
709
710
711
712  /**
713   * Performs any processing which may be necessary before the server starts
714   * processing for a SASL bind request.
715   *
716   * @param  operationContext  The context for the bind operation.
717   * @param  request           The bind request to be processed.  It may be
718   *                           altered if desired.
719   * @param  result            The result that will be returned to the client if
720   *                           the plugin result indicates that processing on
721   *                           the operation should be interrupted.  It may be
722   *                           altered if desired.
723   *
724   * @return  Information about the result of the plugin processing.
725   */
726  public PreParsePluginResult doPreParse(
727              final ActiveOperationContext operationContext,
728              final UpdatableSASLBindRequest request,
729              final UpdatableBindResult result)
730  {
731    // No processing is performed by default.
732    return PreParsePluginResult.SUCCESS;
733  }
734
735
736
737  /**
738   * Performs any processing which may be necessary before the server actually
739   * attempts to perform the authentication for a SASL bind request.
740   *
741   * @param  operationContext  The context for the bind operation.
742   * @param  request           The bind request to be processed.
743   * @param  result            The result that will be returned to the client if
744   *                           the plugin result indicates that processing on
745   *                           the operation should be interrupted.  It may be
746   *                           altered if desired.
747   *
748   * @return  Information about the result of the plugin processing.
749   */
750  public PreOperationPluginResult doPreOperation(
751              final ActiveOperationContext operationContext,
752              final SASLBindRequest request, final UpdatableBindResult result)
753  {
754    // No processing is performed by default.
755    return PreOperationPluginResult.SUCCESS;
756  }
757
758
759
760  /**
761   * Performs any processing which may be necessary before the server sends a
762   * response for a SASL bind operation.
763   *
764   * @param  operationContext  The context for the bind operation.
765   * @param  request           The bind request that was processed.
766   * @param  result            The result to be returned to the client.  It may
767   *                           be altered if desired.
768   *
769   * @return  Information about the result of the plugin processing.
770   */
771  public PostOperationPluginResult doPostOperation(
772              final ActiveOperationContext operationContext,
773              final SASLBindRequest request, final UpdatableBindResult result)
774  {
775    // No processing is performed by default.
776    return PostOperationPluginResult.SUCCESS;
777  }
778
779
780
781  /**
782   * Performs any processing which may be necessary after all other processing
783   * has been completed for a SASL bind operation and the response has been
784   * sent to the client.
785   *
786   * @param  operationContext  The context for the bind operation.
787   * @param  request           The bind request that was processed.
788   * @param  result            The result that was returned to the client.
789   *
790   * @return  Information about the result of the plugin processing.
791   */
792  public PostResponsePluginResult doPostResponse(
793              final CompletedOperationContext operationContext,
794              final SASLBindRequest request, final BindResult result)
795  {
796    // No processing is performed by default.
797    return PostResponsePluginResult.SUCCESS;
798  }
799
800
801
802  /**
803   * Performs any processing which may be necessary before the server starts
804   * processing for a compare request.
805   *
806   * @param  operationContext  The context for the compare operation.
807   * @param  request           The compare request to be processed.  It may be
808   *                           altered if desired.
809   * @param  result            The result that will be returned to the client if
810   *                           the plugin result indicates that processing on
811   *                           the operation should be interrupted.  It may be
812   *                           altered if desired.
813   *
814   * @return  Information about the result of the plugin processing.
815   */
816  public PreParsePluginResult doPreParse(
817              final ActiveOperationContext operationContext,
818              final UpdatableCompareRequest request,
819              final UpdatableCompareResult result)
820  {
821    // No processing is performed by default.
822    return PreParsePluginResult.SUCCESS;
823  }
824
825
826
827  /**
828   * Performs any processing which may be necessary before the server actually
829   * attempts to perform the core processing for the compare.
830   *
831   * @param  operationContext  The context for the compare operation.
832   * @param  request           The compare request to be processed.
833   * @param  result            The result that will be returned to the client if
834   *                           the plugin result indicates that processing on
835   *                           the operation should be interrupted.  It may be
836   *                           altered if desired.
837   * @param  entry             The entry targeted by the compare operation.
838   *
839   * @return  Information about the result of the plugin processing.
840   */
841  public PreOperationPluginResult doPreOperation(
842              final ActiveOperationContext operationContext,
843              final CompareRequest request, final UpdatableCompareResult result,
844              final Entry entry)
845  {
846    // No processing is performed by default.
847    return PreOperationPluginResult.SUCCESS;
848  }
849
850
851
852  /**
853   * Performs any processing which may be necessary before the server sends a
854   * response for a compare operation.
855   *
856   * @param  operationContext  The context for the compare operation.
857   * @param  request           The compare request that was processed.
858   * @param  result            The result to be returned to the client.  It may
859   *                           be altered if desired.
860   * @param  entry             The entry targeted by the compare operation, if
861   *                           it exists.
862   *
863   * @return  Information about the result of the plugin processing.
864   */
865  public PostOperationPluginResult doPostOperation(
866              final ActiveOperationContext operationContext,
867              final CompareRequest request, final UpdatableCompareResult result,
868              final Entry entry)
869  {
870    // No processing is performed by default.
871    return PostOperationPluginResult.SUCCESS;
872  }
873
874
875
876  /**
877   * Performs any processing which may be necessary after all other processing
878   * has been completed for a compare operation and the response has been sent
879   * to the client.
880   *
881   * @param  operationContext  The context for the compare operation.
882   * @param  request           The compare request that was processed.
883   * @param  result            The result that was returned to the client.
884   *
885   * @return  Information about the result of the plugin processing.
886   */
887  public PostResponsePluginResult doPostResponse(
888              final CompletedOperationContext operationContext,
889              final CompareRequest request, final CompareResult result)
890  {
891    // No processing is performed by default.
892    return PostResponsePluginResult.SUCCESS;
893  }
894
895
896
897  /**
898   * Performs any processing which may be necessary before the server starts
899   * processing for a delete request.  This will be invoked only for delete
900   * operations requested directly by clients, but not for delete operations
901   * received from another server via replication.
902   *
903   * @param  operationContext  The context for the delete operation.
904   * @param  request           The delete request to be processed.  It may be
905   *                           altered if desired.
906   * @param  result            The result that will be returned to the client if
907   *                           the plugin result indicates that processing on
908   *                           the operation should be interrupted.  It may be
909   *                           altered if desired.
910   *
911   * @return  Information about the result of the plugin processing.
912   */
913  public PreParsePluginResult doPreParse(
914              final ActiveOperationContext operationContext,
915              final UpdatableDeleteRequest request,
916              final UpdatableDeleteResult result)
917  {
918    // No processing is performed by default.
919    return PreParsePluginResult.SUCCESS;
920  }
921
922
923
924  /**
925   * Performs any processing which may be necessary before the server actually
926   * attempts to remove the entry from the server.  This will be invoked only
927   * for delete operations requested directly by clients, but not for delete
928   * operations received from another server via replication.
929
930   *
931   * @param  operationContext  The context for the delete operation.
932   * @param  request           The delete request to be processed.
933   * @param  result            The result that will be returned to the client if
934   *                           the plugin result indicates that processing on
935   *                           the operation should be interrupted.  It may be
936   *                           altered if desired.
937   * @param  entry             The entry targeted by the delete operation.
938   *
939   * @return  Information about the result of the plugin processing.
940   */
941  public PreOperationPluginResult doPreOperation(
942              final ActiveOperationContext operationContext,
943              final DeleteRequest request, final UpdatableDeleteResult result,
944              final Entry entry)
945  {
946    // No processing is performed by default.
947    return PreOperationPluginResult.SUCCESS;
948  }
949
950
951
952  /**
953   * Performs any processing which may be necessary before the server sends a
954   * response for a delete operation.  This will be invoked only for delete
955   * operations requested directly by clients, but not for delete operations
956   * received from another server via replication.
957
958   *
959   * @param  operationContext  The context for the delete operation.
960   * @param  request           The delete request that was processed.
961   * @param  result            The result to be returned to the client.  It may
962   *                           be altered if desired.
963   * @param  entry             The entry targeted by the delete operation, if
964   *                           it exists.
965   *
966   * @return  Information about the result of the plugin processing.
967   */
968  public PostOperationPluginResult doPostOperation(
969              final ActiveOperationContext operationContext,
970              final DeleteRequest request, final UpdatableDeleteResult result,
971              final Entry entry)
972  {
973    // No processing is performed by default.
974    return PostOperationPluginResult.SUCCESS;
975  }
976
977
978
979  /**
980   * Performs any processing which may be necessary after all other processing
981   * has been completed for a delete operation and the response has been sent
982   * to the client.  This will be invoked only for delete operations requested
983   * directly by clients, but not for delete operations received from another
984   * server via replication.
985
986   *
987   * @param  operationContext  The context for the delete operation.
988   * @param  request           The delete request that was processed.
989   * @param  result            The result that was returned to the client.
990   *
991   * @return  Information about the result of the plugin processing.
992   */
993  public PostResponsePluginResult doPostResponse(
994              final CompletedOperationContext operationContext,
995              final DeleteRequest request, final DeleteResult result)
996  {
997    // No processing is performed by default.
998    return PostResponsePluginResult.SUCCESS;
999  }
1000
1001
1002
1003  /**
1004   * Performs any processing which may be necessary after all other processing
1005   * has been completed for a delete operation which has been received from
1006   * another server via replication.
1007   *
1008   * @param  operationContext  The context for the delete operation.
1009   * @param  request           The delete request that was processed.
1010   * @param  result            The result that was returned to the client.
1011   */
1012  public void doPostReplication(
1013                   final CompletedOperationContext operationContext,
1014                   final DeleteRequest request, final DeleteResult result)
1015  {
1016    // No processing is performed by default.
1017  }
1018
1019
1020
1021  /**
1022   * Performs any processing which may be necessary before the server starts
1023   * processing for an extended request.
1024   *
1025   * @param  operationContext  The context for the extended operation.
1026   * @param  request           The extended request to be processed.  It may be
1027   *                           altered if desired.
1028   * @param  result            The result that will be returned to the client if
1029   *                           the plugin result indicates that processing on
1030   *                           the operation should be interrupted.  It may be
1031   *                           altered if desired.
1032   *
1033   * @return  Information about the result of the plugin processing.
1034   */
1035  public PreParsePluginResult doPreParse(
1036              final ActiveOperationContext operationContext,
1037              final UpdatableExtendedRequest request,
1038              final UpdatableExtendedResult result)
1039  {
1040    // No processing is performed by default.
1041    return PreParsePluginResult.SUCCESS;
1042  }
1043
1044
1045
1046  /**
1047   * Performs any processing which may be necessary before the server actually
1048   * attempts to perform the core processing for the extended operation.
1049   *
1050   * @param  operationContext  The context for the extended operation.
1051   * @param  request           The extended request to be processed.
1052   * @param  result            The result that will be returned to the client if
1053   *                           the plugin result indicates that processing on
1054   *                           the operation should be interrupted.  It may be
1055   *                           altered if desired.
1056   *
1057   * @return  Information about the result of the plugin processing.
1058   */
1059  public PreOperationPluginResult doPreOperation(
1060              final ActiveOperationContext operationContext,
1061              final ExtendedRequest request,
1062              final UpdatableExtendedResult result)
1063  {
1064    // No processing is performed by default.
1065    return PreOperationPluginResult.SUCCESS;
1066  }
1067
1068
1069
1070  /**
1071   * Performs any processing which may be necessary before the server sends a
1072   * response for an extended operation.
1073   *
1074   * @param  operationContext  The context for the extended operation.
1075   * @param  request           The extended request that was processed.
1076   * @param  result            The result to be returned to the client.  It may
1077   *                           be altered if desired.
1078   *
1079   * @return  Information about the result of the plugin processing.
1080   */
1081  public PostOperationPluginResult doPostOperation(
1082              final ActiveOperationContext operationContext,
1083              final ExtendedRequest request,
1084              final UpdatableExtendedResult result)
1085  {
1086    // No processing is performed by default.
1087    return PostOperationPluginResult.SUCCESS;
1088  }
1089
1090
1091
1092  /**
1093   * Performs any processing which may be necessary after all other processing
1094   * has been completed for an extended operation and the response has been sent
1095   * to the client.
1096   *
1097   * @param  operationContext  The context for the extended operation.
1098   * @param  request           The extended request that was processed.
1099   * @param  result            The result that was returned to the client.
1100   *
1101   * @return  Information about the result of the plugin processing.
1102   */
1103  public PostResponsePluginResult doPostResponse(
1104              final CompletedOperationContext operationContext,
1105              final ExtendedRequest request, final ExtendedResult result)
1106  {
1107    // No processing is performed by default.
1108    return PostResponsePluginResult.SUCCESS;
1109  }
1110
1111
1112
1113  /**
1114   * Performs any processing which may be necessary before the server starts
1115   * processing for a modify request.  This will be invoked only for modify
1116   * operations requested directly by clients, but not for modify operations
1117   * received from another server via replication.
1118   *
1119   * @param  operationContext  The context for the modify operation.
1120   * @param  request           The modify request to be processed.  It may be
1121   *                           altered if desired.
1122   * @param  result            The result that will be returned to the client if
1123   *                           the plugin result indicates that processing on
1124   *                           the operation should be interrupted.  It may be
1125   *                           altered if desired.
1126   *
1127   * @return  Information about the result of the plugin processing.
1128   */
1129  public PreParsePluginResult doPreParse(
1130              final ActiveOperationContext operationContext,
1131              final UpdatableModifyRequest request,
1132              final UpdatableModifyResult result)
1133  {
1134    // No processing is performed by default.
1135    return PreParsePluginResult.SUCCESS;
1136  }
1137
1138
1139
1140  /**
1141   * Performs any processing which may be necessary before the server actually
1142   * attempts to update the entry in the backend.  This will be invoked only for
1143   * modify operations requested directly by clients, but not for modify
1144   * operations received from another server via replication.
1145   *
1146   * @param  operationContext  The context for the modify operation.
1147   * @param  request           The modify request to be processed.
1148   * @param  result            The result that will be returned to the client if
1149   *                           the plugin result indicates that processing on
1150   *                           the operation should be interrupted.  It may be
1151   *                           altered if desired.
1152   * @param  oldEntry          The entry as it appeared before the modifications
1153   *                           were applied.
1154   * @param  newEntry          The updated entry as it will appear after the
1155   *                           modifications have been applied.
1156   *
1157   * @return  Information about the result of the plugin processing.
1158   */
1159  public PreOperationPluginResult doPreOperation(
1160              final ActiveOperationContext operationContext,
1161              final ModifyRequest request, final UpdatableModifyResult result,
1162              final Entry oldEntry, final Entry newEntry)
1163  {
1164    // No processing is performed by default.
1165    return PreOperationPluginResult.SUCCESS;
1166  }
1167
1168
1169
1170  /**
1171   * Performs any processing which may be necessary before the server sends a
1172   * response for a modify operation.  This will be invoked only for modify
1173   * operations requested directly by clients, but not for modify operations
1174   * received from another server via replication.
1175   *
1176   * @param  operationContext  The context for the modify operation.
1177   * @param  request           The modify request that was processed.
1178   * @param  result            The result to be returned to the client.  It may
1179   *                           be altered if desired.
1180   * @param  oldEntry          The entry as it appeared before the modifications
1181   *                           were applied, if it exists. .
1182   * @param  newEntry          The entry as it appears after the modifications
1183   *                           have been applied, if it exists. .
1184   *
1185   * @return  Information about the result of the plugin processing.
1186   */
1187  public PostOperationPluginResult doPostOperation(
1188              final ActiveOperationContext operationContext,
1189              final ModifyRequest request, final UpdatableModifyResult result,
1190              final Entry oldEntry, final Entry newEntry)
1191  {
1192    // No processing is performed by default.
1193    return PostOperationPluginResult.SUCCESS;
1194  }
1195
1196
1197
1198  /**
1199   * Performs any processing which may be necessary after all other processing
1200   * has been completed for a modify operation and the response has been sent
1201   * to the client.  This will be invoked only for modify operations requested
1202   * directly by clients, but not for modify operations received from another
1203   * server via replication.
1204   *
1205   * @param  operationContext  The context for the modify operation.
1206   * @param  request           The modify request that was processed.
1207   * @param  result            The result that was returned to the client.
1208   *
1209   * @return  Information about the result of the plugin processing.
1210   */
1211  public PostResponsePluginResult doPostResponse(
1212              final CompletedOperationContext operationContext,
1213              final ModifyRequest request, final ModifyResult result)
1214  {
1215    // No processing is performed by default.
1216    return PostResponsePluginResult.SUCCESS;
1217  }
1218
1219
1220
1221  /**
1222   * Performs any processing which may be necessary after all other processing
1223   * has been completed for a modify operation which has been received from
1224   * another server via replication.
1225   *
1226   * @param  operationContext  The context for the modify operation.
1227   * @param  request           The modify request that was processed.
1228   * @param  result            The result that was returned to the client.
1229   */
1230  public void doPostReplication(
1231                   final CompletedOperationContext operationContext,
1232                   final ModifyRequest request, final ModifyResult result)
1233  {
1234    // No processing is performed by default.
1235  }
1236
1237
1238
1239  /**
1240   * Performs any processing which may be necessary before the server starts
1241   * processing for a modify DN request.  This will be invoked only for modify
1242   * DN operations requested directly by clients, but not for modify DN
1243   * operations received from another server via replication.
1244   *
1245   * @param  operationContext  The context for the modify DN operation.
1246   * @param  request           The modify DN request to be processed.  It may be
1247   *                           altered if desired.
1248   * @param  result            The result that will be returned to the client if
1249   *                           the plugin result indicates that processing on
1250   *                           the operation should be interrupted.  It may be
1251   *                           altered if desired.
1252   *
1253   * @return  Information about the result of the plugin processing.
1254   */
1255  public PreParsePluginResult doPreParse(
1256              final ActiveOperationContext operationContext,
1257              final UpdatableModifyDNRequest request,
1258              final UpdatableModifyDNResult result)
1259  {
1260    // No processing is performed by default.
1261    return PreParsePluginResult.SUCCESS;
1262  }
1263
1264
1265
1266  /**
1267   * Performs any processing which may be necessary before the server actually
1268   * attempts to update the entry in the backend.  This will be invoked only for
1269   * modify DN operations requested directly by clients, but not for modify DN
1270   * operations received from another server via replication.
1271   *
1272   * @param  operationContext  The context for the modify DN operation.
1273   * @param  request           The modify DN request to be processed.
1274   * @param  result            The result that will be returned to the client if
1275   *                           the plugin result indicates that processing on
1276   *                           the operation should be interrupted.  It may be
1277   *                           altered if desired.
1278   * @param  oldEntry          The entry as it appeared before being renamed.
1279   * @param  newEntry          The updated entry as it will appear after it has
1280   *                           been renamed.
1281   *
1282   * @return  Information about the result of the plugin processing.
1283   */
1284  public PreOperationPluginResult doPreOperation(
1285              final ActiveOperationContext operationContext,
1286              final ModifyDNRequest request,
1287              final UpdatableModifyDNResult result, final Entry oldEntry,
1288              final Entry newEntry)
1289  {
1290    // No processing is performed by default.
1291    return PreOperationPluginResult.SUCCESS;
1292  }
1293
1294
1295
1296  /**
1297   * Performs any processing which may be necessary during the course of
1298   * renaming an entry which is subordinate to an entry targeted by a modify DN
1299   * operation.  This will be invoked only for both modify DN operations
1300   * requested by clients and for modify DN operations received from another
1301   * server via replication.
1302   *
1303   * @param  operationContext         The context for the modify DN operation.
1304   * @param  request                  The modify DN request being processed.
1305   * @param  result                   The result that will be returned to the
1306   *                                  client if the plugin result indicates that
1307   *                                  processing on the operation should be
1308   *                                  interrupted.  It may be altered if
1309   *                                  desired.
1310   * @param  oldSubordinateEntry      The subordinate entry as it appeared
1311   *                                  before being renamed.
1312   * @param  newSubordinateEntry      The subordinate entry as it will appear
1313   *                                  after being renamed.
1314   * @param  additionalModifications  A list of additional modifications that
1315   *                                  should be applied to the entry as it is
1316   *                                  renamed.  This list may be altered if
1317   *                                  desired.
1318   *
1319   * @return  Information about the result of the plugin processing.
1320   */
1321  public SubordinateModifyDNPluginResult doSubordinateModifyDN(
1322              final ActiveOperationContext operationContext,
1323              final ModifyDNRequest request,
1324              final UpdatableModifyDNResult result,
1325              final Entry oldSubordinateEntry,
1326              final Entry newSubordinateEntry,
1327              final List<Modification> additionalModifications)
1328  {
1329    // No processing is performed by default.
1330    return SubordinateModifyDNPluginResult.SUCCESS;
1331  }
1332
1333
1334
1335  /**
1336   * Performs any processing which may be necessary before the server sends a
1337   * response for a modify DN operation.  This will be invoked only for modify
1338   * DN operations requested directly by clients, but not for modify DN
1339   * operations received from another server via replication.
1340   *
1341   * @param  operationContext  The context for the modify DN operation.
1342   * @param  request           The modify DN request that was processed.
1343   * @param  result            The result to be returned to the client.  It may
1344   *                           be altered if desired.
1345   * @param  oldEntry          The entry as it appeared before it was renamed,
1346   *                           if it exists.
1347   * @param  newEntry          The entry as it appears after it was renamed, if
1348   *                           it exists. .
1349   *
1350   * @return  Information about the result of the plugin processing.
1351   */
1352  public PostOperationPluginResult doPostOperation(
1353              final ActiveOperationContext operationContext,
1354              final ModifyDNRequest request,
1355              final UpdatableModifyDNResult result, final Entry oldEntry,
1356              final Entry newEntry)
1357  {
1358    // No processing is performed by default.
1359    return PostOperationPluginResult.SUCCESS;
1360  }
1361
1362
1363
1364  /**
1365   * Performs any processing which may be necessary after all other processing
1366   * has been completed for a modify DN operation and the response has been
1367   * sent to the client.  This will be invoked only for modify DN operations
1368   * requested directly by clients, but not for modify DN operations received
1369   * from another server via replication.
1370   *
1371   * @param  operationContext  The context for the modify DN operation.
1372   * @param  request           The modify DN request that was processed.
1373   * @param  result            The result that was returned to the client.
1374   *
1375   * @return  Information about the result of the plugin processing.
1376   */
1377  public PostResponsePluginResult doPostResponse(
1378              final CompletedOperationContext operationContext,
1379              final ModifyDNRequest request, final ModifyDNResult result)
1380  {
1381    // No processing is performed by default.
1382    return PostResponsePluginResult.SUCCESS;
1383  }
1384
1385
1386
1387  /**
1388   * Performs any processing which may be necessary after all other processing
1389   * has been completed for a modify DN operation which has been received from
1390   * another server via replication.
1391   *
1392   * @param  operationContext  The context for the modify DN operation.
1393   * @param  request           The modify DN request that was processed.
1394   * @param  result            The result that was returned to the client.
1395   */
1396  public void doPostReplication(
1397                   final CompletedOperationContext operationContext,
1398                   final ModifyDNRequest request, final ModifyDNResult result)
1399  {
1400    // No processing is performed by default.
1401  }
1402
1403
1404
1405  /**
1406   * Performs any processing which may be necessary before the server starts
1407   * processing for a search request.
1408   *
1409   * @param  operationContext  The context for the search operation.
1410   * @param  request           The search request to be processed.  It may be
1411   *                           altered if desired.
1412   * @param  result            The result that will be returned to the client if
1413   *                           the plugin result indicates that processing on
1414   *                           the operation should be interrupted.  It may be
1415   *                           altered if desired.
1416   *
1417   * @return  Information about the result of the plugin processing.
1418   */
1419  public PreParsePluginResult doPreParse(
1420              final ActiveSearchOperationContext operationContext,
1421              final UpdatableSearchRequest request,
1422              final UpdatableSearchResult result)
1423  {
1424    // No processing is performed by default.
1425    return PreParsePluginResult.SUCCESS;
1426  }
1427
1428
1429
1430  /**
1431   * Performs any processing which may be necessary before the server actually
1432   * attempts to process the search in the backend.
1433   *
1434   * @param  operationContext  The context for the search operation.
1435   * @param  request           The search request to be processed.
1436   * @param  result            The result that will be returned to the client if
1437   *                           the plugin result indicates that processing on
1438   *                           the operation should be interrupted.  It may be
1439   *                           altered if desired.
1440   *
1441   * @return  Information about the result of the plugin processing.
1442   */
1443  public PreOperationPluginResult doPreOperation(
1444              final ActiveSearchOperationContext operationContext,
1445              final SearchRequest request, final UpdatableSearchResult result)
1446  {
1447    // No processing is performed by default.
1448    return PreOperationPluginResult.SUCCESS;
1449  }
1450
1451
1452
1453  /**
1454   * Performs any processing which may be necessary before the server sends a
1455   * search result entry to the client.
1456   *
1457   * @param  operationContext  The context for the search operation.
1458   * @param  request           The search request being processed.
1459   * @param  result            The result that will be returned to the client if
1460   *                           the plugin result indicates that processing on
1461   *                           the operation should be interrupted.  It may be
1462   *                           altered if desired.
1463   * @param  entry             The entry to be returned to the client.  It may
1464   *                           be altered if desired.
1465   * @param  controls          The set of controls to be included with the
1466   *                           entry.  It may be altered if desired.
1467   *
1468   * @return  Information about the result of the plugin processing.
1469   */
1470  public SearchEntryPluginResult doSearchEntry(
1471              final ActiveSearchOperationContext operationContext,
1472              final SearchRequest request, final UpdatableSearchResult result,
1473              final UpdatableEntry entry, final List<Control> controls)
1474  {
1475    // No processing is performed by default.
1476    return SearchEntryPluginResult.SUCCESS;
1477  }
1478
1479
1480
1481  /**
1482   * Performs any processing which may be necessary before the server sends a
1483   * search result reference to the client.
1484   *
1485   * @param  operationContext  The context for the search operation.
1486   * @param  request           The search request being processed.
1487   * @param  result            The result that will be returned to the client if
1488   *                           the plugin result indicates that processing on
1489   *                           the operation should be interrupted.  It may be
1490   *                           altered if desired.
1491   * @param  referralURLs      The set of referral URLs to be returned to the
1492   *                           client.  It may be altered if desired.
1493   * @param  controls          The set of controls to be included with the
1494   *                           reference.  It may be altered if desired.
1495   *
1496   * @return  Information about the result of the plugin processing.
1497   */
1498  public SearchReferencePluginResult doSearchReference(
1499              final ActiveSearchOperationContext operationContext,
1500              final SearchRequest request, final UpdatableSearchResult result,
1501              final List<String> referralURLs, final List<Control> controls)
1502  {
1503    // No processing is performed by default.
1504    return SearchReferencePluginResult.SUCCESS;
1505  }
1506
1507
1508
1509  /**
1510   * Performs any processing which may be necessary before the server sends a
1511   * response for a search operation.
1512   *
1513   * @param  operationContext  The context for the search operation.
1514   * @param  request           The search request that was processed.
1515   * @param  result            The result to be returned to the client.  It may
1516   *                           be altered if desired.
1517   *
1518   * @return  Information about the result of the plugin processing.
1519   */
1520  public PostOperationPluginResult doPostOperation(
1521              final ActiveSearchOperationContext operationContext,
1522              final SearchRequest request, final UpdatableSearchResult result)
1523  {
1524    // No processing is performed by default.
1525    return PostOperationPluginResult.SUCCESS;
1526  }
1527
1528
1529
1530  /**
1531   * Performs any processing which may be necessary after all other processing
1532   * has been completed for a search operation and the response has been sent to
1533   * the client.
1534   *
1535   * @param  operationContext  The context for the search operation.
1536   * @param  request           The search request that was processed.
1537   * @param  result            The result that was returned to the client.
1538   *
1539   * @return  Information about the result of the plugin processing.
1540   */
1541  public PostResponsePluginResult doPostResponse(
1542              final CompletedSearchOperationContext operationContext,
1543              final SearchRequest request, final SearchResult result)
1544  {
1545    // No processing is performed by default.
1546    return PostResponsePluginResult.SUCCESS;
1547  }
1548
1549
1550
1551  /**
1552   * Performs any processing which may be necessary before the server starts
1553   * processing for an unbind request.
1554   *
1555   * @param  operationContext  The context for the unbind operation.
1556   * @param  request           The unbind request to be processed.  It may be
1557   *                           altered if desired.
1558   *
1559   * @return  Information about the result of the plugin processing.
1560   */
1561  public PreParsePluginResult doPreParse(
1562              final ActiveOperationContext operationContext,
1563              final UpdatableUnbindRequest request)
1564  {
1565    // No processing is performed by default.
1566    return PreParsePluginResult.SUCCESS;
1567  }
1568
1569
1570
1571  /**
1572   * Performs any processing which may be necessary before the server sends an
1573   * intermediate response to the client.
1574   *
1575   * @param  operationContext      The context for the associated operation.
1576   * @param  result                The result that will be returned to the
1577   *                               client if the plugin result indicates that
1578   *                               processing on the operation should be
1579   *                               interrupted.  It may be altered if desired.
1580   * @param  intermediateResponse  The intermediate response to be returned to
1581   *                               the client.  It may be altered if desired.
1582   *
1583   * @return  Information about the result of the plugin processing.
1584   */
1585  public IntermediateResponsePluginResult doIntermediateResponse(
1586              final ActiveOperationContext operationContext,
1587              final UpdatableGenericResult result,
1588              final IntermediateResponse intermediateResponse)
1589  {
1590    // No processing is performed by default.
1591    return IntermediateResponsePluginResult.SUCCESS;
1592  }
1593
1594
1595
1596  /**
1597   * {@inheritDoc}
1598   */
1599  public Map<List<String>,String> getExamplesArgumentSets()
1600  {
1601    return Collections.emptyMap();
1602  }
1603}