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 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.admin.std.meta; 028 029 030 031 import java.util.Collection; 032 import java.util.SortedSet; 033 import org.opends.server.admin.AdministratorAction; 034 import org.opends.server.admin.BooleanPropertyDefinition; 035 import org.opends.server.admin.ClassPropertyDefinition; 036 import org.opends.server.admin.client.AuthorizationException; 037 import org.opends.server.admin.client.CommunicationException; 038 import org.opends.server.admin.client.ConcurrentModificationException; 039 import org.opends.server.admin.client.ManagedObject; 040 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 041 import org.opends.server.admin.client.OperationRejectedException; 042 import org.opends.server.admin.DefaultBehaviorProvider; 043 import org.opends.server.admin.DefinedDefaultBehaviorProvider; 044 import org.opends.server.admin.EnumPropertyDefinition; 045 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 046 import org.opends.server.admin.ManagedObjectDefinition; 047 import org.opends.server.admin.PropertyOption; 048 import org.opends.server.admin.PropertyProvider; 049 import org.opends.server.admin.server.ConfigurationChangeListener; 050 import org.opends.server.admin.server.ServerManagedObject; 051 import org.opends.server.admin.std.client.PluginCfgClient; 052 import org.opends.server.admin.std.server.PluginCfg; 053 import org.opends.server.admin.Tag; 054 import org.opends.server.admin.TopCfgDefn; 055 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 056 import org.opends.server.types.DN; 057 058 059 060 /** 061 * An interface for querying the Plugin managed object definition meta 062 * information. 063 * <p> 064 * Plugins provide a mechanism for executing custom code at specified 065 * points in operation processing and in the course of other events 066 * like connection establishment and termination, server startup and 067 * shutdown, and LDIF import and export. 068 */ 069 public final class PluginCfgDefn extends ManagedObjectDefinition<PluginCfgClient, PluginCfg> { 070 071 // The singleton configuration definition instance. 072 private static final PluginCfgDefn INSTANCE = new PluginCfgDefn(); 073 074 075 076 /** 077 * Defines the set of permissable values for the "plugin-type" property. 078 * <p> 079 * Specifies the set of plug-in types for the plug-in, which 080 * specifies the times at which the plug-in is invoked. 081 */ 082 public static enum PluginType { 083 084 /** 085 * Invoked before sending an intermediate repsonse message to the 086 * client. 087 */ 088 INTERMEDIATERESPONSE("intermediateresponse"), 089 090 091 092 /** 093 * Invoked for each operation to be written during an LDIF export. 094 */ 095 LDIFEXPORT("ldifexport"), 096 097 098 099 /** 100 * Invoked for each entry read during an LDIF import. 101 */ 102 LDIFIMPORT("ldifimport"), 103 104 105 106 /** 107 * Invoked whenever a new connection is established to the server. 108 */ 109 POSTCONNECT("postconnect"), 110 111 112 113 /** 114 * Invoked whenever an existing connection is terminated (by 115 * either the client or the server). 116 */ 117 POSTDISCONNECT("postdisconnect"), 118 119 120 121 /** 122 * Invoked after completing the abandon processing. 123 */ 124 POSTOPERATIONABANDON("postoperationabandon"), 125 126 127 128 /** 129 * Invoked after completing the core add processing but before 130 * sending the response to the client. 131 */ 132 POSTOPERATIONADD("postoperationadd"), 133 134 135 136 /** 137 * Invoked after completing the core bind processing but before 138 * sending the response to the client. 139 */ 140 POSTOPERATIONBIND("postoperationbind"), 141 142 143 144 /** 145 * Invoked after completing the core compare processing but before 146 * sending the response to the client. 147 */ 148 POSTOPERATIONCOMPARE("postoperationcompare"), 149 150 151 152 /** 153 * Invoked after completing the core delete processing but before 154 * sending the response to the client. 155 */ 156 POSTOPERATIONDELETE("postoperationdelete"), 157 158 159 160 /** 161 * Invoked after completing the core extended processing but 162 * before sending the response to the client. 163 */ 164 POSTOPERATIONEXTENDED("postoperationextended"), 165 166 167 168 /** 169 * Invoked after completing the core modify processing but before 170 * sending the response to the client. 171 */ 172 POSTOPERATIONMODIFY("postoperationmodify"), 173 174 175 176 /** 177 * Invoked after completing the core modify DN processing but 178 * before sending the response to the client. 179 */ 180 POSTOPERATIONMODIFYDN("postoperationmodifydn"), 181 182 183 184 /** 185 * Invoked after completing the core search processing but before 186 * sending the response to the client. 187 */ 188 POSTOPERATIONSEARCH("postoperationsearch"), 189 190 191 192 /** 193 * Invoked after completing the unbind processing. 194 */ 195 POSTOPERATIONUNBIND("postoperationunbind"), 196 197 198 199 /** 200 * Invoked after sending the add response to the client. 201 */ 202 POSTRESPONSEADD("postresponseadd"), 203 204 205 206 /** 207 * Invoked after sending the bind response to the client. 208 */ 209 POSTRESPONSEBIND("postresponsebind"), 210 211 212 213 /** 214 * Invoked after sending the compare response to the client. 215 */ 216 POSTRESPONSECOMPARE("postresponsecompare"), 217 218 219 220 /** 221 * Invoked after sending the delete response to the client. 222 */ 223 POSTRESPONSEDELETE("postresponsedelete"), 224 225 226 227 /** 228 * Invoked after sending the extended response to the client. 229 */ 230 POSTRESPONSEEXTENDED("postresponseextended"), 231 232 233 234 /** 235 * Invoked after sending the modify response to the client. 236 */ 237 POSTRESPONSEMODIFY("postresponsemodify"), 238 239 240 241 /** 242 * Invoked after sending the modify DN response to the client. 243 */ 244 POSTRESPONSEMODIFYDN("postresponsemodifydn"), 245 246 247 248 /** 249 * Invoked after sending the search result done message to the 250 * client. 251 */ 252 POSTRESPONSESEARCH("postresponsesearch"), 253 254 255 256 /** 257 * Invoked after completing post-synchronization processing for an 258 * add operation. 259 */ 260 POSTSYNCHRONIZATIONADD("postsynchronizationadd"), 261 262 263 264 /** 265 * Invoked after completing post-synchronization processing for a 266 * delete operation. 267 */ 268 POSTSYNCHRONIZATIONDELETE("postsynchronizationdelete"), 269 270 271 272 /** 273 * Invoked after completing post-synchronization processing for a 274 * modify operation. 275 */ 276 POSTSYNCHRONIZATIONMODIFY("postsynchronizationmodify"), 277 278 279 280 /** 281 * Invoked after completing post-synchronization processing for a 282 * modify DN operation. 283 */ 284 POSTSYNCHRONIZATIONMODIFYDN("postsynchronizationmodifydn"), 285 286 287 288 /** 289 * Invoked prior to performing the core add processing. 290 */ 291 PREOPERATIONADD("preoperationadd"), 292 293 294 295 /** 296 * Invoked prior to performing the core bind processing. 297 */ 298 PREOPERATIONBIND("preoperationbind"), 299 300 301 302 /** 303 * Invoked prior to performing the core compare processing. 304 */ 305 PREOPERATIONCOMPARE("preoperationcompare"), 306 307 308 309 /** 310 * Invoked prior to performing the core delete processing. 311 */ 312 PREOPERATIONDELETE("preoperationdelete"), 313 314 315 316 /** 317 * Invoked prior to performing the core extended processing. 318 */ 319 PREOPERATIONEXTENDED("preoperationextended"), 320 321 322 323 /** 324 * Invoked prior to performing the core modify processing. 325 */ 326 PREOPERATIONMODIFY("preoperationmodify"), 327 328 329 330 /** 331 * Invoked prior to performing the core modify DN processing. 332 */ 333 PREOPERATIONMODIFYDN("preoperationmodifydn"), 334 335 336 337 /** 338 * Invoked prior to performing the core search processing. 339 */ 340 PREOPERATIONSEARCH("preoperationsearch"), 341 342 343 344 /** 345 * Invoked prior to parsing an abandon request. 346 */ 347 PREPARSEABANDON("preparseabandon"), 348 349 350 351 /** 352 * Invoked prior to parsing an add request. 353 */ 354 PREPARSEADD("preparseadd"), 355 356 357 358 /** 359 * Invoked prior to parsing a bind request. 360 */ 361 PREPARSEBIND("preparsebind"), 362 363 364 365 /** 366 * Invoked prior to parsing a compare request. 367 */ 368 PREPARSECOMPARE("preparsecompare"), 369 370 371 372 /** 373 * Invoked prior to parsing a delete request. 374 */ 375 PREPARSEDELETE("preparsedelete"), 376 377 378 379 /** 380 * Invoked prior to parsing an extended request. 381 */ 382 PREPARSEEXTENDED("preparseextended"), 383 384 385 386 /** 387 * Invoked prior to parsing a modify request. 388 */ 389 PREPARSEMODIFY("preparsemodify"), 390 391 392 393 /** 394 * Invoked prior to parsing a modify DN request. 395 */ 396 PREPARSEMODIFYDN("preparsemodifydn"), 397 398 399 400 /** 401 * Invoked prior to parsing a search request. 402 */ 403 PREPARSESEARCH("preparsesearch"), 404 405 406 407 /** 408 * Invoked prior to parsing an unbind request. 409 */ 410 PREPARSEUNBIND("preparseunbind"), 411 412 413 414 /** 415 * Invoked before sending a search result entry to the client. 416 */ 417 SEARCHRESULTENTRY("searchresultentry"), 418 419 420 421 /** 422 * Invoked before sending a search result reference to the client. 423 */ 424 SEARCHRESULTREFERENCE("searchresultreference"), 425 426 427 428 /** 429 * Invoked during a graceful Directory Server shutdown. 430 */ 431 SHUTDOWN("shutdown"), 432 433 434 435 /** 436 * Invoked during the Directory Server startup process. 437 */ 438 STARTUP("startup"), 439 440 441 442 /** 443 * Invoked in the course of moving or renaming an entry 444 * subordinate to the target of a modify DN operation. 445 */ 446 SUBORDINATEMODIFYDN("subordinatemodifydn"); 447 448 449 450 // String representation of the value. 451 private final String name; 452 453 454 455 // Private constructor. 456 private PluginType(String name) { this.name = name; } 457 458 459 460 /** 461 * {@inheritDoc} 462 */ 463 public String toString() { return name; } 464 465 } 466 467 468 469 // The "enabled" property definition. 470 private static final BooleanPropertyDefinition PD_ENABLED; 471 472 473 474 // The "invoke-for-internal-operations" property definition. 475 private static final BooleanPropertyDefinition PD_INVOKE_FOR_INTERNAL_OPERATIONS; 476 477 478 479 // The "java-class" property definition. 480 private static final ClassPropertyDefinition PD_JAVA_CLASS; 481 482 483 484 // The "plugin-type" property definition. 485 private static final EnumPropertyDefinition<PluginType> PD_PLUGIN_TYPE; 486 487 488 489 // Build the "enabled" property definition. 490 static { 491 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled"); 492 builder.setOption(PropertyOption.MANDATORY); 493 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled")); 494 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>()); 495 PD_ENABLED = builder.getInstance(); 496 INSTANCE.registerPropertyDefinition(PD_ENABLED); 497 } 498 499 500 501 // Build the "invoke-for-internal-operations" property definition. 502 static { 503 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "invoke-for-internal-operations"); 504 builder.setOption(PropertyOption.ADVANCED); 505 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "invoke-for-internal-operations")); 506 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 507 builder.setDefaultBehaviorProvider(provider); 508 PD_INVOKE_FOR_INTERNAL_OPERATIONS = builder.getInstance(); 509 INSTANCE.registerPropertyDefinition(PD_INVOKE_FOR_INTERNAL_OPERATIONS); 510 } 511 512 513 514 // Build the "java-class" property definition. 515 static { 516 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 517 builder.setOption(PropertyOption.MANDATORY); 518 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class")); 519 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 520 builder.addInstanceOf("org.opends.server.api.plugin.DirectoryServerPlugin"); 521 PD_JAVA_CLASS = builder.getInstance(); 522 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 523 } 524 525 526 527 // Build the "plugin-type" property definition. 528 static { 529 EnumPropertyDefinition.Builder<PluginType> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "plugin-type"); 530 builder.setOption(PropertyOption.MULTI_VALUED); 531 builder.setOption(PropertyOption.MANDATORY); 532 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "plugin-type")); 533 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<PluginType>()); 534 builder.setEnumClass(PluginType.class); 535 PD_PLUGIN_TYPE = builder.getInstance(); 536 INSTANCE.registerPropertyDefinition(PD_PLUGIN_TYPE); 537 } 538 539 540 541 // Register the tags associated with this managed object definition. 542 static { 543 INSTANCE.registerTag(Tag.valueOf("core-server")); 544 } 545 546 547 548 /** 549 * Get the Plugin configuration definition singleton. 550 * 551 * @return Returns the Plugin configuration definition singleton. 552 */ 553 public static PluginCfgDefn getInstance() { 554 return INSTANCE; 555 } 556 557 558 559 /** 560 * Private constructor. 561 */ 562 private PluginCfgDefn() { 563 super("plugin", TopCfgDefn.getInstance()); 564 } 565 566 567 568 /** 569 * {@inheritDoc} 570 */ 571 public PluginCfgClient createClientConfiguration( 572 ManagedObject<? extends PluginCfgClient> impl) { 573 return new PluginCfgClientImpl(impl); 574 } 575 576 577 578 /** 579 * {@inheritDoc} 580 */ 581 public PluginCfg createServerConfiguration( 582 ServerManagedObject<? extends PluginCfg> impl) { 583 return new PluginCfgServerImpl(impl); 584 } 585 586 587 588 /** 589 * {@inheritDoc} 590 */ 591 public Class<PluginCfg> getServerConfigurationClass() { 592 return PluginCfg.class; 593 } 594 595 596 597 /** 598 * Get the "enabled" property definition. 599 * <p> 600 * Indicates whether the plug-in is enabled for use. 601 * 602 * @return Returns the "enabled" property definition. 603 */ 604 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 605 return PD_ENABLED; 606 } 607 608 609 610 /** 611 * Get the "invoke-for-internal-operations" property definition. 612 * <p> 613 * Indicates whether the plug-in should be invoked for internal 614 * operations. 615 * <p> 616 * Any plug-in that can be invoked for internal operations must 617 * ensure that it does not create any new internal operatons that can 618 * cause the same plug-in to be re-invoked. 619 * 620 * @return Returns the "invoke-for-internal-operations" property definition. 621 */ 622 public BooleanPropertyDefinition getInvokeForInternalOperationsPropertyDefinition() { 623 return PD_INVOKE_FOR_INTERNAL_OPERATIONS; 624 } 625 626 627 628 /** 629 * Get the "java-class" property definition. 630 * <p> 631 * Specifies the fully-qualified name of the Java class that 632 * provides the plug-in implementation. 633 * 634 * @return Returns the "java-class" property definition. 635 */ 636 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 637 return PD_JAVA_CLASS; 638 } 639 640 641 642 /** 643 * Get the "plugin-type" property definition. 644 * <p> 645 * Specifies the set of plug-in types for the plug-in, which 646 * specifies the times at which the plug-in is invoked. 647 * 648 * @return Returns the "plugin-type" property definition. 649 */ 650 public EnumPropertyDefinition<PluginType> getPluginTypePropertyDefinition() { 651 return PD_PLUGIN_TYPE; 652 } 653 654 655 656 /** 657 * Managed object client implementation. 658 */ 659 private static class PluginCfgClientImpl implements 660 PluginCfgClient { 661 662 // Private implementation. 663 private ManagedObject<? extends PluginCfgClient> impl; 664 665 666 667 // Private constructor. 668 private PluginCfgClientImpl( 669 ManagedObject<? extends PluginCfgClient> impl) { 670 this.impl = impl; 671 } 672 673 674 675 /** 676 * {@inheritDoc} 677 */ 678 public Boolean isEnabled() { 679 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 680 } 681 682 683 684 /** 685 * {@inheritDoc} 686 */ 687 public void setEnabled(boolean value) { 688 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 689 } 690 691 692 693 /** 694 * {@inheritDoc} 695 */ 696 public boolean isInvokeForInternalOperations() { 697 return impl.getPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition()); 698 } 699 700 701 702 /** 703 * {@inheritDoc} 704 */ 705 public void setInvokeForInternalOperations(Boolean value) { 706 impl.setPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition(), value); 707 } 708 709 710 711 /** 712 * {@inheritDoc} 713 */ 714 public String getJavaClass() { 715 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 716 } 717 718 719 720 /** 721 * {@inheritDoc} 722 */ 723 public void setJavaClass(String value) { 724 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 725 } 726 727 728 729 /** 730 * {@inheritDoc} 731 */ 732 public SortedSet<PluginType> getPluginType() { 733 return impl.getPropertyValues(INSTANCE.getPluginTypePropertyDefinition()); 734 } 735 736 737 738 /** 739 * {@inheritDoc} 740 */ 741 public void setPluginType(Collection<PluginType> values) { 742 impl.setPropertyValues(INSTANCE.getPluginTypePropertyDefinition(), values); 743 } 744 745 746 747 /** 748 * {@inheritDoc} 749 */ 750 public ManagedObjectDefinition<? extends PluginCfgClient, ? extends PluginCfg> definition() { 751 return INSTANCE; 752 } 753 754 755 756 /** 757 * {@inheritDoc} 758 */ 759 public PropertyProvider properties() { 760 return impl; 761 } 762 763 764 765 /** 766 * {@inheritDoc} 767 */ 768 public void commit() throws ManagedObjectAlreadyExistsException, 769 MissingMandatoryPropertiesException, ConcurrentModificationException, 770 OperationRejectedException, AuthorizationException, 771 CommunicationException { 772 impl.commit(); 773 } 774 775 } 776 777 778 779 /** 780 * Managed object server implementation. 781 */ 782 private static class PluginCfgServerImpl implements 783 PluginCfg { 784 785 // Private implementation. 786 private ServerManagedObject<? extends PluginCfg> impl; 787 788 // The value of the "enabled" property. 789 private final boolean pEnabled; 790 791 // The value of the "invoke-for-internal-operations" property. 792 private final boolean pInvokeForInternalOperations; 793 794 // The value of the "java-class" property. 795 private final String pJavaClass; 796 797 // The value of the "plugin-type" property. 798 private final SortedSet<PluginType> pPluginType; 799 800 801 802 // Private constructor. 803 private PluginCfgServerImpl(ServerManagedObject<? extends PluginCfg> impl) { 804 this.impl = impl; 805 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 806 this.pInvokeForInternalOperations = impl.getPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition()); 807 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 808 this.pPluginType = impl.getPropertyValues(INSTANCE.getPluginTypePropertyDefinition()); 809 } 810 811 812 813 /** 814 * {@inheritDoc} 815 */ 816 public void addChangeListener( 817 ConfigurationChangeListener<PluginCfg> listener) { 818 impl.registerChangeListener(listener); 819 } 820 821 822 823 /** 824 * {@inheritDoc} 825 */ 826 public void removeChangeListener( 827 ConfigurationChangeListener<PluginCfg> listener) { 828 impl.deregisterChangeListener(listener); 829 } 830 831 832 833 /** 834 * {@inheritDoc} 835 */ 836 public boolean isEnabled() { 837 return pEnabled; 838 } 839 840 841 842 /** 843 * {@inheritDoc} 844 */ 845 public boolean isInvokeForInternalOperations() { 846 return pInvokeForInternalOperations; 847 } 848 849 850 851 /** 852 * {@inheritDoc} 853 */ 854 public String getJavaClass() { 855 return pJavaClass; 856 } 857 858 859 860 /** 861 * {@inheritDoc} 862 */ 863 public SortedSet<PluginType> getPluginType() { 864 return pPluginType; 865 } 866 867 868 869 /** 870 * {@inheritDoc} 871 */ 872 public Class<? extends PluginCfg> configurationClass() { 873 return PluginCfg.class; 874 } 875 876 877 878 /** 879 * {@inheritDoc} 880 */ 881 public DN dn() { 882 return impl.getDN(); 883 } 884 885 } 886 }