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