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