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