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 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 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 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. 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 2006-2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.core; 028 029 030 031 import java.lang.reflect.Method; 032 import java.util.ArrayList; 033 import java.util.HashMap; 034 import java.util.HashSet; 035 import java.util.Iterator; 036 import java.util.LinkedHashSet; 037 import java.util.List; 038 import java.util.Set; 039 import java.util.StringTokenizer; 040 import java.util.concurrent.ConcurrentHashMap; 041 import java.util.concurrent.locks.ReentrantLock; 042 043 import org.opends.messages.Message; 044 import org.opends.messages.MessageBuilder; 045 import org.opends.server.admin.ClassPropertyDefinition; 046 import org.opends.server.admin.server.ConfigurationAddListener; 047 import org.opends.server.admin.server.ConfigurationChangeListener; 048 import org.opends.server.admin.server.ConfigurationDeleteListener; 049 import org.opends.server.admin.server.ServerManagementContext; 050 import org.opends.server.admin.std.meta.PluginCfgDefn; 051 import org.opends.server.admin.std.server.PluginCfg; 052 import org.opends.server.admin.std.server.PluginRootCfg; 053 import org.opends.server.admin.std.server.RootCfg; 054 import org.opends.server.api.ClientConnection; 055 import org.opends.server.api.plugin.*; 056 import org.opends.server.config.ConfigException; 057 import org.opends.server.loggers.debug.DebugTracer; 058 import org.opends.server.types.*; 059 import org.opends.server.types.operation.*; 060 import org.opends.server.workflowelement.localbackend.*; 061 062 import static org.opends.messages.ConfigMessages.*; 063 import static org.opends.messages.PluginMessages.*; 064 import static org.opends.server.loggers.debug.DebugLogger.*; 065 import static org.opends.server.loggers.ErrorLogger.*; 066 import static org.opends.server.util.StaticUtils.*; 067 068 069 070 /** 071 * This class defines a utility that will be used to manage the configuration 072 * for the set of plugins defined in the Directory Server. It will perform the 073 * necessary initialization of those plugins when the server is first started, 074 * and then will manage any changes to them while the server is running. It 075 * also provides methods for invoking all the plugins of a given type. 076 */ 077 public class PluginConfigManager 078 implements ConfigurationAddListener<PluginCfg>, 079 ConfigurationDeleteListener<PluginCfg>, 080 ConfigurationChangeListener<PluginCfg> 081 { 082 /** 083 * The tracer object for the debug logger. 084 */ 085 private static final DebugTracer TRACER = getTracer(); 086 087 // Arrays for holding the plugins of each type. 088 private DirectoryServerPlugin[] startupPlugins; 089 private DirectoryServerPlugin[] shutdownPlugins; 090 private DirectoryServerPlugin[] postConnectPlugins; 091 private DirectoryServerPlugin[] postDisconnectPlugins; 092 private DirectoryServerPlugin[] ldifImportPlugins; 093 private DirectoryServerPlugin[] ldifExportPlugins; 094 private DirectoryServerPlugin[] preParseAbandonPlugins; 095 private DirectoryServerPlugin[] preParseAddPlugins; 096 private DirectoryServerPlugin[] preParseBindPlugins; 097 private DirectoryServerPlugin[] preParseComparePlugins; 098 private DirectoryServerPlugin[] preParseDeletePlugins; 099 private DirectoryServerPlugin[] preParseExtendedPlugins; 100 private DirectoryServerPlugin[] preParseModifyPlugins; 101 private DirectoryServerPlugin[] preParseModifyDNPlugins; 102 private DirectoryServerPlugin[] preParseSearchPlugins; 103 private DirectoryServerPlugin[] preParseUnbindPlugins; 104 private DirectoryServerPlugin[] preOperationAddPlugins; 105 private DirectoryServerPlugin[] preOperationBindPlugins; 106 private DirectoryServerPlugin[] preOperationComparePlugins; 107 private DirectoryServerPlugin[] preOperationDeletePlugins; 108 private DirectoryServerPlugin[] preOperationExtendedPlugins; 109 private DirectoryServerPlugin[] preOperationModifyPlugins; 110 private DirectoryServerPlugin[] preOperationModifyDNPlugins; 111 private DirectoryServerPlugin[] preOperationSearchPlugins; 112 private DirectoryServerPlugin[] postOperationAbandonPlugins; 113 private DirectoryServerPlugin[] postOperationAddPlugins; 114 private DirectoryServerPlugin[] postOperationBindPlugins; 115 private DirectoryServerPlugin[] postOperationComparePlugins; 116 private DirectoryServerPlugin[] postOperationDeletePlugins; 117 private DirectoryServerPlugin[] postOperationExtendedPlugins; 118 private DirectoryServerPlugin[] postOperationModifyPlugins; 119 private DirectoryServerPlugin[] postOperationModifyDNPlugins; 120 private DirectoryServerPlugin[] postOperationSearchPlugins; 121 private DirectoryServerPlugin[] postOperationUnbindPlugins; 122 private DirectoryServerPlugin[] postResponseAddPlugins; 123 private DirectoryServerPlugin[] postResponseBindPlugins; 124 private DirectoryServerPlugin[] postResponseComparePlugins; 125 private DirectoryServerPlugin[] postResponseDeletePlugins; 126 private DirectoryServerPlugin[] postResponseExtendedPlugins; 127 private DirectoryServerPlugin[] postResponseModifyPlugins; 128 private DirectoryServerPlugin[] postResponseModifyDNPlugins; 129 private DirectoryServerPlugin[] postResponseSearchPlugins; 130 private DirectoryServerPlugin[] postSynchronizationAddPlugins; 131 private DirectoryServerPlugin[] postSynchronizationDeletePlugins; 132 private DirectoryServerPlugin[] postSynchronizationModifyPlugins; 133 private DirectoryServerPlugin[] postSynchronizationModifyDNPlugins; 134 private DirectoryServerPlugin[] searchResultEntryPlugins; 135 private DirectoryServerPlugin[] searchResultReferencePlugins; 136 private DirectoryServerPlugin[] subordinateModifyDNPlugins; 137 private DirectoryServerPlugin[] intermediateResponsePlugins; 138 139 140 // The mapping between the DN of a plugin entry and the plugin instance loaded 141 // from that entry. 142 private ConcurrentHashMap<DN, 143 DirectoryServerPlugin<? extends PluginCfg>> 144 registeredPlugins; 145 146 // The mapping between an operation and a set of post operation plugins 147 // it should skip. This pairs up pre and post operation plugin processing 148 // such that only plugins that successfully execute its pre op plugin will 149 // have its post op plugin executed on a per operation basis. If an 150 // operation is not registered on this list then all all pre op plugins 151 // executed successfully for this operation so all post op plugins should 152 // execute. 153 private ConcurrentHashMap<PluginOperation, ArrayList<DirectoryServerPlugin>> 154 skippedPreOperationPlugins; 155 156 // The plugin root configuration read at server startup. 157 private PluginRootCfg pluginRootConfig; 158 159 // The lock that will provide threadsafe access to the sets of registered 160 // plugins. 161 private ReentrantLock pluginLock; 162 163 164 165 /** 166 * Creates a new instance of this plugin config manager. 167 */ 168 public PluginConfigManager() 169 { 170 pluginLock = new ReentrantLock(); 171 172 startupPlugins = new DirectoryServerPlugin[0]; 173 shutdownPlugins = new DirectoryServerPlugin[0]; 174 postConnectPlugins = new DirectoryServerPlugin[0]; 175 postDisconnectPlugins = new DirectoryServerPlugin[0]; 176 ldifImportPlugins = new DirectoryServerPlugin[0]; 177 ldifExportPlugins = new DirectoryServerPlugin[0]; 178 preParseAbandonPlugins = new DirectoryServerPlugin[0]; 179 preParseAddPlugins = new DirectoryServerPlugin[0]; 180 preParseBindPlugins = new DirectoryServerPlugin[0]; 181 preParseComparePlugins = new DirectoryServerPlugin[0]; 182 preParseDeletePlugins = new DirectoryServerPlugin[0]; 183 preParseExtendedPlugins = new DirectoryServerPlugin[0]; 184 preParseModifyPlugins = new DirectoryServerPlugin[0]; 185 preParseModifyDNPlugins = new DirectoryServerPlugin[0]; 186 preParseSearchPlugins = new DirectoryServerPlugin[0]; 187 preParseUnbindPlugins = new DirectoryServerPlugin[0]; 188 preOperationAddPlugins = new DirectoryServerPlugin[0]; 189 preOperationBindPlugins = new DirectoryServerPlugin[0]; 190 preOperationComparePlugins = new DirectoryServerPlugin[0]; 191 preOperationDeletePlugins = new DirectoryServerPlugin[0]; 192 preOperationExtendedPlugins = new DirectoryServerPlugin[0]; 193 preOperationModifyPlugins = new DirectoryServerPlugin[0]; 194 preOperationModifyDNPlugins = new DirectoryServerPlugin[0]; 195 preOperationSearchPlugins = new DirectoryServerPlugin[0]; 196 postOperationAbandonPlugins = new DirectoryServerPlugin[0]; 197 postOperationAddPlugins = new DirectoryServerPlugin[0]; 198 postOperationBindPlugins = new DirectoryServerPlugin[0]; 199 postOperationComparePlugins = new DirectoryServerPlugin[0]; 200 postOperationDeletePlugins = new DirectoryServerPlugin[0]; 201 postOperationExtendedPlugins = new DirectoryServerPlugin[0]; 202 postOperationModifyPlugins = new DirectoryServerPlugin[0]; 203 postOperationModifyDNPlugins = new DirectoryServerPlugin[0]; 204 postOperationSearchPlugins = new DirectoryServerPlugin[0]; 205 postOperationUnbindPlugins = new DirectoryServerPlugin[0]; 206 postResponseAddPlugins = new DirectoryServerPlugin[0]; 207 postResponseBindPlugins = new DirectoryServerPlugin[0]; 208 postResponseComparePlugins = new DirectoryServerPlugin[0]; 209 postResponseDeletePlugins = new DirectoryServerPlugin[0]; 210 postResponseExtendedPlugins = new DirectoryServerPlugin[0]; 211 postResponseModifyPlugins = new DirectoryServerPlugin[0]; 212 postResponseModifyDNPlugins = new DirectoryServerPlugin[0]; 213 postResponseSearchPlugins = new DirectoryServerPlugin[0]; 214 postSynchronizationAddPlugins = new DirectoryServerPlugin[0]; 215 postSynchronizationDeletePlugins = new DirectoryServerPlugin[0]; 216 postSynchronizationModifyPlugins = new DirectoryServerPlugin[0]; 217 postSynchronizationModifyDNPlugins = new DirectoryServerPlugin[0]; 218 searchResultEntryPlugins = new DirectoryServerPlugin[0]; 219 searchResultReferencePlugins = new DirectoryServerPlugin[0]; 220 subordinateModifyDNPlugins = new DirectoryServerPlugin[0]; 221 intermediateResponsePlugins = new DirectoryServerPlugin[0]; 222 registeredPlugins = 223 new ConcurrentHashMap<DN, 224 DirectoryServerPlugin<? extends PluginCfg>>(); 225 skippedPreOperationPlugins = 226 new ConcurrentHashMap<PluginOperation, 227 ArrayList<DirectoryServerPlugin>>(); 228 } 229 230 231 232 /** 233 * Initializes the configuration associated with the Directory Server plugins. 234 * This should only be called at Directory Server startup. 235 * 236 * @param pluginTypes The set of plugin types for the plugins to initialize, 237 * or <CODE>null</CODE> to initialize all types of 238 * plugins defined in the server configuration. In 239 * general, this should only be non-null for cases in 240 * which the server is running in a special mode that 241 * only uses a minimal set of plugins (e.g., LDIF import 242 * or export). 243 * 244 * @throws ConfigException If a critical configuration problem prevents the 245 * plugin initialization from succeeding. 246 * 247 * @throws InitializationException If a problem occurs while initializing 248 * the plugins that is not related to the 249 * server configuration. 250 */ 251 public void initializePluginConfig(Set<PluginType> pluginTypes) 252 throws ConfigException, InitializationException 253 { 254 registeredPlugins.clear(); 255 256 257 // Get the root configuration object. 258 ServerManagementContext managementContext = 259 ServerManagementContext.getInstance(); 260 RootCfg rootConfiguration = 261 managementContext.getRootConfiguration(); 262 263 264 // Get the plugin root configuration and register with it as an add and 265 // delete listener so we can be notified if any plugin entries are added or 266 // removed. 267 pluginRootConfig = rootConfiguration.getPluginRoot(); 268 pluginRootConfig.addPluginAddListener(this); 269 pluginRootConfig.addPluginDeleteListener(this); 270 271 272 //Initialize the existing plugins. 273 for (String pluginName : pluginRootConfig.listPlugins()) 274 { 275 PluginCfg pluginConfiguration = pluginRootConfig.getPlugin(pluginName); 276 pluginConfiguration.addChangeListener(this); 277 278 if (! pluginConfiguration.isEnabled()) 279 { 280 continue; 281 } 282 283 // Create a set of plugin types for the plugin. 284 HashSet<PluginType> initTypes = new HashSet<PluginType>(); 285 for (PluginCfgDefn.PluginType pluginType : 286 pluginConfiguration.getPluginType()) 287 { 288 PluginType t = getPluginType(pluginType); 289 if ((pluginTypes == null) || pluginTypes.contains(t)) 290 { 291 initTypes.add(t); 292 } 293 } 294 295 if (initTypes.isEmpty()) 296 { 297 continue; 298 } 299 300 try 301 { 302 DirectoryServerPlugin<? extends PluginCfg> plugin = 303 loadPlugin(pluginConfiguration.getJavaClass(), initTypes, 304 pluginConfiguration, true); 305 registerPlugin(plugin, pluginConfiguration.dn(), initTypes); 306 } 307 catch (InitializationException ie) 308 { 309 logError(ie.getMessageObject()); 310 continue; 311 } 312 } 313 } 314 315 316 317 /** 318 * Loads the specified class, instantiates it as a plugin, and optionally 319 * initializes that plugin. 320 * 321 * @param className The fully-qualified name of the plugin class to 322 * load, instantiate, and initialize. 323 * @param pluginTypes The set of plugin types for the plugins to 324 * initialize, or {@code null} to initialize all types 325 * of plugins defined in the server configuration. In 326 * general, this should only be non-null for cases in 327 * which the server is running in a special mode that 328 * only uses a minimal set of plugins (e.g., LDIF 329 * import or export). 330 * @param configuration The configuration to use to initialize the plugin. 331 * It must not be {@code null}. 332 * @param initialize Indicates whether the plugin instance should be 333 * initialized. 334 * 335 * @return The possibly initialized plugin. 336 * 337 * @throws InitializationException If a problem occurred while attempting to 338 * initialize the plugin. 339 */ 340 private DirectoryServerPlugin<? extends PluginCfg> 341 loadPlugin(String className, Set<PluginType> pluginTypes, 342 PluginCfg configuration, boolean initialize) 343 throws InitializationException 344 { 345 try 346 { 347 PluginCfgDefn definition = 348 PluginCfgDefn.getInstance(); 349 ClassPropertyDefinition propertyDefinition = 350 definition.getJavaClassPropertyDefinition(); 351 Class<? extends DirectoryServerPlugin> pluginClass = 352 propertyDefinition.loadClass(className, DirectoryServerPlugin.class); 353 DirectoryServerPlugin<? extends PluginCfg> plugin = 354 (DirectoryServerPlugin<? extends PluginCfg>) 355 pluginClass.newInstance(); 356 357 if (initialize) 358 { 359 Method method = plugin.getClass().getMethod("initializeInternal", 360 PluginCfg.class, Set.class); 361 method.invoke(plugin, configuration, pluginTypes); 362 363 method = plugin.getClass().getMethod("initializePlugin", Set.class, 364 configuration.configurationClass()); 365 method.invoke(plugin, pluginTypes, configuration); 366 } 367 else 368 { 369 Method method = plugin.getClass().getMethod("isConfigurationAcceptable", 370 PluginCfg.class, 371 List.class); 372 373 List<Message> unacceptableReasons = new ArrayList<Message>(); 374 Boolean acceptable = (Boolean) method.invoke(plugin, configuration, 375 unacceptableReasons); 376 if (! acceptable) 377 { 378 MessageBuilder buffer = new MessageBuilder(); 379 if (! unacceptableReasons.isEmpty()) 380 { 381 Iterator<Message> iterator = unacceptableReasons.iterator(); 382 buffer.append(iterator.next()); 383 while (iterator.hasNext()) 384 { 385 buffer.append(". "); 386 buffer.append(iterator.next()); 387 } 388 } 389 390 Message message = ERR_CONFIG_PLUGIN_CONFIG_NOT_ACCEPTABLE.get( 391 String.valueOf(configuration.dn()), buffer.toString()); 392 throw new InitializationException(message); 393 } 394 } 395 396 return plugin; 397 } 398 catch (Exception e) 399 { 400 Message message = ERR_CONFIG_PLUGIN_CANNOT_INITIALIZE. 401 get(className, String.valueOf(configuration.dn()), 402 stackTraceToSingleLineString(e)); 403 throw new InitializationException(message, e); 404 } 405 } 406 407 408 409 /** 410 * Gets the OpenDS plugin type object that corresponds to the configuration 411 * counterpart. 412 * 413 * @param configPluginType The configuration plugin type for which to 414 * retrieve the OpenDS plugin type. 415 */ 416 private PluginType getPluginType(PluginCfgDefn.PluginType 417 configPluginType) 418 { 419 switch (configPluginType) 420 { 421 case STARTUP: return PluginType.STARTUP; 422 case SHUTDOWN: return PluginType.SHUTDOWN; 423 case POSTCONNECT: return PluginType.POST_CONNECT; 424 case POSTDISCONNECT: return PluginType.POST_DISCONNECT; 425 case LDIFIMPORT: return PluginType.LDIF_IMPORT; 426 case LDIFEXPORT: return PluginType.LDIF_EXPORT; 427 case PREPARSEABANDON: return PluginType.PRE_PARSE_ABANDON; 428 case PREPARSEADD: return PluginType.PRE_PARSE_ADD; 429 case PREPARSEBIND: return PluginType.PRE_PARSE_BIND; 430 case PREPARSECOMPARE: return PluginType.PRE_PARSE_COMPARE; 431 case PREPARSEDELETE: return PluginType.PRE_PARSE_DELETE; 432 case PREPARSEEXTENDED: return PluginType.PRE_PARSE_EXTENDED; 433 case PREPARSEMODIFY: return PluginType.PRE_PARSE_MODIFY; 434 case PREPARSEMODIFYDN: return PluginType.PRE_PARSE_MODIFY_DN; 435 case PREPARSESEARCH: return PluginType.PRE_PARSE_SEARCH; 436 case PREPARSEUNBIND: return PluginType.PRE_PARSE_UNBIND; 437 case PREOPERATIONADD: return PluginType.PRE_OPERATION_ADD; 438 case PREOPERATIONBIND: return PluginType.PRE_OPERATION_BIND; 439 case PREOPERATIONCOMPARE: return PluginType.PRE_OPERATION_COMPARE; 440 case PREOPERATIONDELETE: return PluginType.PRE_OPERATION_DELETE; 441 case PREOPERATIONEXTENDED: return PluginType.PRE_OPERATION_EXTENDED; 442 case PREOPERATIONMODIFY: return PluginType.PRE_OPERATION_MODIFY; 443 case PREOPERATIONMODIFYDN: return PluginType.PRE_OPERATION_MODIFY_DN; 444 case PREOPERATIONSEARCH: return PluginType.PRE_OPERATION_SEARCH; 445 case POSTOPERATIONABANDON: return PluginType.POST_OPERATION_ABANDON; 446 case POSTOPERATIONADD: return PluginType.POST_OPERATION_ADD; 447 case POSTOPERATIONBIND: return PluginType.POST_OPERATION_BIND; 448 case POSTOPERATIONCOMPARE: return PluginType.POST_OPERATION_COMPARE; 449 case POSTOPERATIONDELETE: return PluginType.POST_OPERATION_DELETE; 450 case POSTOPERATIONEXTENDED: return PluginType.POST_OPERATION_EXTENDED; 451 case POSTOPERATIONMODIFY: return PluginType.POST_OPERATION_MODIFY; 452 case POSTOPERATIONMODIFYDN: return PluginType.POST_OPERATION_MODIFY_DN; 453 case POSTOPERATIONSEARCH: return PluginType.POST_OPERATION_SEARCH; 454 case POSTOPERATIONUNBIND: return PluginType.POST_OPERATION_UNBIND; 455 case POSTRESPONSEADD: return PluginType.POST_RESPONSE_ADD; 456 case POSTRESPONSEBIND: return PluginType.POST_RESPONSE_BIND; 457 case POSTRESPONSECOMPARE: return PluginType.POST_RESPONSE_COMPARE; 458 case POSTRESPONSEDELETE: return PluginType.POST_RESPONSE_DELETE; 459 case POSTRESPONSEEXTENDED: return PluginType.POST_RESPONSE_EXTENDED; 460 case POSTRESPONSEMODIFY: return PluginType.POST_RESPONSE_MODIFY; 461 case POSTRESPONSEMODIFYDN: return PluginType.POST_RESPONSE_MODIFY_DN; 462 case POSTRESPONSESEARCH: return PluginType.POST_RESPONSE_SEARCH; 463 case SEARCHRESULTENTRY: return PluginType.SEARCH_RESULT_ENTRY; 464 case SEARCHRESULTREFERENCE: return PluginType.SEARCH_RESULT_REFERENCE; 465 case SUBORDINATEMODIFYDN: return PluginType.SUBORDINATE_MODIFY_DN; 466 case INTERMEDIATERESPONSE: return PluginType.INTERMEDIATE_RESPONSE; 467 case POSTSYNCHRONIZATIONADD: 468 return PluginType.POST_SYNCHRONIZATION_ADD; 469 case POSTSYNCHRONIZATIONDELETE: 470 return PluginType.POST_SYNCHRONIZATION_DELETE; 471 case POSTSYNCHRONIZATIONMODIFY: 472 return PluginType.POST_SYNCHRONIZATION_MODIFY; 473 case POSTSYNCHRONIZATIONMODIFYDN: 474 return PluginType.POST_SYNCHRONIZATION_MODIFY_DN; 475 default: return null; 476 } 477 } 478 479 480 481 /** 482 * Finalizes all plugins that are registered with the Directory Server. 483 */ 484 public void finalizePlugins() 485 { 486 pluginLock.lock(); 487 488 try 489 { 490 Iterator<DirectoryServerPlugin<? extends PluginCfg>> iterator = 491 registeredPlugins.values().iterator(); 492 while (iterator.hasNext()) 493 { 494 try 495 { 496 iterator.next().finalizePlugin(); 497 } 498 catch (Exception e) 499 { 500 if (debugEnabled()) 501 { 502 TRACER.debugCaught(DebugLogLevel.ERROR, e); 503 } 504 } 505 } 506 507 registeredPlugins.clear(); 508 } 509 finally 510 { 511 pluginLock.unlock(); 512 } 513 } 514 515 516 517 /** 518 * Retrieves the set of plugins that have been registered with the Directory 519 * Server. 520 * 521 * @return The set of plugins that have been registered with the Directory 522 * Server. 523 */ 524 public ConcurrentHashMap<DN, 525 DirectoryServerPlugin<? extends PluginCfg>> 526 getRegisteredPlugins() 527 { 528 return registeredPlugins; 529 } 530 531 532 533 /** 534 * Retrieves the plugin with the specified configuration entry DN. 535 * 536 * @param pluginDN The DN of the configuration entry for the plugin to 537 * retrieve. 538 * 539 * @return The requested plugin, or <CODE>null</CODE> if there is no such 540 * plugin. 541 */ 542 public DirectoryServerPlugin getRegisteredPlugin(DN pluginDN) 543 { 544 return registeredPlugins.get(pluginDN); 545 } 546 547 548 549 /** 550 * Registers the provided plugin with this plugin config manager and ensures 551 * that it will be invoked in the specified ways. 552 * 553 * @param plugin The plugin to register with the server. 554 * @param pluginEntryDN The DN of the configuration entry for the provided 555 * plugin. 556 * @param pluginTypes The plugin types that will be used to control the 557 * points at which the provided plugin is invoked. 558 */ 559 private void registerPlugin( 560 DirectoryServerPlugin<? extends PluginCfg> plugin, 561 DN pluginEntryDN, Set<PluginType> pluginTypes) 562 { 563 pluginLock.lock(); 564 565 try 566 { 567 registeredPlugins.put(pluginEntryDN, plugin); 568 569 for (PluginType t : pluginTypes) 570 { 571 switch (t) 572 { 573 case STARTUP: 574 startupPlugins = 575 addPlugin(startupPlugins, plugin, t, 576 pluginRootConfig.getPluginOrderStartup()); 577 break; 578 case SHUTDOWN: 579 shutdownPlugins = 580 addPlugin(shutdownPlugins, plugin, t, 581 pluginRootConfig.getPluginOrderShutdown()); 582 break; 583 case POST_CONNECT: 584 postConnectPlugins = 585 addPlugin(postConnectPlugins, plugin, t, 586 pluginRootConfig.getPluginOrderPostConnect()); 587 break; 588 case POST_DISCONNECT: 589 postDisconnectPlugins = 590 addPlugin(postDisconnectPlugins, plugin, t, 591 pluginRootConfig.getPluginOrderPostDisconnect()); 592 break; 593 case LDIF_IMPORT: 594 ldifImportPlugins = 595 addPlugin(ldifImportPlugins, plugin, t, 596 pluginRootConfig.getPluginOrderLDIFImport()); 597 break; 598 case LDIF_EXPORT: 599 ldifExportPlugins = 600 addPlugin(ldifExportPlugins, plugin, t, 601 pluginRootConfig.getPluginOrderLDIFExport()); 602 break; 603 case PRE_PARSE_ABANDON: 604 preParseAbandonPlugins = 605 addPlugin(preParseAbandonPlugins, plugin, t, 606 pluginRootConfig.getPluginOrderPreParseAbandon()); 607 break; 608 case PRE_PARSE_ADD: 609 preParseAddPlugins = 610 addPlugin(preParseAddPlugins, plugin, t, 611 pluginRootConfig.getPluginOrderPreParseAdd()); 612 break; 613 case PRE_PARSE_BIND: 614 preParseBindPlugins = 615 addPlugin(preParseBindPlugins, plugin, t, 616 pluginRootConfig.getPluginOrderPreParseBind()); 617 break; 618 case PRE_PARSE_COMPARE: 619 preParseComparePlugins = 620 addPlugin(preParseComparePlugins, plugin, t, 621 pluginRootConfig.getPluginOrderPreParseCompare()); 622 break; 623 case PRE_PARSE_DELETE: 624 preParseDeletePlugins = 625 addPlugin(preParseDeletePlugins, plugin, t, 626 pluginRootConfig.getPluginOrderPreParseDelete()); 627 break; 628 case PRE_PARSE_EXTENDED: 629 preParseExtendedPlugins = 630 addPlugin(preParseExtendedPlugins, plugin, t, 631 pluginRootConfig.getPluginOrderPreParseExtended()); 632 break; 633 case PRE_PARSE_MODIFY: 634 preParseModifyPlugins = 635 addPlugin(preParseModifyPlugins, plugin, t, 636 pluginRootConfig.getPluginOrderPreParseModify()); 637 break; 638 case PRE_PARSE_MODIFY_DN: 639 preParseModifyDNPlugins = 640 addPlugin(preParseModifyDNPlugins, plugin, t, 641 pluginRootConfig.getPluginOrderPreParseModifyDN()); 642 break; 643 case PRE_PARSE_SEARCH: 644 preParseSearchPlugins = 645 addPlugin(preParseSearchPlugins, plugin, t, 646 pluginRootConfig.getPluginOrderPreParseSearch()); 647 break; 648 case PRE_PARSE_UNBIND: 649 preParseUnbindPlugins = 650 addPlugin(preParseUnbindPlugins, plugin, t, 651 pluginRootConfig.getPluginOrderPreParseUnbind()); 652 break; 653 case PRE_OPERATION_ADD: 654 preOperationAddPlugins = 655 addPlugin(preOperationAddPlugins, plugin, t, 656 pluginRootConfig.getPluginOrderPreOperationAdd()); 657 break; 658 case PRE_OPERATION_BIND: 659 preOperationBindPlugins = 660 addPlugin(preOperationBindPlugins, plugin, t, 661 pluginRootConfig.getPluginOrderPreOperationBind()); 662 break; 663 case PRE_OPERATION_COMPARE: 664 preOperationComparePlugins = 665 addPlugin(preOperationComparePlugins,plugin, t, 666 pluginRootConfig.getPluginOrderPreOperationCompare()); 667 break; 668 case PRE_OPERATION_DELETE: 669 preOperationDeletePlugins = 670 addPlugin(preOperationDeletePlugins, plugin, t, 671 pluginRootConfig.getPluginOrderPreOperationDelete()); 672 break; 673 case PRE_OPERATION_EXTENDED: 674 preOperationExtendedPlugins = 675 addPlugin(preOperationExtendedPlugins, plugin, t, 676 pluginRootConfig.getPluginOrderPreOperationExtended()); 677 break; 678 case PRE_OPERATION_MODIFY: 679 preOperationModifyPlugins = 680 addPlugin(preOperationModifyPlugins, plugin, t, 681 pluginRootConfig.getPluginOrderPreOperationModify()); 682 break; 683 case PRE_OPERATION_MODIFY_DN: 684 preOperationModifyDNPlugins = 685 addPlugin(preOperationModifyDNPlugins, plugin, t, 686 pluginRootConfig.getPluginOrderPreOperationModifyDN()); 687 break; 688 case PRE_OPERATION_SEARCH: 689 preOperationSearchPlugins = 690 addPlugin(preOperationSearchPlugins, plugin, t, 691 pluginRootConfig.getPluginOrderPreOperationSearch()); 692 break; 693 case POST_OPERATION_ABANDON: 694 postOperationAbandonPlugins = 695 addPlugin(postOperationAbandonPlugins, plugin, t, 696 pluginRootConfig.getPluginOrderPostOperationAbandon()); 697 break; 698 case POST_OPERATION_ADD: 699 postOperationAddPlugins = 700 addPlugin(postOperationAddPlugins, plugin, t, 701 pluginRootConfig.getPluginOrderPostOperationAdd()); 702 break; 703 case POST_OPERATION_BIND: 704 postOperationBindPlugins = 705 addPlugin(postOperationBindPlugins, plugin, t, 706 pluginRootConfig.getPluginOrderPostOperationBind()); 707 break; 708 case POST_OPERATION_COMPARE: 709 postOperationComparePlugins = 710 addPlugin(postOperationComparePlugins, plugin, t, 711 pluginRootConfig.getPluginOrderPostOperationCompare()); 712 break; 713 case POST_OPERATION_DELETE: 714 postOperationDeletePlugins = 715 addPlugin(postOperationDeletePlugins, plugin, t, 716 pluginRootConfig.getPluginOrderPostOperationDelete()); 717 break; 718 case POST_OPERATION_EXTENDED: 719 postOperationExtendedPlugins = 720 addPlugin(postOperationExtendedPlugins, plugin, t, 721 pluginRootConfig.getPluginOrderPostOperationExtended()); 722 break; 723 case POST_OPERATION_MODIFY: 724 postOperationModifyPlugins = 725 addPlugin(postOperationModifyPlugins, plugin, t, 726 pluginRootConfig.getPluginOrderPostOperationModify()); 727 break; 728 case POST_OPERATION_MODIFY_DN: 729 postOperationModifyDNPlugins = 730 addPlugin(postOperationModifyDNPlugins, plugin, t, 731 pluginRootConfig.getPluginOrderPostOperationModifyDN()); 732 break; 733 case POST_OPERATION_SEARCH: 734 postOperationSearchPlugins = 735 addPlugin(postOperationSearchPlugins, plugin, t, 736 pluginRootConfig.getPluginOrderPostOperationSearch()); 737 break; 738 case POST_OPERATION_UNBIND: 739 postOperationUnbindPlugins = 740 addPlugin(postOperationUnbindPlugins, plugin, t, 741 pluginRootConfig.getPluginOrderPostOperationUnbind()); 742 break; 743 case POST_RESPONSE_ADD: 744 postResponseAddPlugins = 745 addPlugin(postResponseAddPlugins, plugin, t, 746 pluginRootConfig.getPluginOrderPostResponseAdd()); 747 break; 748 case POST_RESPONSE_BIND: 749 postResponseBindPlugins = 750 addPlugin(postResponseBindPlugins, plugin, t, 751 pluginRootConfig.getPluginOrderPostResponseBind()); 752 break; 753 case POST_RESPONSE_COMPARE: 754 postResponseComparePlugins = 755 addPlugin(postResponseComparePlugins, plugin, t, 756 pluginRootConfig.getPluginOrderPostResponseCompare()); 757 break; 758 case POST_RESPONSE_DELETE: 759 postResponseDeletePlugins = 760 addPlugin(postResponseDeletePlugins, plugin, t, 761 pluginRootConfig.getPluginOrderPostResponseDelete()); 762 break; 763 case POST_RESPONSE_EXTENDED: 764 postResponseExtendedPlugins = 765 addPlugin(postResponseExtendedPlugins, plugin, t, 766 pluginRootConfig.getPluginOrderPostResponseExtended()); 767 break; 768 case POST_RESPONSE_MODIFY: 769 postResponseModifyPlugins = 770 addPlugin(postResponseModifyPlugins, plugin, t, 771 pluginRootConfig.getPluginOrderPostResponseModify()); 772 break; 773 case POST_RESPONSE_MODIFY_DN: 774 postResponseModifyDNPlugins = 775 addPlugin(postResponseModifyDNPlugins, plugin, t, 776 pluginRootConfig.getPluginOrderPostResponseModifyDN()); 777 break; 778 case POST_RESPONSE_SEARCH: 779 postResponseSearchPlugins = 780 addPlugin(postResponseSearchPlugins, plugin, t, 781 pluginRootConfig.getPluginOrderPostResponseSearch()); 782 break; 783 case POST_SYNCHRONIZATION_ADD: 784 postSynchronizationAddPlugins = 785 addPlugin(postSynchronizationAddPlugins, plugin, t, 786 pluginRootConfig. 787 getPluginOrderPostSynchronizationAdd()); 788 break; 789 case POST_SYNCHRONIZATION_DELETE: 790 postSynchronizationDeletePlugins = 791 addPlugin(postSynchronizationDeletePlugins, plugin, t, 792 pluginRootConfig. 793 getPluginOrderPostSynchronizationDelete()); 794 break; 795 case POST_SYNCHRONIZATION_MODIFY: 796 postSynchronizationModifyPlugins = 797 addPlugin(postSynchronizationModifyPlugins, plugin, t, 798 pluginRootConfig. 799 getPluginOrderPostSynchronizationModify()); 800 break; 801 case POST_SYNCHRONIZATION_MODIFY_DN: 802 postSynchronizationModifyDNPlugins = 803 addPlugin(postSynchronizationModifyDNPlugins, plugin, t, 804 pluginRootConfig. 805 getPluginOrderPostSynchronizationModifyDN()); 806 break; 807 case SEARCH_RESULT_ENTRY: 808 searchResultEntryPlugins = 809 addPlugin(searchResultEntryPlugins, plugin, t, 810 pluginRootConfig.getPluginOrderSearchResultEntry()); 811 break; 812 case SEARCH_RESULT_REFERENCE: 813 searchResultReferencePlugins = 814 addPlugin(searchResultReferencePlugins, plugin, t, 815 pluginRootConfig.getPluginOrderSearchResultReference()); 816 break; 817 case SUBORDINATE_MODIFY_DN: 818 subordinateModifyDNPlugins = 819 addPlugin(subordinateModifyDNPlugins, plugin, t, 820 pluginRootConfig.getPluginOrderSubordinateModifyDN()); 821 break; 822 case INTERMEDIATE_RESPONSE: 823 intermediateResponsePlugins = 824 addPlugin(intermediateResponsePlugins, plugin, t, 825 pluginRootConfig.getPluginOrderIntermediateResponse()); 826 break; 827 default: 828 } 829 } 830 } 831 finally 832 { 833 pluginLock.unlock(); 834 } 835 } 836 837 838 839 /** 840 * Adds the provided plugin to the given array. The provided array will not 841 * itself be modified, but rather a new array will be created with one 842 * additional element. The provided plugin will be the last element in the 843 * new array. 844 * <BR><BR> 845 * Note that the only use of this method outside of this class should be for 846 * testing purposes. 847 * 848 * @param pluginArray The array containing the existing set of plugins. 849 * @param plugin The plugin to be added to the array. 850 * @param pluginType The plugin type for the plugin being registered. 851 * @param pluginOrder A string that represents the order in which plugins of 852 * this type should be invoked, or {@code null} if the 853 * order is not considered important. 854 * 855 * @return The new array containing the new set of plugins. 856 */ 857 static DirectoryServerPlugin[] addPlugin(DirectoryServerPlugin[] pluginArray, 858 DirectoryServerPlugin plugin, 859 PluginType pluginType, 860 String pluginOrder) 861 { 862 // If the provided plugin order string is null, empty, or contains only a 863 // wildcard, then simply add the new plugin to the end of the list. 864 // Otherwise, parse the order string and figure out where to put the 865 // provided plugin. 866 if ((pluginOrder == null) || 867 ((pluginOrder = pluginOrder.trim()).length() == 0) || 868 pluginOrder.equals("*")) 869 { 870 DirectoryServerPlugin[] newPlugins = 871 new DirectoryServerPlugin[pluginArray.length+1]; 872 System.arraycopy(pluginArray, 0, newPlugins, 0, pluginArray.length); 873 newPlugins[pluginArray.length] = plugin; 874 875 return newPlugins; 876 } 877 else 878 { 879 // Parse the plugin order into initial and final plugin names. 880 boolean starFound = false; 881 LinkedHashSet<String> initialPluginNames = new LinkedHashSet<String>(); 882 LinkedHashSet<String> finalPluginNames = new LinkedHashSet<String>(); 883 884 StringTokenizer tokenizer = new StringTokenizer(pluginOrder, ","); 885 while (tokenizer.hasMoreTokens()) 886 { 887 String token = tokenizer.nextToken().trim(); 888 if (token.length() == 0) 889 { 890 // Only log the warning once per plugin type. The plugin array will 891 // be empty the first time through, so we can use that to make the 892 // determination. 893 if (pluginArray.length == 0) 894 { 895 Message message = WARN_CONFIG_PLUGIN_EMPTY_ELEMENT_IN_ORDER.get( 896 pluginType.getName()); 897 logError(message); 898 } 899 } 900 else if (token.equals("*")) 901 { 902 if (starFound) 903 { 904 // Only log the warning once per plugin type. The plugin array will 905 // be empty the first time through, so we can use that to make the 906 // determination. 907 if (pluginArray.length == 0) 908 { 909 Message message = WARN_CONFIG_PLUGIN_MULTIPLE_WILDCARDS_IN_ORDER. 910 get(pluginType.getName()); 911 logError(message); 912 } 913 } 914 else 915 { 916 starFound = true; 917 } 918 } 919 else 920 { 921 String lowerName = toLowerCase(token); 922 if (starFound) 923 { 924 if (initialPluginNames.contains(lowerName) || 925 finalPluginNames.contains(lowerName)) 926 { 927 // Only log the warning once per plugin type. The plugin array 928 // will be empty the first time through, so we can use that to 929 // make the determination. 930 if (pluginArray.length == 0) 931 { 932 Message message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get( 933 pluginType.getName(), token); 934 logError(message); 935 } 936 } 937 938 finalPluginNames.add(lowerName); 939 } 940 else 941 { 942 if (initialPluginNames.contains(lowerName)) 943 { 944 // Only log the warning once per plugin type. The plugin array 945 // will be empty the first time through, so we can use that to 946 // make the determination. 947 if (pluginArray.length == 0) 948 { 949 Message message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get( 950 pluginType.getName(), token); 951 logError(message); 952 } 953 } 954 955 initialPluginNames.add(lowerName); 956 } 957 } 958 } 959 960 if (! starFound) 961 { 962 // Only log the warning once per plugin type. The plugin array will be 963 // empty the first time through, so we can use that to make the 964 // determination. 965 if (pluginArray.length == 0) 966 { 967 Message message = 968 WARN_CONFIG_PLUGIN_ORDER_NO_WILDCARD.get(pluginType.getName()); 969 logError(message); 970 } 971 } 972 973 974 // Parse the array of already registered plugins to sort them accordingly. 975 HashMap<String,DirectoryServerPlugin> initialPlugins = 976 new HashMap<String,DirectoryServerPlugin>(initialPluginNames.size()); 977 HashMap<String,DirectoryServerPlugin> finalPlugins = 978 new HashMap<String,DirectoryServerPlugin>(finalPluginNames.size()); 979 ArrayList<DirectoryServerPlugin> otherPlugins = 980 new ArrayList<DirectoryServerPlugin>(); 981 for (DirectoryServerPlugin p : pluginArray) 982 { 983 DN dn = p.getPluginEntryDN(); 984 String lowerName = 985 toLowerCase(dn.getRDN().getAttributeValue(0).getStringValue()); 986 if (initialPluginNames.contains(lowerName)) 987 { 988 initialPlugins.put(lowerName, p); 989 } 990 else if (finalPluginNames.contains(lowerName)) 991 { 992 finalPlugins.put(lowerName, p); 993 } 994 else 995 { 996 otherPlugins.add(p); 997 } 998 } 999 1000 1001 // Get the name of the provided plugin from its RDN value and put it in 1002 // the correct category. 1003 DN dn = plugin.getPluginEntryDN(); 1004 String lowerName = 1005 toLowerCase(dn.getRDN().getAttributeValue(0).getStringValue()); 1006 if (initialPluginNames.contains(lowerName)) 1007 { 1008 initialPlugins.put(lowerName, plugin); 1009 } 1010 else if (finalPluginNames.contains(lowerName)) 1011 { 1012 finalPlugins.put(lowerName, plugin); 1013 } 1014 else 1015 { 1016 otherPlugins.add(plugin); 1017 } 1018 1019 1020 // Compile a list of all the plugins in the correct order, convert it to 1021 // an array, and return it. 1022 ArrayList<DirectoryServerPlugin> newList = 1023 new ArrayList<DirectoryServerPlugin>(pluginArray.length+1); 1024 for (String name : initialPluginNames) 1025 { 1026 DirectoryServerPlugin p = initialPlugins.get(name); 1027 if (p != null) 1028 { 1029 newList.add(p); 1030 } 1031 } 1032 1033 newList.addAll(otherPlugins); 1034 1035 for (String name : finalPluginNames) 1036 { 1037 DirectoryServerPlugin p = finalPlugins.get(name); 1038 if (p != null) 1039 { 1040 newList.add(p); 1041 } 1042 } 1043 1044 DirectoryServerPlugin[] newPlugins = 1045 new DirectoryServerPlugin[newList.size()]; 1046 newList.toArray(newPlugins); 1047 return newPlugins; 1048 } 1049 } 1050 1051 1052 1053 /** 1054 * Deregisters the plugin with the provided configuration entry DN. 1055 * 1056 * @param configEntryDN The DN of the configuration entry for the plugin to 1057 * deregister. 1058 */ 1059 private void deregisterPlugin(DN configEntryDN) 1060 { 1061 pluginLock.lock(); 1062 1063 DirectoryServerPlugin<? extends PluginCfg> plugin; 1064 try 1065 { 1066 plugin = registeredPlugins.remove(configEntryDN); 1067 if (plugin == null) 1068 { 1069 return; 1070 } 1071 1072 for (PluginType t : plugin.getPluginTypes()) 1073 { 1074 switch (t) 1075 { 1076 case STARTUP: 1077 startupPlugins = removePlugin(startupPlugins, plugin); 1078 break; 1079 case SHUTDOWN: 1080 shutdownPlugins = removePlugin(shutdownPlugins, plugin); 1081 break; 1082 case POST_CONNECT: 1083 postConnectPlugins = removePlugin(postConnectPlugins, plugin); 1084 break; 1085 case POST_DISCONNECT: 1086 postDisconnectPlugins = removePlugin(postDisconnectPlugins, plugin); 1087 break; 1088 case LDIF_IMPORT: 1089 ldifImportPlugins = removePlugin(ldifImportPlugins, plugin); 1090 break; 1091 case LDIF_EXPORT: 1092 ldifExportPlugins = removePlugin(ldifExportPlugins, plugin); 1093 break; 1094 case PRE_PARSE_ABANDON: 1095 preParseAbandonPlugins = removePlugin(preParseAbandonPlugins, 1096 plugin); 1097 break; 1098 case PRE_PARSE_ADD: 1099 preParseAddPlugins = removePlugin(preParseAddPlugins, plugin); 1100 break; 1101 case PRE_PARSE_BIND: 1102 preParseBindPlugins = removePlugin(preParseBindPlugins, plugin); 1103 break; 1104 case PRE_PARSE_COMPARE: 1105 preParseComparePlugins = removePlugin(preParseComparePlugins, 1106 plugin); 1107 break; 1108 case PRE_PARSE_DELETE: 1109 preParseDeletePlugins = removePlugin(preParseDeletePlugins, plugin); 1110 break; 1111 case PRE_PARSE_EXTENDED: 1112 preParseExtendedPlugins = removePlugin(preParseExtendedPlugins, 1113 plugin); 1114 break; 1115 case PRE_PARSE_MODIFY: 1116 preParseModifyPlugins = removePlugin(preParseModifyPlugins, plugin); 1117 break; 1118 case PRE_PARSE_MODIFY_DN: 1119 preParseModifyDNPlugins = removePlugin(preParseModifyDNPlugins, 1120 plugin); 1121 break; 1122 case PRE_PARSE_SEARCH: 1123 preParseSearchPlugins = removePlugin(preParseSearchPlugins, plugin); 1124 break; 1125 case PRE_PARSE_UNBIND: 1126 preParseUnbindPlugins = removePlugin(preParseUnbindPlugins, plugin); 1127 break; 1128 case PRE_OPERATION_ADD: 1129 preOperationAddPlugins = removePlugin(preOperationAddPlugins, 1130 plugin); 1131 break; 1132 case PRE_OPERATION_BIND: 1133 preOperationBindPlugins = removePlugin(preOperationBindPlugins, 1134 plugin); 1135 break; 1136 case PRE_OPERATION_COMPARE: 1137 preOperationComparePlugins = 1138 removePlugin(preOperationComparePlugins, plugin); 1139 break; 1140 case PRE_OPERATION_DELETE: 1141 preOperationDeletePlugins = removePlugin(preOperationDeletePlugins, 1142 plugin); 1143 break; 1144 case PRE_OPERATION_EXTENDED: 1145 preOperationExtendedPlugins = 1146 removePlugin(preOperationExtendedPlugins, plugin); 1147 break; 1148 case PRE_OPERATION_MODIFY: 1149 preOperationModifyPlugins = removePlugin(preOperationModifyPlugins, 1150 plugin); 1151 break; 1152 case PRE_OPERATION_MODIFY_DN: 1153 preOperationModifyDNPlugins = 1154 removePlugin(preOperationModifyDNPlugins, plugin); 1155 break; 1156 case PRE_OPERATION_SEARCH: 1157 preOperationSearchPlugins = removePlugin(preOperationSearchPlugins, 1158 plugin); 1159 break; 1160 case POST_OPERATION_ABANDON: 1161 postOperationAbandonPlugins = 1162 removePlugin(postOperationAbandonPlugins, plugin); 1163 break; 1164 case POST_OPERATION_ADD: 1165 postOperationAddPlugins = removePlugin(postOperationAddPlugins, 1166 plugin); 1167 break; 1168 case POST_OPERATION_BIND: 1169 postOperationBindPlugins = removePlugin(postOperationBindPlugins, 1170 plugin); 1171 break; 1172 case POST_OPERATION_COMPARE: 1173 postOperationComparePlugins = 1174 removePlugin(postOperationComparePlugins, plugin); 1175 break; 1176 case POST_OPERATION_DELETE: 1177 postOperationDeletePlugins = 1178 removePlugin(postOperationDeletePlugins, plugin); 1179 break; 1180 case POST_OPERATION_EXTENDED: 1181 postOperationExtendedPlugins = 1182 removePlugin(postOperationExtendedPlugins, plugin); 1183 break; 1184 case POST_OPERATION_MODIFY: 1185 postOperationModifyPlugins = 1186 removePlugin(postOperationModifyPlugins, plugin); 1187 break; 1188 case POST_OPERATION_MODIFY_DN: 1189 postOperationModifyDNPlugins = 1190 removePlugin(postOperationModifyDNPlugins, plugin); 1191 break; 1192 case POST_OPERATION_SEARCH: 1193 postOperationSearchPlugins = 1194 removePlugin(postOperationSearchPlugins, plugin); 1195 break; 1196 case POST_OPERATION_UNBIND: 1197 postOperationUnbindPlugins = 1198 removePlugin(postOperationUnbindPlugins, plugin); 1199 break; 1200 case POST_RESPONSE_ADD: 1201 postResponseAddPlugins = removePlugin(postResponseAddPlugins, 1202 plugin); 1203 break; 1204 case POST_RESPONSE_BIND: 1205 postResponseBindPlugins = removePlugin(postResponseBindPlugins, 1206 plugin); 1207 break; 1208 case POST_RESPONSE_COMPARE: 1209 postResponseComparePlugins = 1210 removePlugin(postResponseComparePlugins, plugin); 1211 break; 1212 case POST_RESPONSE_DELETE: 1213 postResponseDeletePlugins = removePlugin(postResponseDeletePlugins, 1214 plugin); 1215 break; 1216 case POST_RESPONSE_EXTENDED: 1217 postResponseExtendedPlugins = 1218 removePlugin(postResponseExtendedPlugins, plugin); 1219 break; 1220 case POST_RESPONSE_MODIFY: 1221 postResponseModifyPlugins = removePlugin(postResponseModifyPlugins, 1222 plugin); 1223 break; 1224 case POST_RESPONSE_MODIFY_DN: 1225 postResponseModifyDNPlugins = 1226 removePlugin(postResponseModifyDNPlugins, plugin); 1227 break; 1228 case POST_RESPONSE_SEARCH: 1229 postResponseSearchPlugins = removePlugin(postResponseSearchPlugins, 1230 plugin); 1231 break; 1232 case POST_SYNCHRONIZATION_ADD: 1233 postSynchronizationAddPlugins = 1234 removePlugin(postSynchronizationAddPlugins, plugin); 1235 break; 1236 case POST_SYNCHRONIZATION_DELETE: 1237 postSynchronizationDeletePlugins = 1238 removePlugin(postSynchronizationDeletePlugins, plugin); 1239 break; 1240 case POST_SYNCHRONIZATION_MODIFY: 1241 postSynchronizationModifyPlugins = 1242 removePlugin(postSynchronizationModifyPlugins, plugin); 1243 break; 1244 case POST_SYNCHRONIZATION_MODIFY_DN: 1245 postSynchronizationModifyDNPlugins = 1246 removePlugin(postSynchronizationModifyDNPlugins, plugin); 1247 break; 1248 case SEARCH_RESULT_ENTRY: 1249 searchResultEntryPlugins = removePlugin(searchResultEntryPlugins, 1250 plugin); 1251 break; 1252 case SEARCH_RESULT_REFERENCE: 1253 searchResultReferencePlugins = 1254 removePlugin(searchResultReferencePlugins, plugin); 1255 break; 1256 case SUBORDINATE_MODIFY_DN: 1257 subordinateModifyDNPlugins = 1258 removePlugin(subordinateModifyDNPlugins, plugin); 1259 break; 1260 case INTERMEDIATE_RESPONSE: 1261 intermediateResponsePlugins = 1262 removePlugin(intermediateResponsePlugins, plugin); 1263 break; 1264 default: 1265 } 1266 } 1267 } 1268 finally 1269 { 1270 pluginLock.unlock(); 1271 } 1272 1273 plugin.finalizePlugin(); 1274 } 1275 1276 1277 1278 /** 1279 * Removes the provided plugin from the given array. The provided array will 1280 * not itself be modified, but rather a new array will be created with one 1281 * fewer element (assuming that the specified plugin was found). 1282 * 1283 * @param pluginArray The array containing the existing set of plugins. 1284 * @param plugin The plugin to be removed from the array. 1285 * 1286 * @return The new array containing the new set of plugins. 1287 */ 1288 private DirectoryServerPlugin[] 1289 removePlugin(DirectoryServerPlugin[] pluginArray, 1290 DirectoryServerPlugin plugin) 1291 { 1292 int slot = -1; 1293 int length = pluginArray.length; 1294 for (int i=0; i < length; i++) 1295 { 1296 if (pluginArray[i].getPluginEntryDN().equals(plugin.getPluginEntryDN())) 1297 { 1298 slot = i; 1299 break; 1300 } 1301 } 1302 1303 if (slot < 0) 1304 { 1305 // The plugin wasn't found in the list, so return the same list. 1306 return pluginArray; 1307 } 1308 1309 1310 // If it was the only element in the array, then return an empty array. 1311 if (length == 0) 1312 { 1313 return new DirectoryServerPlugin[0]; 1314 } 1315 1316 1317 // Create an array that's one element smaller and copy the remaining "good" 1318 // elements into it. 1319 DirectoryServerPlugin[] newPlugins = new DirectoryServerPlugin[length-1]; 1320 if (slot > 0) 1321 { 1322 System.arraycopy(pluginArray, 0, newPlugins, 0, slot); 1323 } 1324 1325 if (slot < (length-1)) 1326 { 1327 System.arraycopy(pluginArray, slot+1, newPlugins, slot, (length-slot-1)); 1328 } 1329 1330 return newPlugins; 1331 } 1332 1333 1334 1335 /** 1336 * Invokes the set of startup plugins that have been registered with the 1337 * Directory Server. 1338 * 1339 * @return The result of processing the startup plugins. 1340 */ 1341 public PluginResult.Startup invokeStartupPlugins() 1342 { 1343 PluginResult.Startup result = null; 1344 1345 for (DirectoryServerPlugin p : startupPlugins) 1346 { 1347 try 1348 { 1349 result = p.doStartup(); 1350 } 1351 catch (Exception e) 1352 { 1353 if (debugEnabled()) 1354 { 1355 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1356 } 1357 1358 Message message = ERR_PLUGIN_STARTUP_PLUGIN_EXCEPTION.get( 1359 String.valueOf(p.getPluginEntryDN()), 1360 stackTraceToSingleLineString(e)); 1361 1362 return PluginResult.Startup.stopStartup(message); 1363 } 1364 1365 if (result == null) 1366 { 1367 Message message = ERR_PLUGIN_STARTUP_PLUGIN_RETURNED_NULL.get( 1368 String.valueOf(p.getPluginEntryDN())); 1369 logError(message); 1370 return PluginResult.Startup.stopStartup(message); 1371 } 1372 else if (! result.continueProcessing()) 1373 { 1374 Message message = ERR_PLUGIN_STARTUP_PLUGIN_FAIL_ABORT. 1375 get(String.valueOf(p.getPluginEntryDN()), 1376 result.getErrorMessage(), 1377 result.getErrorMessage().getDescriptor().getId()); 1378 logError(message); 1379 return result; 1380 } 1381 } 1382 1383 if (result == null) 1384 { 1385 // This should only happen if there were no startup plugins registered, 1386 // which is fine. 1387 result = PluginResult.Startup.continueStartup(); 1388 } 1389 1390 return result; 1391 } 1392 1393 1394 1395 /** 1396 * Invokes the set of shutdown plugins that have been configured in the 1397 * Directory Server. 1398 * 1399 * @param reason The human-readable reason for the shutdown. 1400 */ 1401 public void invokeShutdownPlugins(Message reason) 1402 { 1403 for (DirectoryServerPlugin p : shutdownPlugins) 1404 { 1405 try 1406 { 1407 p.doShutdown(reason); 1408 } 1409 catch (Exception e) 1410 { 1411 if (debugEnabled()) 1412 { 1413 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1414 } 1415 1416 Message message = ERR_PLUGIN_SHUTDOWN_PLUGIN_EXCEPTION. 1417 get(String.valueOf(p.getPluginEntryDN()), 1418 stackTraceToSingleLineString(e)); 1419 logError(message); 1420 } 1421 } 1422 } 1423 1424 1425 1426 /** 1427 * Invokes the set of post-connect plugins that have been configured in the 1428 * Directory Server. 1429 * 1430 * @param clientConnection The client connection that has been established. 1431 * 1432 * @return The result of processing the post-connect plugins. 1433 */ 1434 public PluginResult.PostConnect invokePostConnectPlugins(ClientConnection 1435 clientConnection) 1436 { 1437 PluginResult.PostConnect result = null; 1438 1439 for (DirectoryServerPlugin p : postConnectPlugins) 1440 { 1441 try 1442 { 1443 result = p.doPostConnect(clientConnection); 1444 } 1445 catch (Exception e) 1446 { 1447 if (debugEnabled()) 1448 { 1449 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1450 } 1451 1452 Message message = ERR_PLUGIN_POST_CONNECT_PLUGIN_EXCEPTION. 1453 get(String.valueOf(p.getPluginEntryDN()), 1454 clientConnection.getConnectionID(), 1455 clientConnection.getClientAddress(), 1456 stackTraceToSingleLineString(e)); 1457 logError(message); 1458 1459 return PluginResult.PostConnect.disconnectClient( 1460 DisconnectReason.SERVER_ERROR, true, message); 1461 } 1462 1463 1464 if (result == null) 1465 { 1466 Message message = ERR_PLUGIN_POST_CONNECT_PLUGIN_RETURNED_NULL. 1467 get(String.valueOf(p.getPluginEntryDN()), 1468 clientConnection.getConnectionID(), 1469 clientConnection.getClientAddress()); 1470 logError(message); 1471 1472 return PluginResult.PostConnect.disconnectClient( 1473 DisconnectReason.SERVER_ERROR, true, message); 1474 } 1475 else if (!result.continuePluginProcessing()) 1476 { 1477 return result; 1478 } 1479 } 1480 1481 if (result == null) 1482 { 1483 // This should only happen if there were no post-connect plugins 1484 // registered, which is fine. 1485 result = PluginResult.PostConnect.continueConnectProcessing(); 1486 } 1487 1488 return result; 1489 } 1490 1491 1492 1493 /** 1494 * Invokes the set of post-disconnect plugins that have been configured in the 1495 * Directory Server. 1496 * 1497 * @param clientConnection The client connection that has been closed. 1498 * @param disconnectReason The general reason that the connection was 1499 * closed. 1500 * @param message A human-readable message that may provide 1501 * additional information about the closure. 1502 * 1503 * @return The result of processing the post-connect plugins. 1504 */ 1505 public PluginResult.PostDisconnect invokePostDisconnectPlugins( 1506 ClientConnection clientConnection, 1507 DisconnectReason disconnectReason, 1508 Message message) 1509 { 1510 PluginResult.PostDisconnect result = null; 1511 1512 for (DirectoryServerPlugin p : postDisconnectPlugins) 1513 { 1514 try 1515 { 1516 result = p.doPostDisconnect(clientConnection, disconnectReason, 1517 message); 1518 } 1519 catch (Exception e) 1520 { 1521 if (debugEnabled()) 1522 { 1523 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1524 } 1525 1526 Message msg = ERR_PLUGIN_POST_DISCONNECT_PLUGIN_EXCEPTION. 1527 get(String.valueOf(p.getPluginEntryDN()), 1528 clientConnection.getConnectionID(), 1529 clientConnection.getClientAddress(), 1530 stackTraceToSingleLineString(e)); 1531 logError(msg); 1532 } 1533 1534 1535 if (result == null) 1536 { 1537 Message msg = ERR_PLUGIN_POST_DISCONNECT_PLUGIN_RETURNED_NULL. 1538 get(String.valueOf(p.getPluginEntryDN()), 1539 clientConnection.getConnectionID(), 1540 clientConnection.getClientAddress()); 1541 logError(msg); 1542 } 1543 else if (! result.continuePluginProcessing()) 1544 { 1545 return result; 1546 } 1547 } 1548 1549 if (result == null) 1550 { 1551 // This should only happen if there were no post-disconnect plugins 1552 // registered, which is fine. 1553 result = PluginResult.PostDisconnect.continueDisconnectProcessing(); 1554 } 1555 1556 return result; 1557 } 1558 1559 1560 1561 /** 1562 * Invokes the set of LDIF import plugins that have been configured in the 1563 * Directory Server. 1564 * 1565 * @param importConfig The LDIF import configuration used to read the 1566 * associated entry. 1567 * @param entry The entry that has been read from LDIF. 1568 * 1569 * @return The result of processing the LDIF import plugins. 1570 */ 1571 public PluginResult.ImportLDIF invokeLDIFImportPlugins( 1572 LDIFImportConfig importConfig, Entry entry) 1573 { 1574 PluginResult.ImportLDIF result = null; 1575 1576 for (DirectoryServerPlugin p : ldifImportPlugins) 1577 { 1578 try 1579 { 1580 result = p.doLDIFImport(importConfig, entry); 1581 } 1582 catch (Exception e) 1583 { 1584 if (debugEnabled()) 1585 { 1586 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1587 } 1588 1589 Message message = ERR_PLUGIN_LDIF_IMPORT_PLUGIN_EXCEPTION. 1590 get(String.valueOf(p.getPluginEntryDN()), 1591 String.valueOf(entry.getDN()), stackTraceToSingleLineString(e)); 1592 logError(message); 1593 1594 return PluginResult.ImportLDIF.stopEntryProcessing(message); 1595 } 1596 1597 if (result == null) 1598 { 1599 Message message = ERR_PLUGIN_LDIF_IMPORT_PLUGIN_RETURNED_NULL. 1600 get(String.valueOf(p.getPluginEntryDN()), 1601 String.valueOf(entry.getDN())); 1602 logError(message); 1603 1604 return PluginResult.ImportLDIF.stopEntryProcessing(message); 1605 } 1606 else if (! result.continuePluginProcessing()) 1607 { 1608 return result; 1609 } 1610 } 1611 1612 if (result == null) 1613 { 1614 // This should only happen if there were no LDIF import plugins 1615 // registered, which is fine. 1616 result = PluginResult.ImportLDIF.continueEntryProcessing(); 1617 } 1618 1619 return result; 1620 } 1621 1622 1623 1624 /** 1625 * Invokes the set of LDIF export plugins that have been configured in the 1626 * Directory Server. 1627 * 1628 * @param exportConfig The LDIF export configuration used to read the 1629 * associated entry. 1630 * @param entry The entry that has been read from LDIF. 1631 * 1632 * @return The result of processing the LDIF export plugins. 1633 */ 1634 public PluginResult.ImportLDIF invokeLDIFExportPlugins( 1635 LDIFExportConfig exportConfig, Entry entry) 1636 { 1637 PluginResult.ImportLDIF result = null; 1638 1639 for (DirectoryServerPlugin p : ldifExportPlugins) 1640 { 1641 try 1642 { 1643 result = p.doLDIFExport(exportConfig, entry); 1644 } 1645 catch (Exception e) 1646 { 1647 if (debugEnabled()) 1648 { 1649 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1650 } 1651 1652 Message message = ERR_PLUGIN_LDIF_EXPORT_PLUGIN_EXCEPTION. 1653 get(String.valueOf(p.getPluginEntryDN()), 1654 String.valueOf(entry.getDN()), stackTraceToSingleLineString(e)); 1655 logError(message); 1656 1657 return PluginResult.ImportLDIF.stopEntryProcessing(message); 1658 } 1659 1660 if (result == null) 1661 { 1662 Message message = ERR_PLUGIN_LDIF_EXPORT_PLUGIN_RETURNED_NULL. 1663 get(String.valueOf(p.getPluginEntryDN()), 1664 String.valueOf(entry.getDN())); 1665 logError(message); 1666 1667 return PluginResult.ImportLDIF.stopEntryProcessing(message); 1668 } 1669 else if (! result.continuePluginProcessing()) 1670 { 1671 return result; 1672 } 1673 } 1674 1675 if (result == null) 1676 { 1677 // This should only happen if there were no LDIF export plugins 1678 // registered, which is fine. 1679 result = PluginResult.ImportLDIF.continueEntryProcessing(); 1680 } 1681 1682 return result; 1683 } 1684 1685 1686 1687 /** 1688 * Invokes the set of pre-parse abandon plugins that have been configured in 1689 * the Directory Server. 1690 * 1691 * @param abandonOperation The abandon operation for which to invoke the 1692 * pre-parse plugins. 1693 * 1694 * @return The result of processing the pre-parse abandon plugins. 1695 */ 1696 public PluginResult.PreParse invokePreParseAbandonPlugins( 1697 PreParseAbandonOperation abandonOperation) 1698 { 1699 PluginResult.PreParse result = null; 1700 1701 for (DirectoryServerPlugin p : preParseAbandonPlugins) 1702 { 1703 if (abandonOperation.isInternalOperation() && 1704 (! p.invokeForInternalOperations())) 1705 { 1706 continue; 1707 } 1708 1709 try 1710 { 1711 result = p.doPreParse(abandonOperation); 1712 } 1713 catch (Exception e) 1714 { 1715 if (debugEnabled()) 1716 { 1717 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1718 } 1719 1720 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 1721 get(abandonOperation.getOperationType().getOperationName(), 1722 String.valueOf(p.getPluginEntryDN()), 1723 abandonOperation.getConnectionID(), 1724 abandonOperation.getOperationID(), 1725 stackTraceToSingleLineString(e)); 1726 logError(message); 1727 1728 return PluginResult.PreParse.stopProcessing( 1729 DirectoryServer.getServerErrorResultCode(), message); 1730 } 1731 1732 if (result == null) 1733 { 1734 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 1735 get(abandonOperation.getOperationType().getOperationName(), 1736 String.valueOf(p.getPluginEntryDN()), 1737 abandonOperation.getConnectionID(), 1738 String.valueOf(abandonOperation.getOperationID())); 1739 logError(message); 1740 1741 return PluginResult.PreParse.stopProcessing( 1742 DirectoryServer.getServerErrorResultCode(), message); 1743 } 1744 else if (!result.continuePluginProcessing()) 1745 { 1746 return result; 1747 } 1748 } 1749 1750 if (result == null) 1751 { 1752 // This should only happen if there were no pre-parse abandon plugins 1753 // registered, which is fine. 1754 result = PluginResult.PreParse.continueOperationProcessing(); 1755 } 1756 1757 return result; 1758 } 1759 1760 1761 1762 /** 1763 * Invokes the set of pre-parse add plugins that have been configured in the 1764 * Directory Server. 1765 * 1766 * @param addOperation The add operation for which to invoke the pre-parse 1767 * plugins. 1768 * 1769 * @return The result of processing the pre-parse add plugins. 1770 * 1771 * @throws CanceledOperationException if the operation should be canceled. 1772 */ 1773 public PluginResult.PreParse invokePreParseAddPlugins( 1774 PreParseAddOperation addOperation) 1775 throws CanceledOperationException { 1776 PluginResult.PreParse result = null; 1777 1778 for (DirectoryServerPlugin p : preParseAddPlugins) 1779 { 1780 if (addOperation.isInternalOperation() && 1781 (! p.invokeForInternalOperations())) 1782 { 1783 continue; 1784 } 1785 1786 try 1787 { 1788 result = p.doPreParse(addOperation); 1789 } 1790 catch (CanceledOperationException coe) 1791 { 1792 throw coe; 1793 } 1794 catch (Exception e) 1795 { 1796 if (debugEnabled()) 1797 { 1798 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1799 } 1800 1801 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 1802 get(addOperation.getOperationType().getOperationName(), 1803 String.valueOf(p.getPluginEntryDN()), 1804 addOperation.getConnectionID(), addOperation.getOperationID(), 1805 stackTraceToSingleLineString(e)); 1806 logError(message); 1807 1808 return PluginResult.PreParse.stopProcessing( 1809 DirectoryServer.getServerErrorResultCode(), message); 1810 } 1811 1812 if (result == null) 1813 { 1814 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 1815 get(addOperation.getOperationType().getOperationName(), 1816 String.valueOf(p.getPluginEntryDN()), 1817 addOperation.getConnectionID(), 1818 String.valueOf(addOperation.getOperationID())); 1819 logError(message); 1820 1821 return PluginResult.PreParse.stopProcessing( 1822 DirectoryServer.getServerErrorResultCode(), message); 1823 } 1824 else if (!result.continuePluginProcessing()) 1825 { 1826 return result; 1827 } 1828 } 1829 1830 if (result == null) 1831 { 1832 // This should only happen if there were no pre-parse add plugins 1833 // registered, which is fine. 1834 result = PluginResult.PreParse.continueOperationProcessing(); 1835 } 1836 1837 return result; 1838 } 1839 1840 1841 1842 /** 1843 * Invokes the set of pre-parse bind plugins that have been configured in 1844 * the Directory Server. 1845 * 1846 * @param bindOperation The bind operation for which to invoke the pre-parse 1847 * plugins. 1848 * 1849 * @return The result of processing the pre-parse bind plugins. 1850 */ 1851 public PluginResult.PreParse invokePreParseBindPlugins( 1852 PreParseBindOperation bindOperation) 1853 { 1854 PluginResult.PreParse result = null; 1855 1856 for (DirectoryServerPlugin p : preParseBindPlugins) 1857 { 1858 if (bindOperation.isInternalOperation() && 1859 (! p.invokeForInternalOperations())) 1860 { 1861 continue; 1862 } 1863 1864 try 1865 { 1866 result = p.doPreParse(bindOperation); 1867 } 1868 catch (Exception e) 1869 { 1870 if (debugEnabled()) 1871 { 1872 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1873 } 1874 1875 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 1876 get(bindOperation.getOperationType().getOperationName(), 1877 String.valueOf(p.getPluginEntryDN()), 1878 bindOperation.getConnectionID(), bindOperation.getOperationID(), 1879 stackTraceToSingleLineString(e)); 1880 logError(message); 1881 1882 return PluginResult.PreParse.stopProcessing( 1883 DirectoryServer.getServerErrorResultCode(), message); 1884 } 1885 1886 if (result == null) 1887 { 1888 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 1889 get(bindOperation.getOperationType().getOperationName(), 1890 String.valueOf(p.getPluginEntryDN()), 1891 bindOperation.getConnectionID(), 1892 String.valueOf(bindOperation.getOperationID())); 1893 logError(message); 1894 1895 return PluginResult.PreParse.stopProcessing( 1896 DirectoryServer.getServerErrorResultCode(), message); 1897 } 1898 else if (!result.continuePluginProcessing()) 1899 { 1900 return result; 1901 } 1902 } 1903 1904 if (result == null) 1905 { 1906 // This should only happen if there were no pre-parse bind plugins 1907 // registered, which is fine. 1908 result = PluginResult.PreParse.continueOperationProcessing(); 1909 } 1910 1911 return result; 1912 } 1913 1914 1915 1916 /** 1917 * Invokes the set of pre-parse compare plugins that have been configured in 1918 * the Directory Server. 1919 * 1920 * @param compareOperation The compare operation for which to invoke the 1921 * pre-parse plugins. 1922 * 1923 * @return The result of processing the pre-parse compare plugins. 1924 * 1925 * @throws CanceledOperationException if the operation should be canceled. 1926 */ 1927 public PluginResult.PreParse invokePreParseComparePlugins( 1928 PreParseCompareOperation compareOperation) 1929 throws CanceledOperationException { 1930 PluginResult.PreParse result = null; 1931 1932 for (DirectoryServerPlugin p : preParseComparePlugins) 1933 { 1934 if (compareOperation.isInternalOperation() && 1935 (! p.invokeForInternalOperations())) 1936 { 1937 continue; 1938 } 1939 1940 try 1941 { 1942 result = p.doPreParse(compareOperation); 1943 } 1944 catch (CanceledOperationException coe) 1945 { 1946 throw coe; 1947 } 1948 catch (Exception e) 1949 { 1950 if (debugEnabled()) 1951 { 1952 TRACER.debugCaught(DebugLogLevel.ERROR, e); 1953 } 1954 1955 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 1956 get(compareOperation.getOperationType().getOperationName(), 1957 String.valueOf(p.getPluginEntryDN()), 1958 compareOperation.getConnectionID(), 1959 compareOperation.getOperationID(), 1960 stackTraceToSingleLineString(e)); 1961 logError(message); 1962 1963 return PluginResult.PreParse.stopProcessing( 1964 DirectoryServer.getServerErrorResultCode(), message); 1965 } 1966 1967 if (result == null) 1968 { 1969 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 1970 get(compareOperation.getOperationType().getOperationName(), 1971 String.valueOf(p.getPluginEntryDN()), 1972 compareOperation.getConnectionID(), 1973 String.valueOf(compareOperation.getOperationID())); 1974 logError(message); 1975 1976 return PluginResult.PreParse.stopProcessing( 1977 DirectoryServer.getServerErrorResultCode(), message); 1978 } 1979 else if (!result.continuePluginProcessing()) 1980 { 1981 return result; 1982 } 1983 } 1984 1985 if (result == null) 1986 { 1987 // This should only happen if there were no pre-parse compare plugins 1988 // registered, which is fine. 1989 result = PluginResult.PreParse.continueOperationProcessing(); 1990 } 1991 1992 return result; 1993 } 1994 1995 1996 1997 /** 1998 * Invokes the set of pre-parse delete plugins that have been configured in 1999 * the Directory Server. 2000 * 2001 * @param deleteOperation The delete operation for which to invoke the 2002 * pre-parse plugins. 2003 * 2004 * @return The result of processing the pre-parse delete plugins. 2005 * 2006 * @throws CanceledOperationException if the operation should be canceled. 2007 */ 2008 public PluginResult.PreParse invokePreParseDeletePlugins( 2009 PreParseDeleteOperation deleteOperation) 2010 throws CanceledOperationException { 2011 PluginResult.PreParse result = null; 2012 2013 for (DirectoryServerPlugin p : preParseDeletePlugins) 2014 { 2015 if (deleteOperation.isInternalOperation() && 2016 (! p.invokeForInternalOperations())) 2017 { 2018 continue; 2019 } 2020 2021 try 2022 { 2023 result = p.doPreParse(deleteOperation); 2024 } 2025 catch (CanceledOperationException coe) 2026 { 2027 throw coe; 2028 } 2029 catch (Exception e) 2030 { 2031 if (debugEnabled()) 2032 { 2033 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2034 } 2035 2036 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2037 get(deleteOperation.getOperationType().getOperationName(), 2038 String.valueOf(p.getPluginEntryDN()), 2039 deleteOperation.getConnectionID(), 2040 deleteOperation.getOperationID(), 2041 stackTraceToSingleLineString(e)); 2042 logError(message); 2043 2044 return PluginResult.PreParse.stopProcessing( 2045 DirectoryServer.getServerErrorResultCode(), message); 2046 } 2047 2048 if (result == null) 2049 { 2050 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2051 get(deleteOperation.getOperationType().getOperationName(), 2052 String.valueOf(p.getPluginEntryDN()), 2053 deleteOperation.getConnectionID(), 2054 String.valueOf(deleteOperation.getOperationID())); 2055 logError(message); 2056 2057 return PluginResult.PreParse.stopProcessing( 2058 DirectoryServer.getServerErrorResultCode(), message); 2059 } 2060 else if (!result.continuePluginProcessing()) 2061 { 2062 return result; 2063 } 2064 } 2065 2066 if (result == null) 2067 { 2068 // This should only happen if there were no pre-parse delete plugins 2069 // registered, which is fine. 2070 result = PluginResult.PreParse.continueOperationProcessing(); 2071 } 2072 2073 return result; 2074 } 2075 2076 2077 2078 /** 2079 * Invokes the set of pre-parse extended plugins that have been configured in 2080 * the Directory Server. 2081 * 2082 * @param extendedOperation The extended operation for which to invoke the 2083 * pre-parse plugins. 2084 * 2085 * @return The result of processing the pre-parse extended plugins. 2086 * 2087 * @throws CanceledOperationException if the operation should be canceled. 2088 */ 2089 public PluginResult.PreParse invokePreParseExtendedPlugins( 2090 PreParseExtendedOperation extendedOperation) 2091 throws CanceledOperationException { 2092 PluginResult.PreParse result = null; 2093 2094 for (DirectoryServerPlugin p : preParseExtendedPlugins) 2095 { 2096 if (extendedOperation.isInternalOperation() && 2097 (! p.invokeForInternalOperations())) 2098 { 2099 continue; 2100 } 2101 2102 try 2103 { 2104 result = p.doPreParse(extendedOperation); 2105 } 2106 catch (CanceledOperationException coe) 2107 { 2108 throw coe; 2109 } 2110 catch (Exception e) 2111 { 2112 if (debugEnabled()) 2113 { 2114 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2115 } 2116 2117 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2118 get(extendedOperation.getOperationType().getOperationName(), 2119 String.valueOf(p.getPluginEntryDN()), 2120 extendedOperation.getConnectionID(), 2121 extendedOperation.getOperationID(), 2122 stackTraceToSingleLineString(e)); 2123 logError(message); 2124 2125 return PluginResult.PreParse.stopProcessing( 2126 DirectoryServer.getServerErrorResultCode(), message); 2127 } 2128 2129 if (result == null) 2130 { 2131 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2132 get(extendedOperation.getOperationType().getOperationName(), 2133 String.valueOf(p.getPluginEntryDN()), 2134 extendedOperation.getConnectionID(), 2135 String.valueOf(extendedOperation.getOperationID())); 2136 logError(message); 2137 2138 return PluginResult.PreParse.stopProcessing( 2139 DirectoryServer.getServerErrorResultCode(), message); 2140 } 2141 else if (!result.continuePluginProcessing()) 2142 { 2143 return result; 2144 } 2145 } 2146 2147 if (result == null) 2148 { 2149 // This should only happen if there were no pre-parse extended plugins 2150 // registered, which is fine. 2151 result = PluginResult.PreParse.continueOperationProcessing(); 2152 } 2153 2154 return result; 2155 } 2156 2157 2158 2159 /** 2160 * Invokes the set of pre-parse modify plugins that have been configured in 2161 * the Directory Server. 2162 * 2163 * @param modifyOperation The modify operation for which to invoke the 2164 * pre-parse plugins. 2165 * 2166 * @return The result of processing the pre-parse modify plugins. 2167 * 2168 * @throws CanceledOperationException if the operation should be canceled. 2169 */ 2170 public PluginResult.PreParse invokePreParseModifyPlugins( 2171 PreParseModifyOperation modifyOperation) 2172 throws CanceledOperationException { 2173 PluginResult.PreParse result = null; 2174 2175 for (DirectoryServerPlugin p : preParseModifyPlugins) 2176 { 2177 if (modifyOperation.isInternalOperation() && 2178 (! p.invokeForInternalOperations())) 2179 { 2180 continue; 2181 } 2182 2183 try 2184 { 2185 result = p.doPreParse(modifyOperation); 2186 } 2187 catch (CanceledOperationException coe) 2188 { 2189 throw coe; 2190 } 2191 catch (Exception e) 2192 { 2193 if (debugEnabled()) 2194 { 2195 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2196 } 2197 2198 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2199 get(modifyOperation.getOperationType().getOperationName(), 2200 String.valueOf(p.getPluginEntryDN()), 2201 modifyOperation.getConnectionID(), 2202 modifyOperation.getOperationID(), 2203 stackTraceToSingleLineString(e)); 2204 logError(message); 2205 2206 return PluginResult.PreParse.stopProcessing( 2207 DirectoryServer.getServerErrorResultCode(), message); 2208 } 2209 2210 if (result == null) 2211 { 2212 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2213 get(modifyOperation.getOperationType().getOperationName(), 2214 String.valueOf(p.getPluginEntryDN()), 2215 modifyOperation.getConnectionID(), 2216 String.valueOf(modifyOperation.getOperationID())); 2217 logError(message); 2218 2219 return PluginResult.PreParse.stopProcessing( 2220 DirectoryServer.getServerErrorResultCode(), message); 2221 } 2222 else if (!result.continuePluginProcessing()) 2223 { 2224 return result; 2225 } 2226 } 2227 2228 if (result == null) 2229 { 2230 // This should only happen if there were no pre-parse modify plugins 2231 // registered, which is fine. 2232 result = PluginResult.PreParse.continueOperationProcessing(); 2233 } 2234 2235 return result; 2236 } 2237 2238 2239 2240 /** 2241 * Invokes the set of pre-parse modify DN plugins that have been configured in 2242 * the Directory Server. 2243 * 2244 * @param modifyDNOperation The modify DN operation for which to invoke the 2245 * pre-parse plugins. 2246 * 2247 * @return The result of processing the pre-parse modify DN plugins. 2248 * 2249 * @throws CanceledOperationException if the operation should be canceled. 2250 */ 2251 public PluginResult.PreParse invokePreParseModifyDNPlugins( 2252 PreParseModifyDNOperation modifyDNOperation) 2253 throws CanceledOperationException { 2254 PluginResult.PreParse result = null; 2255 2256 for (DirectoryServerPlugin p : preParseModifyDNPlugins) 2257 { 2258 if (modifyDNOperation.isInternalOperation() && 2259 (! p.invokeForInternalOperations())) 2260 { 2261 continue; 2262 } 2263 2264 try 2265 { 2266 result = p.doPreParse(modifyDNOperation); 2267 } 2268 catch (CanceledOperationException coe) 2269 { 2270 throw coe; 2271 } 2272 catch (Exception e) 2273 { 2274 if (debugEnabled()) 2275 { 2276 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2277 } 2278 2279 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2280 get(modifyDNOperation.getOperationType().getOperationName(), 2281 String.valueOf(p.getPluginEntryDN()), 2282 modifyDNOperation.getConnectionID(), 2283 modifyDNOperation.getOperationID(), 2284 stackTraceToSingleLineString(e)); 2285 logError(message); 2286 2287 return PluginResult.PreParse.stopProcessing( 2288 DirectoryServer.getServerErrorResultCode(), message); 2289 } 2290 2291 if (result == null) 2292 { 2293 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2294 get(modifyDNOperation.getOperationType().getOperationName(), 2295 String.valueOf(p.getPluginEntryDN()), 2296 modifyDNOperation.getConnectionID(), 2297 String.valueOf(modifyDNOperation.getOperationID())); 2298 logError(message); 2299 2300 return PluginResult.PreParse.stopProcessing( 2301 DirectoryServer.getServerErrorResultCode(), message); 2302 } 2303 else if (!result.continuePluginProcessing()) 2304 { 2305 return result; 2306 } 2307 } 2308 2309 if (result == null) 2310 { 2311 // This should only happen if there were no pre-parse modify DN plugins 2312 // registered, which is fine. 2313 result = PluginResult.PreParse.continueOperationProcessing(); 2314 } 2315 2316 return result; 2317 } 2318 2319 2320 2321 /** 2322 * Invokes the set of pre-parse search plugins that have been configured in 2323 * the Directory Server. 2324 * 2325 * @param searchOperation The search operation for which to invoke the 2326 * pre-parse plugins. 2327 * 2328 * @return The result of processing the pre-parse search plugins. 2329 * 2330 * @throws CanceledOperationException if the operation should be canceled. 2331 */ 2332 public PluginResult.PreParse invokePreParseSearchPlugins( 2333 PreParseSearchOperation searchOperation) 2334 throws CanceledOperationException { 2335 PluginResult.PreParse result = null; 2336 2337 for (DirectoryServerPlugin p : preParseSearchPlugins) 2338 { 2339 if (searchOperation.isInternalOperation() && 2340 (! p.invokeForInternalOperations())) 2341 { 2342 continue; 2343 } 2344 2345 try 2346 { 2347 result = p.doPreParse(searchOperation); 2348 } 2349 catch (CanceledOperationException coe) 2350 { 2351 throw coe; 2352 } 2353 catch (Exception e) 2354 { 2355 if (debugEnabled()) 2356 { 2357 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2358 } 2359 2360 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2361 get(searchOperation.getOperationType().getOperationName(), 2362 String.valueOf(p.getPluginEntryDN()), 2363 searchOperation.getConnectionID(), 2364 searchOperation.getOperationID(), 2365 stackTraceToSingleLineString(e)); 2366 logError(message); 2367 2368 return PluginResult.PreParse.stopProcessing( 2369 DirectoryServer.getServerErrorResultCode(), message); 2370 } 2371 2372 if (result == null) 2373 { 2374 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2375 get(searchOperation.getOperationType().getOperationName(), 2376 String.valueOf(p.getPluginEntryDN()), 2377 searchOperation.getConnectionID(), 2378 String.valueOf(searchOperation.getOperationID())); 2379 logError(message); 2380 2381 return PluginResult.PreParse.stopProcessing( 2382 DirectoryServer.getServerErrorResultCode(), message); 2383 } 2384 else if (!result.continuePluginProcessing()) 2385 { 2386 return result; 2387 } 2388 } 2389 2390 if (result == null) 2391 { 2392 // This should only happen if there were no pre-parse search plugins 2393 // registered, which is fine. 2394 result = PluginResult.PreParse.continueOperationProcessing(); 2395 } 2396 2397 return result; 2398 } 2399 2400 2401 2402 /** 2403 * Invokes the set of pre-parse unbind plugins that have been configured in 2404 * the Directory Server. 2405 * 2406 * @param unbindOperation The unbind operation for which to invoke the 2407 * pre-parse plugins. 2408 * 2409 * @return The result of processing the pre-parse unbind plugins. 2410 */ 2411 public PluginResult.PreParse invokePreParseUnbindPlugins( 2412 PreParseUnbindOperation unbindOperation) 2413 { 2414 PluginResult.PreParse result = null; 2415 2416 for (DirectoryServerPlugin p : preParseUnbindPlugins) 2417 { 2418 if (unbindOperation.isInternalOperation() && 2419 (! p.invokeForInternalOperations())) 2420 { 2421 continue; 2422 } 2423 2424 try 2425 { 2426 result = p.doPreParse(unbindOperation); 2427 } 2428 catch (Exception e) 2429 { 2430 if (debugEnabled()) 2431 { 2432 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2433 } 2434 2435 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_EXCEPTION. 2436 get(unbindOperation.getOperationType().getOperationName(), 2437 String.valueOf(p.getPluginEntryDN()), 2438 unbindOperation.getConnectionID(), 2439 unbindOperation.getOperationID(), 2440 stackTraceToSingleLineString(e)); 2441 logError(message); 2442 2443 return PluginResult.PreParse.stopProcessing( 2444 DirectoryServer.getServerErrorResultCode(), message); 2445 } 2446 2447 if (result == null) 2448 { 2449 Message message = ERR_PLUGIN_PRE_PARSE_PLUGIN_RETURNED_NULL. 2450 get(unbindOperation.getOperationType().getOperationName(), 2451 String.valueOf(p.getPluginEntryDN()), 2452 unbindOperation.getConnectionID(), 2453 String.valueOf(unbindOperation.getOperationID())); 2454 logError(message); 2455 2456 return PluginResult.PreParse.stopProcessing( 2457 DirectoryServer.getServerErrorResultCode(), message); 2458 } 2459 else if (!result.continuePluginProcessing()) 2460 { 2461 return result; 2462 } 2463 } 2464 2465 if (result == null) 2466 { 2467 // This should only happen if there were no pre-parse unbind plugins 2468 // registered, which is fine. 2469 result = PluginResult.PreParse.continueOperationProcessing(); 2470 } 2471 2472 return result; 2473 } 2474 2475 2476 2477 /** 2478 * Invokes the set of pre-operation add plugins that have been configured in 2479 * the Directory Server. 2480 * 2481 * @param addOperation The add operation for which to invoke the 2482 * pre-operation plugins. 2483 * 2484 * @return The result of processing the pre-operation add plugins. 2485 * 2486 * @throws CanceledOperationException if the operation should be canceled. 2487 */ 2488 public PluginResult.PreOperation invokePreOperationAddPlugins( 2489 PreOperationAddOperation addOperation) 2490 throws CanceledOperationException { 2491 PluginResult.PreOperation result = null; 2492 2493 for (int i = 0; i < preOperationAddPlugins.length; i++) 2494 { 2495 DirectoryServerPlugin p = preOperationAddPlugins[i]; 2496 if (addOperation.isInternalOperation() && 2497 (! p.invokeForInternalOperations())) 2498 { 2499 continue; 2500 } 2501 2502 try 2503 { 2504 result = p.doPreOperation(addOperation); 2505 } 2506 catch (CanceledOperationException coe) 2507 { 2508 throw coe; 2509 } 2510 catch (Exception e) 2511 { 2512 if (debugEnabled()) 2513 { 2514 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2515 } 2516 2517 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2518 get(addOperation.getOperationType().getOperationName(), 2519 String.valueOf(p.getPluginEntryDN()), 2520 addOperation.getConnectionID(), addOperation.getOperationID(), 2521 stackTraceToSingleLineString(e)); 2522 logError(message); 2523 2524 registerSkippedPreOperationPlugins(i, preOperationAddPlugins, 2525 addOperation); 2526 2527 return PluginResult.PreOperation.stopProcessing( 2528 DirectoryServer.getServerErrorResultCode(), message); 2529 } 2530 2531 if (result == null) 2532 { 2533 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2534 get(addOperation.getOperationType().getOperationName(), 2535 String.valueOf(p.getPluginEntryDN()), 2536 addOperation.getConnectionID(), addOperation.getOperationID()); 2537 logError(message); 2538 2539 registerSkippedPreOperationPlugins(i, preOperationAddPlugins, 2540 addOperation); 2541 2542 return PluginResult.PreOperation.stopProcessing( 2543 DirectoryServer.getServerErrorResultCode(), message); 2544 } 2545 else if (!result.continuePluginProcessing()) 2546 { 2547 registerSkippedPreOperationPlugins(i, preOperationAddPlugins, 2548 addOperation); 2549 return result; 2550 } 2551 } 2552 2553 if (result == null) 2554 { 2555 // This should only happen if there were no pre-operation add plugins 2556 // registered, which is fine. 2557 result = PluginResult.PreOperation.continueOperationProcessing(); 2558 } 2559 2560 return result; 2561 } 2562 2563 2564 2565 /** 2566 * Invokes the set of pre-operation bind plugins that have been configured in 2567 * the Directory Server. 2568 * 2569 * @param bindOperation The bind operation for which to invoke the 2570 * pre-operation plugins. 2571 * 2572 * @return The result of processing the pre-operation bind plugins. 2573 */ 2574 public PluginResult.PreOperation invokePreOperationBindPlugins( 2575 PreOperationBindOperation bindOperation) 2576 { 2577 PluginResult.PreOperation result = null; 2578 2579 for (int i = 0; i < preOperationBindPlugins.length; i++) 2580 { 2581 DirectoryServerPlugin p = preOperationBindPlugins[i]; 2582 if (bindOperation.isInternalOperation() && 2583 (! p.invokeForInternalOperations())) 2584 { 2585 continue; 2586 } 2587 2588 try 2589 { 2590 result = p.doPreOperation(bindOperation); 2591 } 2592 catch (Exception e) 2593 { 2594 if (debugEnabled()) 2595 { 2596 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2597 } 2598 2599 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2600 get(bindOperation.getOperationType().getOperationName(), 2601 String.valueOf(p.getPluginEntryDN()), 2602 bindOperation.getConnectionID(), bindOperation.getOperationID(), 2603 stackTraceToSingleLineString(e)); 2604 logError(message); 2605 2606 registerSkippedPreOperationPlugins(i, preOperationBindPlugins, 2607 bindOperation); 2608 2609 return PluginResult.PreOperation.stopProcessing( 2610 DirectoryServer.getServerErrorResultCode(), message); 2611 } 2612 2613 if (result == null) 2614 { 2615 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2616 get(bindOperation.getOperationType().getOperationName(), 2617 String.valueOf(p.getPluginEntryDN()), 2618 bindOperation.getConnectionID(), 2619 bindOperation.getOperationID()); 2620 logError(message); 2621 2622 registerSkippedPreOperationPlugins(i, preOperationBindPlugins, 2623 bindOperation); 2624 2625 return PluginResult.PreOperation.stopProcessing( 2626 DirectoryServer.getServerErrorResultCode(), message); 2627 } 2628 else if (!result.continuePluginProcessing()) 2629 { 2630 registerSkippedPreOperationPlugins(i, preOperationBindPlugins, 2631 bindOperation); 2632 2633 return result; 2634 } 2635 } 2636 2637 if (result == null) 2638 { 2639 // This should only happen if there were no pre-operation add plugins 2640 // registered, which is fine. 2641 result = PluginResult.PreOperation.continueOperationProcessing(); 2642 } 2643 2644 return result; 2645 } 2646 2647 2648 2649 /** 2650 * Invokes the set of pre-operation compare plugins that have been configured 2651 * in the Directory Server. 2652 * 2653 * @param compareOperation The compare operation for which to invoke the 2654 * pre-operation plugins. 2655 * 2656 * @return The result of processing the pre-operation compare plugins. 2657 * 2658 * @throws CanceledOperationException if the operation should be canceled. 2659 */ 2660 public PluginResult.PreOperation invokePreOperationComparePlugins( 2661 PreOperationCompareOperation compareOperation) 2662 throws CanceledOperationException { 2663 PluginResult.PreOperation result = null; 2664 2665 for (int i = 0; i < preOperationComparePlugins.length; i++) 2666 { 2667 DirectoryServerPlugin p = preOperationComparePlugins[i]; 2668 if (compareOperation.isInternalOperation() && 2669 (! p.invokeForInternalOperations())) 2670 { 2671 continue; 2672 } 2673 2674 try 2675 { 2676 result = p.doPreOperation(compareOperation); 2677 } 2678 catch (CanceledOperationException coe) 2679 { 2680 throw coe; 2681 } 2682 catch (Exception e) 2683 { 2684 if (debugEnabled()) 2685 { 2686 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2687 } 2688 2689 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2690 get(compareOperation.getOperationType().getOperationName(), 2691 String.valueOf(p.getPluginEntryDN()), 2692 compareOperation.getConnectionID(), 2693 compareOperation.getOperationID(), 2694 stackTraceToSingleLineString(e)); 2695 logError(message); 2696 2697 registerSkippedPreOperationPlugins(i, preOperationComparePlugins, 2698 compareOperation); 2699 2700 return PluginResult.PreOperation.stopProcessing( 2701 DirectoryServer.getServerErrorResultCode(), message); 2702 } 2703 2704 if (result == null) 2705 { 2706 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2707 get(compareOperation.getOperationType().getOperationName(), 2708 String.valueOf(p.getPluginEntryDN()), 2709 compareOperation.getConnectionID(), 2710 compareOperation.getOperationID()); 2711 logError(message); 2712 2713 registerSkippedPreOperationPlugins(i, preOperationComparePlugins, 2714 compareOperation); 2715 2716 return PluginResult.PreOperation.stopProcessing( 2717 DirectoryServer.getServerErrorResultCode(), message); 2718 } 2719 else if (!result.continuePluginProcessing()) 2720 { 2721 return result; 2722 } 2723 } 2724 2725 if (result == null) 2726 { 2727 // This should only happen if there were no pre-operation add plugins 2728 // registered, which is fine. 2729 result = PluginResult.PreOperation.continueOperationProcessing(); 2730 } 2731 2732 return result; 2733 } 2734 2735 2736 2737 /** 2738 * Invokes the set of pre-operation delete plugins that have been configured 2739 * in the Directory Server. 2740 * 2741 * @param deleteOperation The delete operation for which to invoke the 2742 * pre-operation plugins. 2743 * 2744 * @return The result of processing the pre-operation delete plugins. 2745 * 2746 * @throws CanceledOperationException if the operation should be canceled. 2747 */ 2748 public PluginResult.PreOperation invokePreOperationDeletePlugins( 2749 PreOperationDeleteOperation deleteOperation) 2750 throws CanceledOperationException { 2751 PluginResult.PreOperation result = null; 2752 2753 for (int i = 0; i < preOperationDeletePlugins.length; i++) 2754 { 2755 DirectoryServerPlugin p = preOperationDeletePlugins[i]; 2756 if (deleteOperation.isInternalOperation() && 2757 (! p.invokeForInternalOperations())) 2758 { 2759 continue; 2760 } 2761 2762 try 2763 { 2764 result = p.doPreOperation(deleteOperation); 2765 } 2766 catch (CanceledOperationException coe) 2767 { 2768 throw coe; 2769 } 2770 catch (Exception e) 2771 { 2772 if (debugEnabled()) 2773 { 2774 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2775 } 2776 2777 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2778 get(deleteOperation.getOperationType().getOperationName(), 2779 String.valueOf(p.getPluginEntryDN()), 2780 deleteOperation.getConnectionID(), 2781 deleteOperation.getOperationID(), 2782 stackTraceToSingleLineString(e)); 2783 logError(message); 2784 2785 registerSkippedPreOperationPlugins(i, preOperationDeletePlugins, 2786 deleteOperation); 2787 2788 return PluginResult.PreOperation.stopProcessing( 2789 DirectoryServer.getServerErrorResultCode(), message); 2790 } 2791 2792 if (result == null) 2793 { 2794 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2795 get(deleteOperation.getOperationType().getOperationName(), 2796 String.valueOf(p.getPluginEntryDN()), 2797 deleteOperation.getConnectionID(), 2798 deleteOperation.getOperationID()); 2799 logError(message); 2800 2801 registerSkippedPreOperationPlugins(i, preOperationDeletePlugins, 2802 deleteOperation); 2803 2804 return PluginResult.PreOperation.stopProcessing( 2805 DirectoryServer.getServerErrorResultCode(), message); 2806 } 2807 else if (!result.continuePluginProcessing()) 2808 { 2809 registerSkippedPreOperationPlugins(i, preOperationDeletePlugins, 2810 deleteOperation); 2811 2812 return result; 2813 } 2814 } 2815 2816 if (result == null) 2817 { 2818 // This should only happen if there were no pre-operation add plugins 2819 // registered, which is fine. 2820 result = PluginResult.PreOperation.continueOperationProcessing(); 2821 } 2822 2823 return result; 2824 } 2825 2826 2827 2828 /** 2829 * Invokes the set of pre-operation extended plugins that have been configured 2830 * in the Directory Server. 2831 * 2832 * @param extendedOperation The extended operation for which to invoke the 2833 * pre-operation plugins. 2834 * 2835 * @return The result of processing the pre-operation extended plugins. 2836 * 2837 * @throws CanceledOperationException if the operation should be canceled. 2838 */ 2839 public PluginResult.PreOperation invokePreOperationExtendedPlugins( 2840 PreOperationExtendedOperation extendedOperation) 2841 throws CanceledOperationException { 2842 PluginResult.PreOperation result = null; 2843 2844 for (int i = 0; i < preOperationExtendedPlugins.length; i++) 2845 { 2846 DirectoryServerPlugin p = preOperationExtendedPlugins[i]; 2847 if (extendedOperation.isInternalOperation() && 2848 (! p.invokeForInternalOperations())) 2849 { 2850 registerSkippedPreOperationPlugin(p, extendedOperation); 2851 continue; 2852 } 2853 2854 try 2855 { 2856 result = p.doPreOperation(extendedOperation); 2857 } 2858 catch (CanceledOperationException coe) 2859 { 2860 throw coe; 2861 } 2862 catch (Exception e) 2863 { 2864 if (debugEnabled()) 2865 { 2866 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2867 } 2868 2869 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2870 get(extendedOperation.getOperationType().getOperationName(), 2871 String.valueOf(p.getPluginEntryDN()), 2872 extendedOperation.getConnectionID(), 2873 extendedOperation.getOperationID(), 2874 stackTraceToSingleLineString(e)); 2875 logError(message); 2876 2877 registerSkippedPreOperationPlugins(i, preOperationExtendedPlugins, 2878 extendedOperation); 2879 2880 return PluginResult.PreOperation.stopProcessing( 2881 DirectoryServer.getServerErrorResultCode(), message); 2882 } 2883 2884 if (result == null) 2885 { 2886 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2887 get(extendedOperation.getOperationType().getOperationName(), 2888 String.valueOf(p.getPluginEntryDN()), 2889 extendedOperation.getConnectionID(), 2890 extendedOperation.getOperationID()); 2891 logError(message); 2892 2893 registerSkippedPreOperationPlugins(i, preOperationExtendedPlugins, 2894 extendedOperation); 2895 2896 return PluginResult.PreOperation.stopProcessing( 2897 DirectoryServer.getServerErrorResultCode(), message); 2898 } 2899 else if (!result.continuePluginProcessing()) 2900 { 2901 registerSkippedPreOperationPlugins(i, preOperationExtendedPlugins, 2902 extendedOperation); 2903 2904 return result; 2905 } 2906 } 2907 2908 if (result == null) 2909 { 2910 // This should only happen if there were no pre-operation add plugins 2911 // registered, which is fine. 2912 result = PluginResult.PreOperation.continueOperationProcessing(); 2913 } 2914 2915 return result; 2916 } 2917 2918 2919 2920 /** 2921 * Invokes the set of pre-operation modify plugins that have been configured 2922 * in the Directory Server. 2923 * 2924 * @param modifyOperation The modify operation for which to invoke the 2925 * pre-operation plugins. 2926 * 2927 * @return The result of processing the pre-operation modify plugins. 2928 * 2929 * @throws CanceledOperationException if the operation should be canceled. 2930 */ 2931 public PluginResult.PreOperation invokePreOperationModifyPlugins( 2932 PreOperationModifyOperation modifyOperation) 2933 throws CanceledOperationException { 2934 PluginResult.PreOperation result = null; 2935 2936 for (int i = 0; i < preOperationModifyPlugins.length; i++) 2937 { 2938 DirectoryServerPlugin p = preOperationModifyPlugins[i]; 2939 if (modifyOperation.isInternalOperation() && 2940 (! p.invokeForInternalOperations())) 2941 { 2942 continue; 2943 } 2944 2945 try 2946 { 2947 result = p.doPreOperation(modifyOperation); 2948 } 2949 catch (CanceledOperationException coe) 2950 { 2951 throw coe; 2952 } 2953 catch (Exception e) 2954 { 2955 if (debugEnabled()) 2956 { 2957 TRACER.debugCaught(DebugLogLevel.ERROR, e); 2958 } 2959 2960 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 2961 get(modifyOperation.getOperationType().getOperationName(), 2962 String.valueOf(p.getPluginEntryDN()), 2963 modifyOperation.getConnectionID(), 2964 modifyOperation.getOperationID(), 2965 stackTraceToSingleLineString(e)); 2966 logError(message); 2967 2968 registerSkippedPreOperationPlugins(i, preOperationModifyPlugins, 2969 modifyOperation); 2970 2971 return PluginResult.PreOperation.stopProcessing( 2972 DirectoryServer.getServerErrorResultCode(), message); 2973 } 2974 2975 if (result == null) 2976 { 2977 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 2978 get(modifyOperation.getOperationType().getOperationName(), 2979 String.valueOf(p.getPluginEntryDN()), 2980 modifyOperation.getConnectionID(), 2981 modifyOperation.getOperationID()); 2982 logError(message); 2983 2984 registerSkippedPreOperationPlugins(i, preOperationModifyPlugins, 2985 modifyOperation); 2986 2987 return PluginResult.PreOperation.stopProcessing( 2988 DirectoryServer.getServerErrorResultCode(), message); 2989 } 2990 else if (!result.continuePluginProcessing()) 2991 { 2992 registerSkippedPreOperationPlugins(i, preOperationModifyPlugins, 2993 modifyOperation); 2994 2995 return result; 2996 } 2997 } 2998 2999 if (result == null) 3000 { 3001 // This should only happen if there were no pre-operation add plugins 3002 // registered, which is fine. 3003 result = PluginResult.PreOperation.continueOperationProcessing(); 3004 } 3005 3006 return result; 3007 } 3008 3009 3010 3011 /** 3012 * Invokes the set of pre-operation modify DN plugins that have been 3013 * configured in the Directory Server. 3014 * 3015 * @param modifyDNOperation The modify DN operation for which to invoke the 3016 * pre-operation plugins. 3017 * 3018 * @return The result of processing the pre-operation modify DN plugins. 3019 * 3020 * @throws CanceledOperationException if the operation should be canceled. 3021 */ 3022 public PluginResult.PreOperation invokePreOperationModifyDNPlugins( 3023 PreOperationModifyDNOperation modifyDNOperation) 3024 throws CanceledOperationException { 3025 PluginResult.PreOperation result = null; 3026 3027 for (int i = 0; i < preOperationModifyDNPlugins.length; i++) 3028 { 3029 DirectoryServerPlugin p = preOperationModifyDNPlugins[i]; 3030 if (modifyDNOperation.isInternalOperation() && 3031 (! p.invokeForInternalOperations())) 3032 { 3033 continue; 3034 } 3035 3036 try 3037 { 3038 result = p.doPreOperation(modifyDNOperation); 3039 } 3040 catch (CanceledOperationException coe) 3041 { 3042 throw coe; 3043 } 3044 catch (Exception e) 3045 { 3046 if (debugEnabled()) 3047 { 3048 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3049 } 3050 3051 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 3052 get(modifyDNOperation.getOperationType().getOperationName(), 3053 String.valueOf(p.getPluginEntryDN()), 3054 modifyDNOperation.getConnectionID(), 3055 modifyDNOperation.getOperationID(), 3056 stackTraceToSingleLineString(e)); 3057 logError(message); 3058 3059 registerSkippedPreOperationPlugins(i, preOperationModifyDNPlugins, 3060 modifyDNOperation); 3061 3062 return PluginResult.PreOperation.stopProcessing( 3063 DirectoryServer.getServerErrorResultCode(), message); 3064 } 3065 3066 if (result == null) 3067 { 3068 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 3069 get(modifyDNOperation.getOperationType().getOperationName(), 3070 String.valueOf(p.getPluginEntryDN()), 3071 modifyDNOperation.getConnectionID(), 3072 modifyDNOperation.getOperationID()); 3073 logError(message); 3074 3075 registerSkippedPreOperationPlugins(i, preOperationModifyDNPlugins, 3076 modifyDNOperation); 3077 3078 return PluginResult.PreOperation.stopProcessing( 3079 DirectoryServer.getServerErrorResultCode(), message); 3080 } 3081 else if (!result.continuePluginProcessing()) 3082 { 3083 registerSkippedPreOperationPlugins(i, preOperationModifyDNPlugins, 3084 modifyDNOperation); 3085 3086 return result; 3087 } 3088 } 3089 3090 if (result == null) 3091 { 3092 // This should only happen if there were no pre-operation add plugins 3093 // registered, which is fine. 3094 result = PluginResult.PreOperation.continueOperationProcessing(); 3095 } 3096 3097 return result; 3098 } 3099 3100 3101 3102 /** 3103 * Invokes the set of pre-operation search plugins that have been configured 3104 * in the Directory Server. 3105 * 3106 * @param searchOperation The search operation for which to invoke the 3107 * pre-operation plugins. 3108 * 3109 * @return The result of processing the pre-operation search plugins. 3110 * 3111 * @throws CanceledOperationException if the operation should be canceled. 3112 */ 3113 public PluginResult.PreOperation invokePreOperationSearchPlugins( 3114 PreOperationSearchOperation searchOperation) 3115 throws CanceledOperationException { 3116 PluginResult.PreOperation result = null; 3117 3118 for (int i = 0; i < preOperationSearchPlugins.length; i++) 3119 { 3120 DirectoryServerPlugin p = preOperationSearchPlugins[i]; 3121 if (searchOperation.isInternalOperation() && 3122 (! p.invokeForInternalOperations())) 3123 { 3124 continue; 3125 } 3126 3127 try 3128 { 3129 result = p.doPreOperation(searchOperation); 3130 } 3131 catch (CanceledOperationException coe) 3132 { 3133 throw coe; 3134 } 3135 catch (Exception e) 3136 { 3137 if (debugEnabled()) 3138 { 3139 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3140 } 3141 3142 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_EXCEPTION. 3143 get(searchOperation.getOperationType().getOperationName(), 3144 String.valueOf(p.getPluginEntryDN()), 3145 searchOperation.getConnectionID(), 3146 searchOperation.getOperationID(), 3147 stackTraceToSingleLineString(e)); 3148 logError(message); 3149 3150 registerSkippedPreOperationPlugins(i, preOperationSearchPlugins, 3151 searchOperation); 3152 3153 return PluginResult.PreOperation.stopProcessing( 3154 DirectoryServer.getServerErrorResultCode(), message); 3155 } 3156 3157 if (result == null) 3158 { 3159 Message message = ERR_PLUGIN_PRE_OPERATION_PLUGIN_RETURNED_NULL. 3160 get(searchOperation.getOperationType().getOperationName(), 3161 String.valueOf(p.getPluginEntryDN()), 3162 searchOperation.getConnectionID(), 3163 searchOperation.getOperationID()); 3164 logError(message); 3165 3166 registerSkippedPreOperationPlugins(i, preOperationSearchPlugins, 3167 searchOperation); 3168 3169 return PluginResult.PreOperation.stopProcessing( 3170 DirectoryServer.getServerErrorResultCode(), message); 3171 } 3172 else if (!result.continuePluginProcessing()) 3173 { 3174 registerSkippedPreOperationPlugins(i, preOperationSearchPlugins, 3175 searchOperation); 3176 3177 return result; 3178 } 3179 } 3180 3181 if (result == null) 3182 { 3183 // This should only happen if there were no pre-operation add plugins 3184 // registered, which is fine. 3185 result = PluginResult.PreOperation.continueOperationProcessing(); 3186 } 3187 3188 return result; 3189 } 3190 3191 3192 3193 /** 3194 * Invokes the set of post-operation abandon plugins that have been configured 3195 * in the Directory Server. 3196 * 3197 * @param abandonOperation The abandon operation for which to invoke the 3198 * post-operation plugins. 3199 * 3200 * @return The result of processing the post-operation abandon plugins. 3201 */ 3202 public PluginResult.PostOperation invokePostOperationAbandonPlugins( 3203 PostOperationAbandonOperation abandonOperation) 3204 { 3205 PluginResult.PostOperation result = null; 3206 PluginResult.PostOperation finalResult = null; 3207 3208 for (DirectoryServerPlugin p : postOperationAbandonPlugins) 3209 { 3210 if (abandonOperation.isInternalOperation() && 3211 (! p.invokeForInternalOperations())) 3212 { 3213 continue; 3214 } 3215 3216 try 3217 { 3218 result = p.doPostOperation(abandonOperation); 3219 } 3220 catch (Exception e) 3221 { 3222 if (debugEnabled()) 3223 { 3224 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3225 } 3226 3227 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3228 get(abandonOperation.getOperationType().getOperationName(), 3229 String.valueOf(p.getPluginEntryDN()), 3230 abandonOperation.getConnectionID(), 3231 abandonOperation.getOperationID(), 3232 stackTraceToSingleLineString(e)); 3233 logError(message); 3234 } 3235 3236 if (result == null) 3237 { 3238 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3239 get(abandonOperation.getOperationType().getOperationName(), 3240 String.valueOf(p.getPluginEntryDN()), 3241 abandonOperation.getConnectionID(), 3242 abandonOperation.getOperationID()); 3243 logError(message); 3244 } 3245 else if (!result.continueProcessing()) 3246 { 3247 // This plugin requested operation processing to stop. However, we 3248 // still have to invoke all the post op plugins that successfully 3249 // invoked its pre op plugins. We will just take this plugin's 3250 // results as the final result. 3251 finalResult = result; 3252 } 3253 } 3254 3255 if (result == null) 3256 { 3257 // This should only happen if there were no post-operation add plugins 3258 // registered, which is fine. 3259 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3260 } 3261 else if(finalResult == null) 3262 { 3263 // None of the plugins requested processing to stop so all results 3264 // have equal priority. Just return the last one. 3265 finalResult = result; 3266 } 3267 3268 return finalResult; 3269 } 3270 3271 3272 3273 /** 3274 * Invokes the set of post-operation add plugins that have been configured in 3275 * the Directory Server. 3276 * 3277 * @param addOperation The add operation for which to invoke the 3278 * post-operation plugins. 3279 * 3280 * @return The result of processing the post-operation add plugins. 3281 */ 3282 public PluginResult.PostOperation invokePostOperationAddPlugins( 3283 PostOperationAddOperation addOperation) 3284 { 3285 PluginResult.PostOperation result = null; 3286 PluginResult.PostOperation finalResult = null; 3287 3288 for (DirectoryServerPlugin p : postOperationAddPlugins) 3289 { 3290 if (addOperation.isInternalOperation() && 3291 (! p.invokeForInternalOperations())) 3292 { 3293 continue; 3294 } 3295 3296 ArrayList<DirectoryServerPlugin> skippedPlugins = 3297 skippedPreOperationPlugins.remove(addOperation); 3298 if(skippedPlugins != null && skippedPlugins.contains(p)) 3299 { 3300 continue; 3301 } 3302 3303 try 3304 { 3305 result = p.doPostOperation(addOperation); 3306 } 3307 catch (Exception e) 3308 { 3309 if (debugEnabled()) 3310 { 3311 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3312 } 3313 3314 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3315 get(addOperation.getOperationType().getOperationName(), 3316 String.valueOf(p.getPluginEntryDN()), 3317 addOperation.getConnectionID(), addOperation.getOperationID(), 3318 stackTraceToSingleLineString(e)); 3319 logError(message); 3320 } 3321 3322 if (result == null) 3323 { 3324 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3325 get(addOperation.getOperationType().getOperationName(), 3326 String.valueOf(p.getPluginEntryDN()), 3327 addOperation.getConnectionID(), addOperation.getOperationID()); 3328 logError(message); 3329 } 3330 else if (!result.continueProcessing()) 3331 { 3332 // This plugin requested operation processing to stop. However, we 3333 // still have to invoke all the post op plugins that successfully 3334 // invoked its pre op plugins. We will just take this plugin's 3335 // results as the final result. 3336 finalResult = result; 3337 } 3338 } 3339 3340 if (result == null) 3341 { 3342 // This should only happen if there were no post-operation add plugins 3343 // registered, which is fine. 3344 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3345 } 3346 else if(finalResult == null) 3347 { 3348 // None of the plugins requested processing to stop so all results 3349 // have equal priority. Just return the last one. 3350 finalResult = result; 3351 } 3352 3353 return finalResult; 3354 } 3355 3356 3357 3358 /** 3359 * Invokes the set of post-operation bind plugins that have been configured 3360 * in the Directory Server. 3361 * 3362 * @param bindOperation The bind operation for which to invoke the 3363 * post-operation plugins. 3364 * 3365 * @return The result of processing the post-operation bind plugins. 3366 */ 3367 public PluginResult.PostOperation invokePostOperationBindPlugins( 3368 PostOperationBindOperation bindOperation) 3369 { 3370 PluginResult.PostOperation result = null; 3371 PluginResult.PostOperation finalResult = null; 3372 3373 for (DirectoryServerPlugin p : postOperationBindPlugins) 3374 { 3375 if (bindOperation.isInternalOperation() && 3376 (! p.invokeForInternalOperations())) 3377 { 3378 continue; 3379 } 3380 3381 ArrayList<DirectoryServerPlugin> skippedPlugins = 3382 skippedPreOperationPlugins.remove(bindOperation); 3383 if(skippedPlugins != null && skippedPlugins.contains(p)) 3384 { 3385 continue; 3386 } 3387 3388 try 3389 { 3390 result = p.doPostOperation(bindOperation); 3391 } 3392 catch (Exception e) 3393 { 3394 if (debugEnabled()) 3395 { 3396 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3397 } 3398 3399 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3400 get(bindOperation.getOperationType().getOperationName(), 3401 String.valueOf(p.getPluginEntryDN()), 3402 bindOperation.getConnectionID(), bindOperation.getOperationID(), 3403 stackTraceToSingleLineString(e)); 3404 logError(message); 3405 } 3406 3407 if (result == null) 3408 { 3409 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3410 get(bindOperation.getOperationType().getOperationName(), 3411 String.valueOf(p.getPluginEntryDN()), 3412 bindOperation.getConnectionID(), 3413 bindOperation.getOperationID()); 3414 logError(message); 3415 } 3416 else if (!result.continueProcessing()) 3417 { 3418 // This plugin requested operation processing to stop. However, we 3419 // still have to invoke all the post op plugins that successfully 3420 // invoked its pre op plugins. We will just take this plugin's 3421 // results as the final result. 3422 finalResult = result; 3423 } 3424 } 3425 3426 if (result == null) 3427 { 3428 // This should only happen if there were no post-operation add plugins 3429 // registered, which is fine. 3430 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3431 } 3432 else if(finalResult == null) 3433 { 3434 // None of the plugins requested processing to stop so all results 3435 // have equal priority. Just return the last one. 3436 finalResult = result; 3437 } 3438 3439 return finalResult; 3440 } 3441 3442 3443 3444 /** 3445 * Invokes the set of post-operation compare plugins that have been configured 3446 * in the Directory Server. 3447 * 3448 * @param compareOperation The compare operation for which to invoke the 3449 * post-operation plugins. 3450 * 3451 * @return The result of processing the post-operation compare plugins. 3452 */ 3453 public PluginResult.PostOperation invokePostOperationComparePlugins( 3454 PostOperationCompareOperation compareOperation) 3455 { 3456 PluginResult.PostOperation result = null; 3457 PluginResult.PostOperation finalResult = null; 3458 3459 for (DirectoryServerPlugin p : postOperationComparePlugins) 3460 { 3461 if (compareOperation.isInternalOperation() && 3462 (! p.invokeForInternalOperations())) 3463 { 3464 continue; 3465 } 3466 3467 ArrayList<DirectoryServerPlugin> skippedPlugins = 3468 skippedPreOperationPlugins.remove(compareOperation); 3469 if(skippedPlugins != null && skippedPlugins.contains(p)) 3470 { 3471 continue; 3472 } 3473 3474 try 3475 { 3476 result = p.doPostOperation(compareOperation); 3477 } 3478 catch (Exception e) 3479 { 3480 if (debugEnabled()) 3481 { 3482 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3483 } 3484 3485 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3486 get(compareOperation.getOperationType().getOperationName(), 3487 String.valueOf(p.getPluginEntryDN()), 3488 compareOperation.getConnectionID(), 3489 compareOperation.getOperationID(), 3490 stackTraceToSingleLineString(e)); 3491 logError(message); 3492 } 3493 3494 if (result == null) 3495 { 3496 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3497 get(compareOperation.getOperationType().getOperationName(), 3498 String.valueOf(p.getPluginEntryDN()), 3499 compareOperation.getConnectionID(), 3500 compareOperation.getOperationID()); 3501 logError(message); 3502 } 3503 else if (!result.continueProcessing()) 3504 { 3505 // This plugin requested operation processing to stop. However, we 3506 // still have to invoke all the post op plugins that successfully 3507 // invoked its pre op plugins. We will just take this plugin's 3508 // results as the final result. 3509 finalResult = result; 3510 } 3511 } 3512 3513 if (result == null) 3514 { 3515 // This should only happen if there were no post-operation add plugins 3516 // registered, which is fine. 3517 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3518 } 3519 else if(finalResult == null) 3520 { 3521 // None of the plugins requested processing to stop so all results 3522 // have equal priority. Just return the last one. 3523 finalResult = result; 3524 } 3525 3526 return finalResult; 3527 } 3528 3529 3530 3531 /** 3532 * Invokes the set of post-operation delete plugins that have been configured 3533 * in the Directory Server. 3534 * 3535 * @param deleteOperation The delete operation for which to invoke the 3536 * post-operation plugins. 3537 * 3538 * @return The result of processing the post-operation delete plugins. 3539 */ 3540 public PluginResult.PostOperation invokePostOperationDeletePlugins( 3541 PostOperationDeleteOperation deleteOperation) 3542 { 3543 PluginResult.PostOperation result = null; 3544 PluginResult.PostOperation finalResult = null; 3545 3546 for (DirectoryServerPlugin p : postOperationDeletePlugins) 3547 { 3548 if (deleteOperation.isInternalOperation() && 3549 (! p.invokeForInternalOperations())) 3550 { 3551 continue; 3552 } 3553 3554 ArrayList<DirectoryServerPlugin> skippedPlugins = 3555 skippedPreOperationPlugins.remove(deleteOperation); 3556 if(skippedPlugins != null && skippedPlugins.contains(p)) 3557 { 3558 continue; 3559 } 3560 3561 try 3562 { 3563 result = p.doPostOperation(deleteOperation); 3564 } 3565 catch (Exception e) 3566 { 3567 if (debugEnabled()) 3568 { 3569 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3570 } 3571 3572 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3573 get(deleteOperation.getOperationType().getOperationName(), 3574 String.valueOf(p.getPluginEntryDN()), 3575 deleteOperation.getConnectionID(), 3576 deleteOperation.getOperationID(), 3577 stackTraceToSingleLineString(e)); 3578 logError(message); 3579 } 3580 3581 if (result == null) 3582 { 3583 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3584 get(deleteOperation.getOperationType().getOperationName(), 3585 String.valueOf(p.getPluginEntryDN()), 3586 deleteOperation.getConnectionID(), 3587 deleteOperation.getOperationID()); 3588 logError(message); 3589 } 3590 else if (!result.continueProcessing()) 3591 { 3592 // This plugin requested operation processing to stop. However, we 3593 // still have to invoke all the post op plugins that successfully 3594 // invoked its pre op plugins. We will just take this plugin's 3595 // results as the final result. 3596 finalResult = result; 3597 } 3598 } 3599 3600 if (result == null) 3601 { 3602 // This should only happen if there were no post-operation add plugins 3603 // registered, which is fine. 3604 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3605 } 3606 else if(finalResult == null) 3607 { 3608 // None of the plugins requested processing to stop so all results 3609 // have equal priority. Just return the last one. 3610 finalResult = result; 3611 } 3612 3613 return finalResult; 3614 } 3615 3616 3617 3618 /** 3619 * Invokes the set of post-operation extended plugins that have been 3620 * configured in the Directory Server. 3621 * 3622 * @param extendedOperation The extended operation for which to invoke the 3623 * post-operation plugins. 3624 * 3625 * @return The result of processing the post-operation extended plugins. 3626 */ 3627 public PluginResult.PostOperation invokePostOperationExtendedPlugins( 3628 PostOperationExtendedOperation extendedOperation) 3629 { 3630 PluginResult.PostOperation result = null; 3631 PluginResult.PostOperation finalResult = null; 3632 3633 for (DirectoryServerPlugin p : postOperationExtendedPlugins) 3634 { 3635 if (extendedOperation.isInternalOperation() && 3636 (! p.invokeForInternalOperations())) 3637 { 3638 continue; 3639 } 3640 3641 ArrayList<DirectoryServerPlugin> skippedPlugins = 3642 skippedPreOperationPlugins.remove(extendedOperation); 3643 if(skippedPlugins != null && skippedPlugins.contains(p)) 3644 { 3645 continue; 3646 } 3647 3648 try 3649 { 3650 result = p.doPostOperation(extendedOperation); 3651 } 3652 catch (Exception e) 3653 { 3654 if (debugEnabled()) 3655 { 3656 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3657 } 3658 3659 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3660 get(extendedOperation.getOperationType().getOperationName(), 3661 String.valueOf(p.getPluginEntryDN()), 3662 extendedOperation.getConnectionID(), 3663 extendedOperation.getOperationID(), 3664 stackTraceToSingleLineString(e)); 3665 logError(message); 3666 } 3667 3668 if (result == null) 3669 { 3670 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3671 get(extendedOperation.getOperationType().getOperationName(), 3672 String.valueOf(p.getPluginEntryDN()), 3673 extendedOperation.getConnectionID(), 3674 extendedOperation.getOperationID()); 3675 logError(message); 3676 } 3677 else if (!result.continueProcessing()) 3678 { 3679 // This plugin requested operation processing to stop. However, we 3680 // still have to invoke all the post op plugins that successfully 3681 // invoked its pre op plugins. We will just take this plugin's 3682 // results as the final result. 3683 finalResult = result; 3684 } 3685 } 3686 3687 if (result == null) 3688 { 3689 // This should only happen if there were no post-operation add plugins 3690 // registered, which is fine. 3691 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3692 } 3693 else if(finalResult == null) 3694 { 3695 // None of the plugins requested processing to stop so all results 3696 // have equal priority. Just return the last one. 3697 finalResult = result; 3698 } 3699 3700 return finalResult; 3701 } 3702 3703 3704 3705 /** 3706 * Invokes the set of post-operation modify plugins that have been configured 3707 * in the Directory Server. 3708 * 3709 * @param modifyOperation The modify operation for which to invoke the 3710 * post-operation plugins. 3711 * 3712 * @return The result of processing the post-operation modify plugins. 3713 */ 3714 public PluginResult.PostOperation invokePostOperationModifyPlugins( 3715 PostOperationModifyOperation modifyOperation) 3716 { 3717 PluginResult.PostOperation result = null; 3718 PluginResult.PostOperation finalResult = null; 3719 3720 for (DirectoryServerPlugin p : postOperationModifyPlugins) 3721 { 3722 if (modifyOperation.isInternalOperation() && 3723 (! p.invokeForInternalOperations())) 3724 { 3725 continue; 3726 } 3727 3728 ArrayList<DirectoryServerPlugin> skippedPlugins = 3729 skippedPreOperationPlugins.remove(modifyOperation); 3730 if(skippedPlugins != null && skippedPlugins.contains(p)) 3731 { 3732 continue; 3733 } 3734 3735 try 3736 { 3737 result = p.doPostOperation(modifyOperation); 3738 } 3739 catch (Exception e) 3740 { 3741 if (debugEnabled()) 3742 { 3743 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3744 } 3745 3746 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3747 get(modifyOperation.getOperationType().getOperationName(), 3748 String.valueOf(p.getPluginEntryDN()), 3749 modifyOperation.getConnectionID(), 3750 modifyOperation.getOperationID(), 3751 stackTraceToSingleLineString(e)); 3752 logError(message); 3753 } 3754 3755 if (result == null) 3756 { 3757 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3758 get(modifyOperation.getOperationType().getOperationName(), 3759 String.valueOf(p.getPluginEntryDN()), 3760 modifyOperation.getConnectionID(), 3761 modifyOperation.getOperationID()); 3762 logError(message); 3763 } 3764 else if (!result.continueProcessing()) 3765 { 3766 // This plugin requested operation processing to stop. However, we 3767 // still have to invoke all the post op plugins that successfully 3768 // invoked its pre op plugins. We will just take this plugin's 3769 // results as the final result. 3770 finalResult = result; 3771 } 3772 } 3773 3774 if (result == null) 3775 { 3776 // This should only happen if there were no post-operation add plugins 3777 // registered, which is fine. 3778 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3779 } 3780 else if(finalResult == null) 3781 { 3782 // None of the plugins requested processing to stop so all results 3783 // have equal priority. Just return the last one. 3784 finalResult = result; 3785 } 3786 return finalResult; 3787 } 3788 3789 3790 3791 /** 3792 * Invokes the set of post-operation modify DN plugins that have been 3793 * configured in the Directory Server. 3794 * 3795 * @param modifyDNOperation The modify DN operation for which to invoke the 3796 * post-operation plugins. 3797 * 3798 * @return The result of processing the post-operation modify DN plugins. 3799 */ 3800 public PluginResult.PostOperation invokePostOperationModifyDNPlugins( 3801 PostOperationModifyDNOperation modifyDNOperation) 3802 { 3803 PluginResult.PostOperation result = null; 3804 PluginResult.PostOperation finalResult = null; 3805 3806 for (DirectoryServerPlugin p : postOperationModifyDNPlugins) 3807 { 3808 if (modifyDNOperation.isInternalOperation() && 3809 (! p.invokeForInternalOperations())) 3810 { 3811 continue; 3812 } 3813 3814 ArrayList<DirectoryServerPlugin> skippedPlugins = 3815 skippedPreOperationPlugins.remove(modifyDNOperation); 3816 if(skippedPlugins != null && skippedPlugins.contains(p)) 3817 { 3818 continue; 3819 } 3820 3821 try 3822 { 3823 result = p.doPostOperation(modifyDNOperation); 3824 } 3825 catch (Exception e) 3826 { 3827 if (debugEnabled()) 3828 { 3829 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3830 } 3831 3832 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3833 get(modifyDNOperation.getOperationType().getOperationName(), 3834 String.valueOf(p.getPluginEntryDN()), 3835 modifyDNOperation.getConnectionID(), 3836 modifyDNOperation.getOperationID(), 3837 stackTraceToSingleLineString(e)); 3838 logError(message); 3839 } 3840 3841 if (result == null) 3842 { 3843 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3844 get(modifyDNOperation.getOperationType().getOperationName(), 3845 String.valueOf(p.getPluginEntryDN()), 3846 modifyDNOperation.getConnectionID(), 3847 modifyDNOperation.getOperationID()); 3848 logError(message); 3849 } 3850 else if (!result.continueProcessing()) 3851 { 3852 // This plugin requested operation processing to stop. However, we 3853 // still have to invoke all the post op plugins that successfully 3854 // invoked its pre op plugins. We will just take this plugin's 3855 // results as the final result. 3856 finalResult = result; 3857 } 3858 } 3859 3860 if (result == null) 3861 { 3862 // This should only happen if there were no post-operation add plugins 3863 // registered, which is fine. 3864 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3865 } 3866 else if(finalResult == null) 3867 { 3868 // None of the plugins requested processing to stop so all results 3869 // have equal priority. Just return the last one. 3870 finalResult = result; 3871 } 3872 3873 return finalResult; 3874 } 3875 3876 3877 3878 /** 3879 * Invokes the set of post-operation search plugins that have been configured 3880 * in the Directory Server. 3881 * 3882 * @param searchOperation The search operation for which to invoke the 3883 * post-operation plugins. 3884 * 3885 * @return The result of processing the post-operation search plugins. 3886 */ 3887 public PluginResult.PostOperation invokePostOperationSearchPlugins( 3888 PostOperationSearchOperation searchOperation) 3889 { 3890 PluginResult.PostOperation result = null; 3891 PluginResult.PostOperation finalResult = null; 3892 3893 for (DirectoryServerPlugin p : postOperationSearchPlugins) 3894 { 3895 if (searchOperation.isInternalOperation() && 3896 (! p.invokeForInternalOperations())) 3897 { 3898 continue; 3899 } 3900 3901 ArrayList<DirectoryServerPlugin> skippedPlugins = 3902 skippedPreOperationPlugins.remove(searchOperation); 3903 if(skippedPlugins != null && skippedPlugins.contains(p)) 3904 { 3905 continue; 3906 } 3907 3908 try 3909 { 3910 result = p.doPostOperation(searchOperation); 3911 } 3912 catch (Exception e) 3913 { 3914 if (debugEnabled()) 3915 { 3916 TRACER.debugCaught(DebugLogLevel.ERROR, e); 3917 } 3918 3919 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 3920 get(searchOperation.getOperationType().getOperationName(), 3921 String.valueOf(p.getPluginEntryDN()), 3922 searchOperation.getConnectionID(), 3923 searchOperation.getOperationID(), 3924 stackTraceToSingleLineString(e)); 3925 logError(message); 3926 } 3927 3928 if (result == null) 3929 { 3930 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 3931 get(searchOperation.getOperationType().getOperationName(), 3932 String.valueOf(p.getPluginEntryDN()), 3933 searchOperation.getConnectionID(), 3934 searchOperation.getOperationID()); 3935 logError(message); 3936 } 3937 else if (!result.continueProcessing()) 3938 { 3939 // This plugin requested operation processing to stop. However, we 3940 // still have to invoke all the post op plugins that successfully 3941 // invoked its pre op plugins. We will just take this plugin's 3942 // results as the final result. 3943 finalResult = result; 3944 } 3945 } 3946 3947 if (result == null) 3948 { 3949 // This should only happen if there were no post-operation add plugins 3950 // registered, which is fine. 3951 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 3952 } 3953 else if(finalResult == null) 3954 { 3955 // None of the plugins requested processing to stop so all results 3956 // have equal priority. Just return the last one. 3957 finalResult = result; 3958 } 3959 3960 return finalResult; 3961 } 3962 3963 3964 3965 /** 3966 * Invokes the set of post-operation unbind plugins that have been configured 3967 * in the Directory Server. 3968 * 3969 * @param unbindOperation The unbind operation for which to invoke the 3970 * post-operation plugins. 3971 * 3972 * @return The result of processing the post-operation unbind plugins. 3973 */ 3974 public PluginResult.PostOperation invokePostOperationUnbindPlugins( 3975 PostOperationUnbindOperation unbindOperation) 3976 { 3977 PluginResult.PostOperation result = null; 3978 PluginResult.PostOperation finalResult = null; 3979 3980 for (DirectoryServerPlugin p : postOperationUnbindPlugins) 3981 { 3982 if (unbindOperation.isInternalOperation() && 3983 (! p.invokeForInternalOperations())) 3984 { 3985 continue; 3986 } 3987 3988 ArrayList<DirectoryServerPlugin> skippedPlugins = 3989 skippedPreOperationPlugins.remove(unbindOperation); 3990 if(skippedPlugins != null && skippedPlugins.contains(p)) 3991 { 3992 continue; 3993 } 3994 3995 try 3996 { 3997 result = p.doPostOperation(unbindOperation); 3998 } 3999 catch (Exception e) 4000 { 4001 if (debugEnabled()) 4002 { 4003 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4004 } 4005 4006 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_EXCEPTION. 4007 get(unbindOperation.getOperationType().getOperationName(), 4008 String.valueOf(p.getPluginEntryDN()), 4009 unbindOperation.getConnectionID(), 4010 unbindOperation.getOperationID(), 4011 stackTraceToSingleLineString(e)); 4012 logError(message); 4013 } 4014 4015 if (result == null) 4016 { 4017 Message message = ERR_PLUGIN_POST_OPERATION_PLUGIN_RETURNED_NULL. 4018 get(unbindOperation.getOperationType().getOperationName(), 4019 String.valueOf(p.getPluginEntryDN()), 4020 unbindOperation.getConnectionID(), 4021 unbindOperation.getOperationID()); 4022 logError(message); 4023 } 4024 else if (!result.continueProcessing()) 4025 { 4026 // This plugin requested operation processing to stop. However, we 4027 // still have to invoke all the post op plugins that successfully 4028 // invoked its pre op plugins. We will just take this plugin's 4029 // results as the final result. 4030 finalResult = result; 4031 } 4032 } 4033 4034 if (result == null) 4035 { 4036 // This should only happen if there were no post-operation add plugins 4037 // registered, which is fine. 4038 finalResult = PluginResult.PostOperation.continueOperationProcessing(); 4039 } 4040 else if(finalResult == null) 4041 { 4042 // None of the plugins requested processing to stop so all results 4043 // have equal priority. Just return the last one. 4044 finalResult = result; 4045 } 4046 4047 return finalResult; 4048 } 4049 4050 4051 4052 /** 4053 * Invokes the set of post-response add plugins that have been configured in 4054 * the Directory Server. 4055 * 4056 * @param addOperation The add operation for which to invoke the 4057 * post-response plugins. 4058 * 4059 * @return The result of processing the post-response add plugins. 4060 */ 4061 public PluginResult.PostResponse invokePostResponseAddPlugins( 4062 PostResponseAddOperation addOperation) 4063 { 4064 PluginResult.PostResponse result = null; 4065 4066 for (DirectoryServerPlugin p : postResponseAddPlugins) 4067 { 4068 if (addOperation.isInternalOperation() && 4069 (! p.invokeForInternalOperations())) 4070 { 4071 continue; 4072 } 4073 4074 try 4075 { 4076 result = p.doPostResponse(addOperation); 4077 } 4078 catch (Exception e) 4079 { 4080 if (debugEnabled()) 4081 { 4082 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4083 } 4084 4085 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4086 get(addOperation.getOperationType().getOperationName(), 4087 String.valueOf(p.getPluginEntryDN()), 4088 addOperation.getConnectionID(), addOperation.getOperationID(), 4089 stackTraceToSingleLineString(e)); 4090 logError(message); 4091 } 4092 4093 if (result == null) 4094 { 4095 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4096 get(addOperation.getOperationType().getOperationName(), 4097 String.valueOf(p.getPluginEntryDN()), 4098 addOperation.getConnectionID(), addOperation.getOperationID()); 4099 logError(message); 4100 } 4101 else if (!result.continuePluginProcessing()) 4102 { 4103 return result; 4104 } 4105 } 4106 4107 if (result == null) 4108 { 4109 // This should only happen if there were no post-response add plugins 4110 // registered, which is fine. 4111 result = PluginResult.PostResponse.continueOperationProcessing(); 4112 } 4113 4114 return result; 4115 } 4116 4117 4118 4119 /** 4120 * Invokes the set of post-response bind plugins that have been configured in 4121 * the Directory Server. 4122 * 4123 * @param bindOperation The bind operation for which to invoke the 4124 * post-response plugins. 4125 * 4126 * @return The result of processing the post-response bind plugins. 4127 */ 4128 public PluginResult.PostResponse invokePostResponseBindPlugins( 4129 PostResponseBindOperation bindOperation) 4130 { 4131 PluginResult.PostResponse result = null; 4132 4133 for (DirectoryServerPlugin p : postResponseBindPlugins) 4134 { 4135 if (bindOperation.isInternalOperation() && 4136 (! p.invokeForInternalOperations())) 4137 { 4138 continue; 4139 } 4140 4141 try 4142 { 4143 result = p.doPostResponse(bindOperation); 4144 } 4145 catch (Exception e) 4146 { 4147 if (debugEnabled()) 4148 { 4149 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4150 } 4151 4152 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4153 get(bindOperation.getOperationType().getOperationName(), 4154 String.valueOf(p.getPluginEntryDN()), 4155 bindOperation.getConnectionID(), bindOperation.getOperationID(), 4156 stackTraceToSingleLineString(e)); 4157 logError(message); 4158 } 4159 4160 if (result == null) 4161 { 4162 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4163 get(bindOperation.getOperationType().getOperationName(), 4164 String.valueOf(p.getPluginEntryDN()), 4165 bindOperation.getConnectionID(), 4166 bindOperation.getOperationID()); 4167 logError(message); 4168 } 4169 else if (!result.continuePluginProcessing()) 4170 { 4171 return result; 4172 } 4173 } 4174 4175 if (result == null) 4176 { 4177 // This should only happen if there were no post-response add plugins 4178 // registered, which is fine. 4179 result = PluginResult.PostResponse.continueOperationProcessing(); 4180 } 4181 4182 return result; 4183 } 4184 4185 4186 4187 /** 4188 * Invokes the set of post-response compare plugins that have been configured 4189 * in the Directory Server. 4190 * 4191 * @param compareOperation The compare operation for which to invoke the 4192 * post-response plugins. 4193 * 4194 * @return The result of processing the post-response compare plugins. 4195 */ 4196 public PluginResult.PostResponse invokePostResponseComparePlugins( 4197 PostResponseCompareOperation compareOperation) 4198 { 4199 PluginResult.PostResponse result = null; 4200 4201 for (DirectoryServerPlugin p : postResponseComparePlugins) 4202 { 4203 if (compareOperation.isInternalOperation() && 4204 (! p.invokeForInternalOperations())) 4205 { 4206 continue; 4207 } 4208 4209 try 4210 { 4211 result = p.doPostResponse(compareOperation); 4212 } 4213 catch (Exception e) 4214 { 4215 if (debugEnabled()) 4216 { 4217 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4218 } 4219 4220 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4221 get(compareOperation.getOperationType().getOperationName(), 4222 String.valueOf(p.getPluginEntryDN()), 4223 compareOperation.getConnectionID(), 4224 compareOperation.getOperationID(), 4225 stackTraceToSingleLineString(e)); 4226 logError(message); 4227 } 4228 4229 if (result == null) 4230 { 4231 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4232 get(compareOperation.getOperationType().getOperationName(), 4233 String.valueOf(p.getPluginEntryDN()), 4234 compareOperation.getConnectionID(), 4235 compareOperation.getOperationID()); 4236 logError(message); 4237 } 4238 else if (!result.continuePluginProcessing()) 4239 { 4240 return result; 4241 } 4242 } 4243 4244 if (result == null) 4245 { 4246 // This should only happen if there were no post-response add plugins 4247 // registered, which is fine. 4248 result = PluginResult.PostResponse.continueOperationProcessing(); 4249 } 4250 4251 return result; 4252 } 4253 4254 4255 4256 /** 4257 * Invokes the set of post-response delete plugins that have been configured 4258 * in the Directory Server. 4259 * 4260 * @param deleteOperation The delete operation for which to invoke the 4261 * post-response plugins. 4262 * 4263 * @return The result of processing the post-response delete plugins. 4264 */ 4265 public PluginResult.PostResponse invokePostResponseDeletePlugins( 4266 PostResponseDeleteOperation deleteOperation) 4267 { 4268 PluginResult.PostResponse result = null; 4269 4270 for (DirectoryServerPlugin p : postResponseDeletePlugins) 4271 { 4272 if (deleteOperation.isInternalOperation() && 4273 (! p.invokeForInternalOperations())) 4274 { 4275 continue; 4276 } 4277 4278 try 4279 { 4280 result = p.doPostResponse(deleteOperation); 4281 } 4282 catch (Exception e) 4283 { 4284 if (debugEnabled()) 4285 { 4286 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4287 } 4288 4289 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4290 get(deleteOperation.getOperationType().getOperationName(), 4291 String.valueOf(p.getPluginEntryDN()), 4292 deleteOperation.getConnectionID(), 4293 deleteOperation.getOperationID(), 4294 stackTraceToSingleLineString(e)); 4295 logError(message); 4296 } 4297 4298 if (result == null) 4299 { 4300 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4301 get(deleteOperation.getOperationType().getOperationName(), 4302 String.valueOf(p.getPluginEntryDN()), 4303 deleteOperation.getConnectionID(), 4304 deleteOperation.getOperationID()); 4305 logError(message); 4306 } 4307 else if (!result.continuePluginProcessing()) 4308 { 4309 return result; 4310 } 4311 } 4312 4313 if (result == null) 4314 { 4315 // This should only happen if there were no post-response add plugins 4316 // registered, which is fine. 4317 result = PluginResult.PostResponse.continueOperationProcessing(); 4318 } 4319 return result; 4320 } 4321 4322 4323 4324 /** 4325 * Invokes the set of post-response extended plugins that have been configured 4326 * in the Directory Server. 4327 * 4328 * @param extendedOperation The extended operation for which to invoke the 4329 * post-response plugins. 4330 * 4331 * @return The result of processing the post-response extended plugins. 4332 */ 4333 public PluginResult.PostResponse invokePostResponseExtendedPlugins( 4334 PostResponseExtendedOperation extendedOperation) 4335 { 4336 PluginResult.PostResponse result = null; 4337 4338 for (DirectoryServerPlugin p : postResponseExtendedPlugins) 4339 { 4340 if (extendedOperation.isInternalOperation() && 4341 (! p.invokeForInternalOperations())) 4342 { 4343 continue; 4344 } 4345 4346 try 4347 { 4348 result = p.doPostResponse(extendedOperation); 4349 } 4350 catch (Exception e) 4351 { 4352 if (debugEnabled()) 4353 { 4354 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4355 } 4356 4357 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4358 get(extendedOperation.getOperationType().getOperationName(), 4359 String.valueOf(p.getPluginEntryDN()), 4360 extendedOperation.getConnectionID(), 4361 extendedOperation.getOperationID(), 4362 stackTraceToSingleLineString(e)); 4363 logError(message); 4364 } 4365 4366 if (result == null) 4367 { 4368 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4369 get(extendedOperation.getOperationType().getOperationName(), 4370 String.valueOf(p.getPluginEntryDN()), 4371 extendedOperation.getConnectionID(), 4372 extendedOperation.getOperationID()); 4373 logError(message); 4374 } 4375 else if (!result.continuePluginProcessing()) 4376 { 4377 return result; 4378 } 4379 } 4380 4381 if (result == null) 4382 { 4383 // This should only happen if there were no post-response add plugins 4384 // registered, which is fine. 4385 result = PluginResult.PostResponse.continueOperationProcessing(); 4386 } 4387 4388 return result; 4389 } 4390 4391 4392 4393 /** 4394 * Invokes the set of post-response modify plugins that have been configured 4395 * in the Directory Server. 4396 * 4397 * @param modifyOperation The modify operation for which to invoke the 4398 * post-response plugins. 4399 * 4400 * @return The result of processing the post-response modify plugins. 4401 */ 4402 public PluginResult.PostResponse invokePostResponseModifyPlugins( 4403 PostResponseModifyOperation modifyOperation) 4404 { 4405 PluginResult.PostResponse result = null; 4406 4407 for (DirectoryServerPlugin p : postResponseModifyPlugins) 4408 { 4409 if (modifyOperation.isInternalOperation() && 4410 (! p.invokeForInternalOperations())) 4411 { 4412 continue; 4413 } 4414 4415 try 4416 { 4417 result = p.doPostResponse(modifyOperation); 4418 } 4419 catch (Exception e) 4420 { 4421 if (debugEnabled()) 4422 { 4423 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4424 } 4425 4426 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4427 get(modifyOperation.getOperationType().getOperationName(), 4428 String.valueOf(p.getPluginEntryDN()), 4429 modifyOperation.getConnectionID(), 4430 modifyOperation.getOperationID(), 4431 stackTraceToSingleLineString(e)); 4432 logError(message); 4433 } 4434 4435 if (result == null) 4436 { 4437 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4438 get(modifyOperation.getOperationType().getOperationName(), 4439 String.valueOf(p.getPluginEntryDN()), 4440 modifyOperation.getConnectionID(), 4441 modifyOperation.getOperationID()); 4442 logError(message); 4443 } 4444 else if (!result.continuePluginProcessing()) 4445 { 4446 return result; 4447 } 4448 } 4449 4450 if (result == null) 4451 { 4452 // This should only happen if there were no post-response add plugins 4453 // registered, which is fine. 4454 result = PluginResult.PostResponse.continueOperationProcessing(); 4455 } 4456 4457 return result; 4458 } 4459 4460 4461 4462 /** 4463 * Invokes the set of post-response modify DN plugins that have been 4464 * configured in the Directory Server. 4465 * 4466 * @param modifyDNOperation The modify DN operation for which to invoke the 4467 * post-response plugins. 4468 * 4469 * @return The result of processing the post-response modify DN plugins. 4470 */ 4471 public PluginResult.PostResponse invokePostResponseModifyDNPlugins( 4472 PostResponseModifyDNOperation modifyDNOperation) 4473 { 4474 PluginResult.PostResponse result = null; 4475 4476 for (DirectoryServerPlugin p : postResponseModifyDNPlugins) 4477 { 4478 if (modifyDNOperation.isInternalOperation() && 4479 (! p.invokeForInternalOperations())) 4480 { 4481 continue; 4482 } 4483 4484 try 4485 { 4486 result = p.doPostResponse(modifyDNOperation); 4487 } 4488 catch (Exception e) 4489 { 4490 if (debugEnabled()) 4491 { 4492 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4493 } 4494 4495 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4496 get(modifyDNOperation.getOperationType().getOperationName(), 4497 String.valueOf(p.getPluginEntryDN()), 4498 modifyDNOperation.getConnectionID(), 4499 modifyDNOperation.getOperationID(), 4500 stackTraceToSingleLineString(e)); 4501 logError(message); 4502 } 4503 4504 if (result == null) 4505 { 4506 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4507 get(modifyDNOperation.getOperationType().getOperationName(), 4508 String.valueOf(p.getPluginEntryDN()), 4509 modifyDNOperation.getConnectionID(), 4510 modifyDNOperation.getOperationID()); 4511 logError(message); 4512 } 4513 else if (!result.continuePluginProcessing()) 4514 { 4515 return result; 4516 } 4517 } 4518 4519 if (result == null) 4520 { 4521 // This should only happen if there were no post-response add plugins 4522 // registered, which is fine. 4523 result = PluginResult.PostResponse.continueOperationProcessing(); 4524 } 4525 4526 return result; 4527 } 4528 4529 4530 4531 /** 4532 * Invokes the set of post-response search plugins that have been configured 4533 * in the Directory Server. 4534 * 4535 * @param searchOperation The search operation for which to invoke the 4536 * post-response plugins. 4537 * 4538 * @return The result of processing the post-response search plugins. 4539 */ 4540 public PluginResult.PostResponse invokePostResponseSearchPlugins( 4541 PostResponseSearchOperation searchOperation) 4542 { 4543 PluginResult.PostResponse result = null; 4544 4545 for (DirectoryServerPlugin p : postResponseSearchPlugins) 4546 { 4547 if (searchOperation.isInternalOperation() && 4548 (! p.invokeForInternalOperations())) 4549 { 4550 continue; 4551 } 4552 4553 try 4554 { 4555 result = p.doPostResponse(searchOperation); 4556 } 4557 catch (Exception e) 4558 { 4559 if (debugEnabled()) 4560 { 4561 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4562 } 4563 4564 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_EXCEPTION. 4565 get(searchOperation.getOperationType().getOperationName(), 4566 String.valueOf(p.getPluginEntryDN()), 4567 searchOperation.getConnectionID(), 4568 searchOperation.getOperationID(), 4569 stackTraceToSingleLineString(e)); 4570 logError(message); 4571 } 4572 4573 if (result == null) 4574 { 4575 Message message = ERR_PLUGIN_POST_RESPONSE_PLUGIN_RETURNED_NULL. 4576 get(searchOperation.getOperationType().getOperationName(), 4577 String.valueOf(p.getPluginEntryDN()), 4578 searchOperation.getConnectionID(), 4579 searchOperation.getOperationID()); 4580 logError(message); 4581 } 4582 else if (!result.continuePluginProcessing()) 4583 { 4584 return result; 4585 } 4586 } 4587 4588 if (result == null) 4589 { 4590 // This should only happen if there were no post-response add plugins 4591 // registered, which is fine. 4592 result = PluginResult.PostResponse.continueOperationProcessing(); 4593 } 4594 4595 return result; 4596 } 4597 4598 4599 4600 /** 4601 * Invokes the set of post-synchronization add plugins that have been 4602 * configured in the Directory Server. 4603 * 4604 * @param addOperation The add operation for which to invoke the 4605 * post-synchronization plugins. 4606 */ 4607 public void invokePostSynchronizationAddPlugins( 4608 PostSynchronizationAddOperation addOperation) 4609 { 4610 for (DirectoryServerPlugin p : postSynchronizationAddPlugins) 4611 { 4612 try 4613 { 4614 p.doPostSynchronization(addOperation); 4615 } 4616 catch (Exception e) 4617 { 4618 if (debugEnabled()) 4619 { 4620 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4621 } 4622 4623 Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION. 4624 get(addOperation.getOperationType().getOperationName(), 4625 String.valueOf(p.getPluginEntryDN()), 4626 addOperation.getConnectionID(), addOperation.getOperationID(), 4627 stackTraceToSingleLineString(e)); 4628 logError(message); 4629 } 4630 } 4631 } 4632 4633 4634 4635 /** 4636 * Invokes the set of post-synchronization delete plugins that have been 4637 * configured in the Directory Server. 4638 * 4639 * @param deleteOperation The delete operation for which to invoke the 4640 * post-synchronization plugins. 4641 */ 4642 public void invokePostSynchronizationDeletePlugins( 4643 PostSynchronizationDeleteOperation deleteOperation) 4644 { 4645 for (DirectoryServerPlugin p : postSynchronizationDeletePlugins) 4646 { 4647 try 4648 { 4649 p.doPostSynchronization(deleteOperation); 4650 } 4651 catch (Exception e) 4652 { 4653 if (debugEnabled()) 4654 { 4655 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4656 } 4657 4658 Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION. 4659 get(deleteOperation.getOperationType().getOperationName(), 4660 String.valueOf(p.getPluginEntryDN()), 4661 deleteOperation.getConnectionID(), 4662 deleteOperation.getOperationID(), 4663 stackTraceToSingleLineString(e)); 4664 logError(message); 4665 } 4666 } 4667 } 4668 4669 4670 4671 /** 4672 * Invokes the set of post-synchronization modify plugins that have been 4673 * configured in the Directory Server. 4674 * 4675 * @param modifyOperation The modify operation for which to invoke the 4676 * post-synchronization plugins. 4677 */ 4678 public void invokePostSynchronizationModifyPlugins( 4679 PostSynchronizationModifyOperation modifyOperation) 4680 { 4681 for (DirectoryServerPlugin p : postSynchronizationModifyPlugins) 4682 { 4683 try 4684 { 4685 p.doPostSynchronization(modifyOperation); 4686 } 4687 catch (Exception e) 4688 { 4689 if (debugEnabled()) 4690 { 4691 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4692 } 4693 4694 Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION. 4695 get(modifyOperation.getOperationType().getOperationName(), 4696 String.valueOf(p.getPluginEntryDN()), 4697 modifyOperation.getConnectionID(), 4698 modifyOperation.getOperationID(), 4699 stackTraceToSingleLineString(e)); 4700 logError(message); 4701 } 4702 } 4703 } 4704 4705 4706 4707 /** 4708 * Invokes the set of post-synchronization modify DN plugins that have been 4709 * configured in the Directory Server. 4710 * 4711 * @param modifyDNOperation The modify DN operation for which to invoke the 4712 * post-synchronization plugins. 4713 */ 4714 public void invokePostSynchronizationModifyDNPlugins( 4715 PostSynchronizationModifyDNOperation modifyDNOperation) 4716 { 4717 for (DirectoryServerPlugin p : postSynchronizationModifyDNPlugins) 4718 { 4719 try 4720 { 4721 p.doPostSynchronization(modifyDNOperation); 4722 } 4723 catch (Exception e) 4724 { 4725 if (debugEnabled()) 4726 { 4727 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4728 } 4729 4730 Message message = ERR_PLUGIN_POST_SYNCHRONIZATION_PLUGIN_EXCEPTION. 4731 get(modifyDNOperation.getOperationType().getOperationName(), 4732 String.valueOf(p.getPluginEntryDN()), 4733 modifyDNOperation.getConnectionID(), 4734 modifyDNOperation.getOperationID(), 4735 stackTraceToSingleLineString(e)); 4736 logError(message); 4737 } 4738 } 4739 } 4740 4741 4742 4743 /** 4744 * Invokes the set of search result entry plugins that have been configured 4745 * in the Directory Server. 4746 * 4747 * @param searchOperation The search operation for which to invoke the 4748 * search result entry plugins. 4749 * @param searchEntry The search result entry to be processed. 4750 * 4751 * @return The result of processing the search result entry plugins. 4752 */ 4753 public PluginResult.IntermediateResponse invokeSearchResultEntryPlugins( 4754 LocalBackendSearchOperation searchOperation, 4755 SearchResultEntry searchEntry) 4756 { 4757 PluginResult.IntermediateResponse result = null; 4758 4759 for (DirectoryServerPlugin p : searchResultEntryPlugins) 4760 { 4761 if (searchOperation.isInternalOperation() && 4762 (! p.invokeForInternalOperations())) 4763 { 4764 continue; 4765 } 4766 4767 try 4768 { 4769 result = p.processSearchEntry(searchOperation, searchEntry); 4770 } 4771 catch (Exception e) 4772 { 4773 if (debugEnabled()) 4774 { 4775 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4776 } 4777 4778 Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_EXCEPTION. 4779 get(String.valueOf(p.getPluginEntryDN()), 4780 searchOperation.getConnectionID(), 4781 searchOperation.getOperationID(), 4782 String.valueOf(searchEntry.getDN()), 4783 stackTraceToSingleLineString(e)); 4784 logError(message); 4785 4786 return PluginResult.IntermediateResponse.stopProcessing(false, 4787 DirectoryServer.getServerErrorResultCode(), message); 4788 } 4789 4790 if (result == null) 4791 { 4792 Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_RETURNED_NULL. 4793 get(String.valueOf(p.getPluginEntryDN()), 4794 searchOperation.getConnectionID(), 4795 searchOperation.getOperationID(), 4796 String.valueOf(searchEntry.getDN())); 4797 logError(message); 4798 4799 return PluginResult.IntermediateResponse.stopProcessing(false, 4800 DirectoryServer.getServerErrorResultCode(), message); 4801 } 4802 else if (! result.continuePluginProcessing()) 4803 { 4804 return result; 4805 } 4806 } 4807 4808 if (result == null) 4809 { 4810 // This should only happen if there were no search result entry plugins 4811 // registered, which is fine. 4812 result = PluginResult.IntermediateResponse. 4813 continueOperationProcessing(true); 4814 } 4815 4816 return result; 4817 } 4818 4819 4820 4821 /** 4822 * Invokes the set of search result entry plugins that have been configured 4823 * in the Directory Server. 4824 * 4825 * @param searchOperation The search operation for which to invoke the 4826 * search result entry plugins. 4827 * @param searchEntry The search result entry to be processed. 4828 * 4829 * @return The result of processing the search result entry plugins. 4830 */ 4831 public PluginResult.IntermediateResponse invokeSearchResultEntryPlugins( 4832 SearchEntrySearchOperation searchOperation, 4833 SearchResultEntry searchEntry) 4834 { 4835 PluginResult.IntermediateResponse result = null; 4836 4837 for (DirectoryServerPlugin p : searchResultEntryPlugins) 4838 { 4839 if (searchOperation.isInternalOperation() && 4840 (! p.invokeForInternalOperations())) 4841 { 4842 continue; 4843 } 4844 4845 if (searchOperation.isInternalOperation() && 4846 (! p.invokeForInternalOperations())) 4847 { 4848 continue; 4849 } 4850 4851 try 4852 { 4853 result = p.processSearchEntry(searchOperation, searchEntry); 4854 } 4855 catch (Exception e) 4856 { 4857 if (debugEnabled()) 4858 { 4859 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4860 } 4861 4862 Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_EXCEPTION. 4863 get(String.valueOf(p.getPluginEntryDN()), 4864 searchOperation.getConnectionID(), 4865 searchOperation.getOperationID(), 4866 String.valueOf(searchEntry.getDN()), 4867 stackTraceToSingleLineString(e)); 4868 logError(message); 4869 4870 return PluginResult.IntermediateResponse.stopProcessing(false, 4871 DirectoryServer.getServerErrorResultCode(), message); 4872 } 4873 4874 if (result == null) 4875 { 4876 Message message = ERR_PLUGIN_SEARCH_ENTRY_PLUGIN_RETURNED_NULL. 4877 get(String.valueOf(p.getPluginEntryDN()), 4878 searchOperation.getConnectionID(), 4879 searchOperation.getOperationID(), 4880 String.valueOf(searchEntry.getDN())); 4881 logError(message); 4882 4883 return PluginResult.IntermediateResponse.stopProcessing(false, 4884 DirectoryServer.getServerErrorResultCode(), message); 4885 } 4886 else if (! result.continuePluginProcessing()) 4887 { 4888 return result; 4889 } 4890 } 4891 4892 if (result == null) 4893 { 4894 // This should only happen if there were no search result entry plugins 4895 // registered, which is fine. 4896 result = 4897 PluginResult.IntermediateResponse.continueOperationProcessing(true); 4898 } 4899 4900 return result; 4901 } 4902 4903 4904 4905 /** 4906 * Invokes the set of search result reference plugins that have been 4907 * configured in the Directory Server. 4908 * 4909 * @param searchOperation The search operation for which to invoke the 4910 * search result reference plugins. 4911 * @param searchReference The search result reference to be processed. 4912 * 4913 * @return The result of processing the search result reference plugins. 4914 */ 4915 public PluginResult.IntermediateResponse invokeSearchResultReferencePlugins( 4916 LocalBackendSearchOperation searchOperation, 4917 SearchResultReference searchReference) 4918 { 4919 PluginResult.IntermediateResponse result = null; 4920 4921 for (DirectoryServerPlugin p : searchResultReferencePlugins) 4922 { 4923 if (searchOperation.isInternalOperation() && 4924 (! p.invokeForInternalOperations())) 4925 { 4926 continue; 4927 } 4928 4929 try 4930 { 4931 result = p.processSearchReference(searchOperation, searchReference); 4932 } 4933 catch (Exception e) 4934 { 4935 if (debugEnabled()) 4936 { 4937 TRACER.debugCaught(DebugLogLevel.ERROR, e); 4938 } 4939 4940 Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_EXCEPTION. 4941 get(String.valueOf(p.getPluginEntryDN()), 4942 searchOperation.getConnectionID(), 4943 searchOperation.getOperationID(), 4944 searchReference.getReferralURLString(), 4945 stackTraceToSingleLineString(e)); 4946 logError(message); 4947 4948 return PluginResult.IntermediateResponse.stopProcessing(false, 4949 DirectoryServer.getServerErrorResultCode(), message); 4950 } 4951 4952 if (result == null) 4953 { 4954 Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_RETURNED_NULL. 4955 get(String.valueOf(p.getPluginEntryDN()), 4956 searchOperation.getConnectionID(), 4957 searchOperation.getOperationID(), 4958 searchReference.getReferralURLString()); 4959 logError(message); 4960 4961 return PluginResult.IntermediateResponse.stopProcessing(false, 4962 DirectoryServer.getServerErrorResultCode(), message); 4963 } 4964 else if (! result.continuePluginProcessing()) 4965 { 4966 return result; 4967 } 4968 } 4969 4970 if (result == null) 4971 { 4972 // This should only happen if there were no search result reference 4973 // plugins registered, which is fine. 4974 result = 4975 PluginResult.IntermediateResponse.continueOperationProcessing(true); 4976 } 4977 4978 return result; 4979 } 4980 4981 4982 4983 /** 4984 * Invokes the set of search result reference plugins that have been 4985 * configured in the Directory Server. 4986 * 4987 * @param searchOperation The search operation for which to invoke the 4988 * search result reference plugins. 4989 * @param searchReference The search result reference to be processed. 4990 * 4991 * @return The result of processing the search result reference plugins. 4992 */ 4993 public PluginResult.IntermediateResponse invokeSearchResultReferencePlugins( 4994 SearchReferenceSearchOperation searchOperation, 4995 SearchResultReference searchReference) 4996 { 4997 PluginResult.IntermediateResponse result = null; 4998 4999 for (DirectoryServerPlugin p : searchResultReferencePlugins) 5000 { 5001 if (searchOperation.isInternalOperation() && 5002 (! p.invokeForInternalOperations())) 5003 { 5004 continue; 5005 } 5006 5007 try 5008 { 5009 result = p.processSearchReference(searchOperation, searchReference); 5010 } 5011 catch (Exception e) 5012 { 5013 if (debugEnabled()) 5014 { 5015 TRACER.debugCaught(DebugLogLevel.ERROR, e); 5016 } 5017 5018 Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_EXCEPTION. 5019 get(String.valueOf(p.getPluginEntryDN()), 5020 searchOperation.getConnectionID(), 5021 searchOperation.getOperationID(), 5022 searchReference.getReferralURLString(), 5023 stackTraceToSingleLineString(e)); 5024 logError(message); 5025 5026 return PluginResult.IntermediateResponse.stopProcessing(false, 5027 DirectoryServer.getServerErrorResultCode(), message); 5028 } 5029 5030 if (result == null) 5031 { 5032 Message message = ERR_PLUGIN_SEARCH_REFERENCE_PLUGIN_RETURNED_NULL. 5033 get(String.valueOf(p.getPluginEntryDN()), 5034 searchOperation.getConnectionID(), 5035 searchOperation.getOperationID(), 5036 searchReference.getReferralURLString()); 5037 logError(message); 5038 5039 return PluginResult.IntermediateResponse.stopProcessing(false, 5040 DirectoryServer.getServerErrorResultCode(), message); 5041 } 5042 else if (! result.continuePluginProcessing()) 5043 { 5044 return result; 5045 } 5046 } 5047 5048 if (result == null) 5049 { 5050 // This should only happen if there were no search result reference 5051 // plugins registered, which is fine. 5052 result = 5053 PluginResult.IntermediateResponse.continueOperationProcessing(true); 5054 } 5055 5056 return result; 5057 } 5058 5059 5060 5061 /** 5062 * Invokes the set of subordinate modify DN plugins that have been configured 5063 * in the Directory Server. 5064 * 5065 * @param modifyDNOperation The modify DN operation with which the 5066 * subordinate entry is associated. 5067 * @param oldEntry The subordinate entry prior to the move/rename 5068 * operation. 5069 * @param newEntry The subordinate entry after the move/rename 5070 * operation. 5071 * @param modifications A list into which any modifications made to the 5072 * target entry should be placed. 5073 * 5074 * @return The result of processing the subordinate modify DN plugins. 5075 */ 5076 public PluginResult.SubordinateModifyDN invokeSubordinateModifyDNPlugins( 5077 SubordinateModifyDNOperation modifyDNOperation, Entry oldEntry, 5078 Entry newEntry, List<Modification> modifications) 5079 { 5080 PluginResult.SubordinateModifyDN result = null; 5081 5082 for (DirectoryServerPlugin p : subordinateModifyDNPlugins) 5083 { 5084 if (modifyDNOperation.isInternalOperation() && 5085 (! p.invokeForInternalOperations())) 5086 { 5087 continue; 5088 } 5089 5090 try 5091 { 5092 DirectoryServerPlugin<? extends PluginCfg> gp = 5093 (DirectoryServerPlugin<? extends PluginCfg>) p; 5094 result = gp.processSubordinateModifyDN(modifyDNOperation, oldEntry, 5095 newEntry, modifications); 5096 } 5097 catch (Exception e) 5098 { 5099 if (debugEnabled()) 5100 { 5101 TRACER.debugCaught(DebugLogLevel.ERROR, e); 5102 } 5103 5104 Message message = 5105 ERR_PLUGIN_SUBORDINATE_MODIFY_DN_PLUGIN_EXCEPTION.get( 5106 String.valueOf(p.getPluginEntryDN()), 5107 modifyDNOperation.getConnectionID(), 5108 modifyDNOperation.getOperationID(), 5109 stackTraceToSingleLineString(e)); 5110 logError(message); 5111 5112 return PluginResult.SubordinateModifyDN.stopProcessing( 5113 DirectoryServer.getServerErrorResultCode(), message); 5114 } 5115 5116 if (result == null) 5117 { 5118 Message message = 5119 ERR_PLUGIN_SUBORDINATE_MODIFY_DN_PLUGIN_RETURNED_NULL.get( 5120 String.valueOf(p.getPluginEntryDN()), 5121 modifyDNOperation.getConnectionID(), 5122 String.valueOf(modifyDNOperation.getOperationID())); 5123 logError(message); 5124 5125 return PluginResult.SubordinateModifyDN.stopProcessing( 5126 DirectoryServer.getServerErrorResultCode(), message); 5127 } 5128 else if (! result.continuePluginProcessing()) 5129 { 5130 return result; 5131 } 5132 } 5133 5134 if (result == null) 5135 { 5136 // This should only happen if there were no subordinate modify DN plugins 5137 // registered, which is fine. 5138 result = PluginResult.SubordinateModifyDN.continueOperationProcessing(); 5139 } 5140 5141 return result; 5142 } 5143 5144 5145 5146 /** 5147 * Invokes the set of intermediate response plugins that have been configured 5148 * in the Directory Server. 5149 * 5150 * @param intermediateResponse The intermediate response for which to invoke 5151 * the intermediate response plugins. 5152 * 5153 * @return The result of processing the intermediate response plugins. 5154 */ 5155 public PluginResult.IntermediateResponse 5156 invokeIntermediateResponsePlugins( 5157 IntermediateResponse intermediateResponse) 5158 { 5159 PluginResult.IntermediateResponse result = null; 5160 Operation operation = intermediateResponse.getOperation(); 5161 5162 for (DirectoryServerPlugin p : intermediateResponsePlugins) 5163 { 5164 try 5165 { 5166 result = p.processIntermediateResponse(intermediateResponse); 5167 } 5168 catch (Exception e) 5169 { 5170 if (debugEnabled()) 5171 { 5172 TRACER.debugCaught(DebugLogLevel.ERROR, e); 5173 } 5174 5175 Message message = ERR_PLUGIN_INTERMEDIATE_RESPONSE_PLUGIN_EXCEPTION. 5176 get(String.valueOf(p.getPluginEntryDN()), 5177 operation.getConnectionID(), operation.getOperationID(), 5178 stackTraceToSingleLineString(e)); 5179 logError(message); 5180 5181 return PluginResult.IntermediateResponse.stopProcessing 5182 (false, DirectoryServer.getServerErrorResultCode(), message); 5183 } 5184 5185 if (result == null) 5186 { 5187 Message message = ERR_PLUGIN_INTERMEDIATE_RESPONSE_PLUGIN_RETURNED_NULL. 5188 get(String.valueOf(p.getPluginEntryDN()), 5189 operation.getConnectionID(), operation.getOperationID()); 5190 logError(message); 5191 5192 return PluginResult.IntermediateResponse.stopProcessing 5193 (false, DirectoryServer.getServerErrorResultCode(), message); 5194 } 5195 else if (! result.continuePluginProcessing()) 5196 { 5197 return result; 5198 } 5199 } 5200 5201 if (result == null) 5202 { 5203 // This should only happen if there were no intermediate response plugins 5204 // registered, which is fine. 5205 result = 5206 PluginResult.IntermediateResponse.continueOperationProcessing(true); 5207 } 5208 5209 return result; 5210 } 5211 5212 5213 5214 /** 5215 * {@inheritDoc} 5216 */ 5217 public boolean isConfigurationAddAcceptable(PluginCfg configuration, 5218 List<Message> unacceptableReasons) 5219 { 5220 if (configuration.isEnabled()) 5221 { 5222 // Create a set of plugin types for the plugin. 5223 HashSet<PluginType> pluginTypes = new HashSet<PluginType>(); 5224 for (PluginCfgDefn.PluginType pluginType : 5225 configuration.getPluginType()) 5226 { 5227 pluginTypes.add(getPluginType(pluginType)); 5228 } 5229 5230 // Get the name of the class and make sure we can instantiate it as a 5231 // plugin. 5232 String className = configuration.getJavaClass(); 5233 try 5234 { 5235 loadPlugin(className, pluginTypes, configuration, false); 5236 } 5237 catch (InitializationException ie) 5238 { 5239 unacceptableReasons.add(ie.getMessageObject()); 5240 return false; 5241 } 5242 } 5243 5244 // If we've gotten here, then it's fine. 5245 return true; 5246 } 5247 5248 5249 5250 /** 5251 * {@inheritDoc} 5252 */ 5253 public ConfigChangeResult applyConfigurationAdd( 5254 PluginCfg configuration) 5255 { 5256 ResultCode resultCode = ResultCode.SUCCESS; 5257 boolean adminActionRequired = false; 5258 ArrayList<Message> messages = new ArrayList<Message>(); 5259 5260 configuration.addChangeListener(this); 5261 5262 if (! configuration.isEnabled()) 5263 { 5264 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5265 } 5266 5267 // Create a set of plugin types for the plugin. 5268 HashSet<PluginType> pluginTypes = new HashSet<PluginType>(); 5269 for (PluginCfgDefn.PluginType pluginType : 5270 configuration.getPluginType()) 5271 { 5272 pluginTypes.add(getPluginType(pluginType)); 5273 } 5274 5275 // Get the name of the class and make sure we can instantiate it as a 5276 // plugin. 5277 DirectoryServerPlugin<? extends PluginCfg> plugin = null; 5278 String className = configuration.getJavaClass(); 5279 try 5280 { 5281 plugin = loadPlugin(className, pluginTypes, configuration, true); 5282 } 5283 catch (InitializationException ie) 5284 { 5285 if (resultCode == ResultCode.SUCCESS) 5286 { 5287 resultCode = DirectoryServer.getServerErrorResultCode(); 5288 } 5289 5290 messages.add(ie.getMessageObject()); 5291 } 5292 5293 if (resultCode == ResultCode.SUCCESS) 5294 { 5295 registerPlugin(plugin, configuration.dn(), pluginTypes); 5296 } 5297 5298 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5299 } 5300 5301 5302 5303 /** 5304 * {@inheritDoc} 5305 */ 5306 public boolean isConfigurationDeleteAcceptable( 5307 PluginCfg configuration, 5308 List<Message> unacceptableReasons) 5309 { 5310 // We will always allow plugins to be removed. 5311 return true; 5312 } 5313 5314 5315 5316 /** 5317 * {@inheritDoc} 5318 */ 5319 public ConfigChangeResult applyConfigurationDelete( 5320 PluginCfg configuration) 5321 { 5322 ResultCode resultCode = ResultCode.SUCCESS; 5323 boolean adminActionRequired = false; 5324 ArrayList<Message> messages = new ArrayList<Message>(); 5325 5326 deregisterPlugin(configuration.dn()); 5327 5328 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5329 } 5330 5331 5332 5333 /** 5334 * {@inheritDoc} 5335 */ 5336 public boolean isConfigurationChangeAcceptable( 5337 PluginCfg configuration, 5338 List<Message> unacceptableReasons) 5339 { 5340 if (configuration.isEnabled()) 5341 { 5342 // Create a set of plugin types for the plugin. 5343 HashSet<PluginType> pluginTypes = new HashSet<PluginType>(); 5344 for (PluginCfgDefn.PluginType pluginType : 5345 configuration.getPluginType()) 5346 { 5347 pluginTypes.add(getPluginType(pluginType)); 5348 } 5349 5350 // Get the name of the class and make sure we can instantiate it as a 5351 // plugin. 5352 String className = configuration.getJavaClass(); 5353 try 5354 { 5355 loadPlugin(className, pluginTypes, configuration, false); 5356 } 5357 catch (InitializationException ie) 5358 { 5359 unacceptableReasons.add(ie.getMessageObject()); 5360 return false; 5361 } 5362 } 5363 5364 // If we've gotten here, then it's fine. 5365 return true; 5366 } 5367 5368 5369 5370 /** 5371 * {@inheritDoc} 5372 */ 5373 public ConfigChangeResult applyConfigurationChange( 5374 PluginCfg configuration) 5375 { 5376 ResultCode resultCode = ResultCode.SUCCESS; 5377 boolean adminActionRequired = false; 5378 ArrayList<Message> messages = new ArrayList<Message>(); 5379 5380 5381 // Get the existing plugin if it's already enabled. 5382 DirectoryServerPlugin existingPlugin = 5383 registeredPlugins.get(configuration.dn()); 5384 5385 5386 // If the new configuration has the plugin disabled, then deregister it if 5387 // it is enabled, or do nothing if it's already disabled. 5388 if (! configuration.isEnabled()) 5389 { 5390 if (existingPlugin != null) 5391 { 5392 deregisterPlugin(configuration.dn()); 5393 } 5394 5395 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5396 } 5397 5398 5399 // Get the class for the identity mapper. If the mapper is already enabled, 5400 // then we shouldn't do anything with it although if the class has changed 5401 // then we'll at least need to indicate that administrative action is 5402 // required. If the mapper is disabled, then instantiate the class and 5403 // initialize and register it as an identity mapper. Also, update the 5404 // plugin to indicate whether it should be invoked for internal operations. 5405 String className = configuration.getJavaClass(); 5406 if (existingPlugin != null) 5407 { 5408 if (! className.equals(existingPlugin.getClass().getName())) 5409 { 5410 adminActionRequired = true; 5411 } 5412 5413 existingPlugin.setInvokeForInternalOperations( 5414 configuration.isInvokeForInternalOperations()); 5415 5416 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5417 } 5418 5419 // Create a set of plugin types for the plugin. 5420 HashSet<PluginType> pluginTypes = new HashSet<PluginType>(); 5421 for (PluginCfgDefn.PluginType pluginType : 5422 configuration.getPluginType()) 5423 { 5424 pluginTypes.add(getPluginType(pluginType)); 5425 } 5426 5427 DirectoryServerPlugin<? extends PluginCfg> plugin = null; 5428 try 5429 { 5430 plugin = loadPlugin(className, pluginTypes, configuration, true); 5431 } 5432 catch (InitializationException ie) 5433 { 5434 if (resultCode == ResultCode.SUCCESS) 5435 { 5436 resultCode = DirectoryServer.getServerErrorResultCode(); 5437 } 5438 5439 messages.add(ie.getMessageObject()); 5440 } 5441 5442 if (resultCode == ResultCode.SUCCESS) 5443 { 5444 registerPlugin(plugin, configuration.dn(), pluginTypes); 5445 } 5446 5447 return new ConfigChangeResult(resultCode, adminActionRequired, messages); 5448 } 5449 5450 private void registerSkippedPreOperationPlugins(int i, 5451 DirectoryServerPlugin[] plugins, 5452 PluginOperation operation) 5453 { 5454 ArrayList<DirectoryServerPlugin> skippedPlugins = 5455 new ArrayList<DirectoryServerPlugin>(plugins.length - i); 5456 for(int j = i; j < plugins.length; j++) 5457 { 5458 skippedPlugins.add(plugins[j]); 5459 } 5460 skippedPreOperationPlugins.put(operation, skippedPlugins); 5461 } 5462 5463 private void registerSkippedPreOperationPlugin(DirectoryServerPlugin plugin, 5464 PluginOperation operation) 5465 { 5466 ArrayList<DirectoryServerPlugin> existingList = 5467 skippedPreOperationPlugins.get(operation); 5468 if(existingList == null) 5469 { 5470 existingList = new ArrayList<DirectoryServerPlugin>(); 5471 } 5472 existingList.add(plugin); 5473 skippedPreOperationPlugins.put(operation, existingList); 5474 } 5475 } 5476