001/* 002 * The contents of this file are subject to the terms of the Common Development and 003 * Distribution License (the License). You may not use this file except in compliance with the 004 * License. 005 * 006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the 007 * specific language governing permission and limitations under the License. 008 * 009 * When distributing Covered Software, include this CDDL Header Notice in each file and include 010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL 011 * Header, with the fields enclosed by brackets [] replaced by your own identifying 012 * information: "Portions Copyright [year] [name of copyright owner]". 013 * 014 * Copyright 2008 Sun Microsystems, Inc. 015 */ 016package org.forgerock.opendj.server.config.server; 017 018 019 020import org.forgerock.opendj.config.Configuration; 021import org.forgerock.opendj.config.server.ConfigException; 022import org.forgerock.opendj.config.server.ConfigurationAddListener; 023import org.forgerock.opendj.config.server.ConfigurationDeleteListener; 024 025 026 027/** 028 * A server-side interface for querying Root settings. 029 * <p> 030 * The root configuration provides an entry point to the rest of the 031 * OpenDJ configuration. 032 */ 033public interface RootCfg extends Configuration { 034 035 /** 036 * Gets the configuration class associated with this Root. 037 * 038 * @return Returns the configuration class associated with this Root. 039 */ 040 Class<? extends RootCfg> configurationClass(); 041 042 043 044 /** 045 * Gets the Access Control Handler. 046 * 047 * @return Returns the Access Control Handler. 048 * @throws ConfigException 049 * If the Access Control Handler could not be found or it could not 050 * be successfully decoded. 051 */ 052 AccessControlHandlerCfg getAccessControlHandler() throws ConfigException; 053 054 055 056 /** 057 * Lists the Account Status Notification Handlers. 058 * 059 * @return Returns an array containing the names of the 060 * Account Status Notification Handlers. 061 */ 062 String[] listAccountStatusNotificationHandlers(); 063 064 065 066 /** 067 * Gets the named Account Status Notification Handler. 068 * 069 * @param name 070 * The name of the Account Status Notification Handler to retrieve. 071 * @return Returns the named Account Status Notification Handler. 072 * @throws ConfigException 073 * If the Account Status Notification Handler could not be found or it 074 * could not be successfully decoded. 075 */ 076 AccountStatusNotificationHandlerCfg getAccountStatusNotificationHandler(String name) throws ConfigException; 077 078 079 080 /** 081 * Registers to be notified when new Account Status Notification Handlers are added. 082 * 083 * @param listener 084 * The Account Status Notification Handler configuration add listener. 085 * @throws ConfigException 086 * If the add listener could not be registered. 087 */ 088 void addAccountStatusNotificationHandlerAddListener(ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException; 089 090 091 092 /** 093 * Deregisters an existing Account Status Notification Handler configuration add listener. 094 * 095 * @param listener 096 * The Account Status Notification Handler configuration add listener. 097 */ 098 void removeAccountStatusNotificationHandlerAddListener(ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener); 099 100 101 102 /** 103 * Registers to be notified when existing Account Status Notification Handlers are deleted. 104 * 105 * @param listener 106 * The Account Status Notification Handler configuration delete listener. 107 * @throws ConfigException 108 * If the delete listener could not be registered. 109 */ 110 void addAccountStatusNotificationHandlerDeleteListener(ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException; 111 112 113 114 /** 115 * Deregisters an existing Account Status Notification Handler configuration delete listener. 116 * 117 * @param listener 118 * The Account Status Notification Handler configuration delete listener. 119 */ 120 void removeAccountStatusNotificationHandlerDeleteListener(ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener); 121 122 123 124 /** 125 * Gets the Administration Connector. 126 * 127 * @return Returns the Administration Connector. 128 * @throws ConfigException 129 * If the Administration Connector could not be found or it could not 130 * be successfully decoded. 131 */ 132 AdministrationConnectorCfg getAdministrationConnector() throws ConfigException; 133 134 135 136 /** 137 * Lists the Alert Handlers. 138 * 139 * @return Returns an array containing the names of the 140 * Alert Handlers. 141 */ 142 String[] listAlertHandlers(); 143 144 145 146 /** 147 * Gets the named Alert Handler. 148 * 149 * @param name 150 * The name of the Alert Handler to retrieve. 151 * @return Returns the named Alert Handler. 152 * @throws ConfigException 153 * If the Alert Handler could not be found or it 154 * could not be successfully decoded. 155 */ 156 AlertHandlerCfg getAlertHandler(String name) throws ConfigException; 157 158 159 160 /** 161 * Registers to be notified when new Alert Handlers are added. 162 * 163 * @param listener 164 * The Alert Handler configuration add listener. 165 * @throws ConfigException 166 * If the add listener could not be registered. 167 */ 168 void addAlertHandlerAddListener(ConfigurationAddListener<AlertHandlerCfg> listener) throws ConfigException; 169 170 171 172 /** 173 * Deregisters an existing Alert Handler configuration add listener. 174 * 175 * @param listener 176 * The Alert Handler configuration add listener. 177 */ 178 void removeAlertHandlerAddListener(ConfigurationAddListener<AlertHandlerCfg> listener); 179 180 181 182 /** 183 * Registers to be notified when existing Alert Handlers are deleted. 184 * 185 * @param listener 186 * The Alert Handler configuration delete listener. 187 * @throws ConfigException 188 * If the delete listener could not be registered. 189 */ 190 void addAlertHandlerDeleteListener(ConfigurationDeleteListener<AlertHandlerCfg> listener) throws ConfigException; 191 192 193 194 /** 195 * Deregisters an existing Alert Handler configuration delete listener. 196 * 197 * @param listener 198 * The Alert Handler configuration delete listener. 199 */ 200 void removeAlertHandlerDeleteListener(ConfigurationDeleteListener<AlertHandlerCfg> listener); 201 202 203 204 /** 205 * Lists the Attribute Syntaxes. 206 * 207 * @return Returns an array containing the names of the 208 * Attribute Syntaxes. 209 */ 210 String[] listAttributeSyntaxes(); 211 212 213 214 /** 215 * Gets the named Attribute Syntax. 216 * 217 * @param name 218 * The name of the Attribute Syntax to retrieve. 219 * @return Returns the named Attribute Syntax. 220 * @throws ConfigException 221 * If the Attribute Syntax could not be found or it 222 * could not be successfully decoded. 223 */ 224 AttributeSyntaxCfg getAttributeSyntax(String name) throws ConfigException; 225 226 227 228 /** 229 * Registers to be notified when new Attribute Syntaxes are added. 230 * 231 * @param listener 232 * The Attribute Syntax configuration add listener. 233 * @throws ConfigException 234 * If the add listener could not be registered. 235 */ 236 void addAttributeSyntaxAddListener(ConfigurationAddListener<AttributeSyntaxCfg> listener) throws ConfigException; 237 238 239 240 /** 241 * Deregisters an existing Attribute Syntax configuration add listener. 242 * 243 * @param listener 244 * The Attribute Syntax configuration add listener. 245 */ 246 void removeAttributeSyntaxAddListener(ConfigurationAddListener<AttributeSyntaxCfg> listener); 247 248 249 250 /** 251 * Registers to be notified when existing Attribute Syntaxes are deleted. 252 * 253 * @param listener 254 * The Attribute Syntax configuration delete listener. 255 * @throws ConfigException 256 * If the delete listener could not be registered. 257 */ 258 void addAttributeSyntaxDeleteListener(ConfigurationDeleteListener<AttributeSyntaxCfg> listener) throws ConfigException; 259 260 261 262 /** 263 * Deregisters an existing Attribute Syntax configuration delete listener. 264 * 265 * @param listener 266 * The Attribute Syntax configuration delete listener. 267 */ 268 void removeAttributeSyntaxDeleteListener(ConfigurationDeleteListener<AttributeSyntaxCfg> listener); 269 270 271 272 /** 273 * Lists the Backends. 274 * 275 * @return Returns an array containing the names of the 276 * Backends. 277 */ 278 String[] listBackends(); 279 280 281 282 /** 283 * Gets the named Backend. 284 * 285 * @param name 286 * The name of the Backend to retrieve. 287 * @return Returns the named Backend. 288 * @throws ConfigException 289 * If the Backend could not be found or it 290 * could not be successfully decoded. 291 */ 292 BackendCfg getBackend(String name) throws ConfigException; 293 294 295 296 /** 297 * Registers to be notified when new Backends are added. 298 * 299 * @param listener 300 * The Backend configuration add listener. 301 * @throws ConfigException 302 * If the add listener could not be registered. 303 */ 304 void addBackendAddListener(ConfigurationAddListener<BackendCfg> listener) throws ConfigException; 305 306 307 308 /** 309 * Deregisters an existing Backend configuration add listener. 310 * 311 * @param listener 312 * The Backend configuration add listener. 313 */ 314 void removeBackendAddListener(ConfigurationAddListener<BackendCfg> listener); 315 316 317 318 /** 319 * Registers to be notified when existing Backends are deleted. 320 * 321 * @param listener 322 * The Backend configuration delete listener. 323 * @throws ConfigException 324 * If the delete listener could not be registered. 325 */ 326 void addBackendDeleteListener(ConfigurationDeleteListener<BackendCfg> listener) throws ConfigException; 327 328 329 330 /** 331 * Deregisters an existing Backend configuration delete listener. 332 * 333 * @param listener 334 * The Backend configuration delete listener. 335 */ 336 void removeBackendDeleteListener(ConfigurationDeleteListener<BackendCfg> listener); 337 338 339 340 /** 341 * Lists the Certificate Mappers. 342 * 343 * @return Returns an array containing the names of the 344 * Certificate Mappers. 345 */ 346 String[] listCertificateMappers(); 347 348 349 350 /** 351 * Gets the named Certificate Mapper. 352 * 353 * @param name 354 * The name of the Certificate Mapper to retrieve. 355 * @return Returns the named Certificate Mapper. 356 * @throws ConfigException 357 * If the Certificate Mapper could not be found or it 358 * could not be successfully decoded. 359 */ 360 CertificateMapperCfg getCertificateMapper(String name) throws ConfigException; 361 362 363 364 /** 365 * Registers to be notified when new Certificate Mappers are added. 366 * 367 * @param listener 368 * The Certificate Mapper configuration add listener. 369 * @throws ConfigException 370 * If the add listener could not be registered. 371 */ 372 void addCertificateMapperAddListener(ConfigurationAddListener<CertificateMapperCfg> listener) throws ConfigException; 373 374 375 376 /** 377 * Deregisters an existing Certificate Mapper configuration add listener. 378 * 379 * @param listener 380 * The Certificate Mapper configuration add listener. 381 */ 382 void removeCertificateMapperAddListener(ConfigurationAddListener<CertificateMapperCfg> listener); 383 384 385 386 /** 387 * Registers to be notified when existing Certificate Mappers are deleted. 388 * 389 * @param listener 390 * The Certificate Mapper configuration delete listener. 391 * @throws ConfigException 392 * If the delete listener could not be registered. 393 */ 394 void addCertificateMapperDeleteListener(ConfigurationDeleteListener<CertificateMapperCfg> listener) throws ConfigException; 395 396 397 398 /** 399 * Deregisters an existing Certificate Mapper configuration delete listener. 400 * 401 * @param listener 402 * The Certificate Mapper configuration delete listener. 403 */ 404 void removeCertificateMapperDeleteListener(ConfigurationDeleteListener<CertificateMapperCfg> listener); 405 406 407 408 /** 409 * Lists the Connection Handlers. 410 * 411 * @return Returns an array containing the names of the 412 * Connection Handlers. 413 */ 414 String[] listConnectionHandlers(); 415 416 417 418 /** 419 * Gets the named Connection Handler. 420 * 421 * @param name 422 * The name of the Connection Handler to retrieve. 423 * @return Returns the named Connection Handler. 424 * @throws ConfigException 425 * If the Connection Handler could not be found or it 426 * could not be successfully decoded. 427 */ 428 ConnectionHandlerCfg getConnectionHandler(String name) throws ConfigException; 429 430 431 432 /** 433 * Registers to be notified when new Connection Handlers are added. 434 * 435 * @param listener 436 * The Connection Handler configuration add listener. 437 * @throws ConfigException 438 * If the add listener could not be registered. 439 */ 440 void addConnectionHandlerAddListener(ConfigurationAddListener<ConnectionHandlerCfg> listener) throws ConfigException; 441 442 443 444 /** 445 * Deregisters an existing Connection Handler configuration add listener. 446 * 447 * @param listener 448 * The Connection Handler configuration add listener. 449 */ 450 void removeConnectionHandlerAddListener(ConfigurationAddListener<ConnectionHandlerCfg> listener); 451 452 453 454 /** 455 * Registers to be notified when existing Connection Handlers are deleted. 456 * 457 * @param listener 458 * The Connection Handler configuration delete listener. 459 * @throws ConfigException 460 * If the delete listener could not be registered. 461 */ 462 void addConnectionHandlerDeleteListener(ConfigurationDeleteListener<ConnectionHandlerCfg> listener) throws ConfigException; 463 464 465 466 /** 467 * Deregisters an existing Connection Handler configuration delete listener. 468 * 469 * @param listener 470 * The Connection Handler configuration delete listener. 471 */ 472 void removeConnectionHandlerDeleteListener(ConfigurationDeleteListener<ConnectionHandlerCfg> listener); 473 474 475 476 /** 477 * Gets the Crypto Manager. 478 * 479 * @return Returns the Crypto Manager. 480 * @throws ConfigException 481 * If the Crypto Manager could not be found or it could not 482 * be successfully decoded. 483 */ 484 CryptoManagerCfg getCryptoManager() throws ConfigException; 485 486 487 488 /** 489 * Lists the Entry Caches. 490 * 491 * @return Returns an array containing the names of the 492 * Entry Caches. 493 */ 494 String[] listEntryCaches(); 495 496 497 498 /** 499 * Gets the named Entry Cache. 500 * 501 * @param name 502 * The name of the Entry Cache to retrieve. 503 * @return Returns the named Entry Cache. 504 * @throws ConfigException 505 * If the Entry Cache could not be found or it 506 * could not be successfully decoded. 507 */ 508 EntryCacheCfg getEntryCache(String name) throws ConfigException; 509 510 511 512 /** 513 * Registers to be notified when new Entry Caches are added. 514 * 515 * @param listener 516 * The Entry Cache configuration add listener. 517 * @throws ConfigException 518 * If the add listener could not be registered. 519 */ 520 void addEntryCacheAddListener(ConfigurationAddListener<EntryCacheCfg> listener) throws ConfigException; 521 522 523 524 /** 525 * Deregisters an existing Entry Cache configuration add listener. 526 * 527 * @param listener 528 * The Entry Cache configuration add listener. 529 */ 530 void removeEntryCacheAddListener(ConfigurationAddListener<EntryCacheCfg> listener); 531 532 533 534 /** 535 * Registers to be notified when existing Entry Caches are deleted. 536 * 537 * @param listener 538 * The Entry Cache configuration delete listener. 539 * @throws ConfigException 540 * If the delete listener could not be registered. 541 */ 542 void addEntryCacheDeleteListener(ConfigurationDeleteListener<EntryCacheCfg> listener) throws ConfigException; 543 544 545 546 /** 547 * Deregisters an existing Entry Cache configuration delete listener. 548 * 549 * @param listener 550 * The Entry Cache configuration delete listener. 551 */ 552 void removeEntryCacheDeleteListener(ConfigurationDeleteListener<EntryCacheCfg> listener); 553 554 555 556 /** 557 * Lists the Extended Operation Handlers. 558 * 559 * @return Returns an array containing the names of the 560 * Extended Operation Handlers. 561 */ 562 String[] listExtendedOperationHandlers(); 563 564 565 566 /** 567 * Gets the named Extended Operation Handler. 568 * 569 * @param name 570 * The name of the Extended Operation Handler to retrieve. 571 * @return Returns the named Extended Operation Handler. 572 * @throws ConfigException 573 * If the Extended Operation Handler could not be found or it 574 * could not be successfully decoded. 575 */ 576 ExtendedOperationHandlerCfg getExtendedOperationHandler(String name) throws ConfigException; 577 578 579 580 /** 581 * Registers to be notified when new Extended Operation Handlers are added. 582 * 583 * @param listener 584 * The Extended Operation Handler configuration add listener. 585 * @throws ConfigException 586 * If the add listener could not be registered. 587 */ 588 void addExtendedOperationHandlerAddListener(ConfigurationAddListener<ExtendedOperationHandlerCfg> listener) throws ConfigException; 589 590 591 592 /** 593 * Deregisters an existing Extended Operation Handler configuration add listener. 594 * 595 * @param listener 596 * The Extended Operation Handler configuration add listener. 597 */ 598 void removeExtendedOperationHandlerAddListener(ConfigurationAddListener<ExtendedOperationHandlerCfg> listener); 599 600 601 602 /** 603 * Registers to be notified when existing Extended Operation Handlers are deleted. 604 * 605 * @param listener 606 * The Extended Operation Handler configuration delete listener. 607 * @throws ConfigException 608 * If the delete listener could not be registered. 609 */ 610 void addExtendedOperationHandlerDeleteListener(ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener) throws ConfigException; 611 612 613 614 /** 615 * Deregisters an existing Extended Operation Handler configuration delete listener. 616 * 617 * @param listener 618 * The Extended Operation Handler configuration delete listener. 619 */ 620 void removeExtendedOperationHandlerDeleteListener(ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener); 621 622 623 624 /** 625 * Gets the Global Configuration. 626 * 627 * @return Returns the Global Configuration. 628 * @throws ConfigException 629 * If the Global Configuration could not be found or it could not 630 * be successfully decoded. 631 */ 632 GlobalCfg getGlobalConfiguration() throws ConfigException; 633 634 635 636 /** 637 * Lists the Group Implementations. 638 * 639 * @return Returns an array containing the names of the 640 * Group Implementations. 641 */ 642 String[] listGroupImplementations(); 643 644 645 646 /** 647 * Gets the named Group Implementation. 648 * 649 * @param name 650 * The name of the Group Implementation to retrieve. 651 * @return Returns the named Group Implementation. 652 * @throws ConfigException 653 * If the Group Implementation could not be found or it 654 * could not be successfully decoded. 655 */ 656 GroupImplementationCfg getGroupImplementation(String name) throws ConfigException; 657 658 659 660 /** 661 * Registers to be notified when new Group Implementations are added. 662 * 663 * @param listener 664 * The Group Implementation configuration add listener. 665 * @throws ConfigException 666 * If the add listener could not be registered. 667 */ 668 void addGroupImplementationAddListener(ConfigurationAddListener<GroupImplementationCfg> listener) throws ConfigException; 669 670 671 672 /** 673 * Deregisters an existing Group Implementation configuration add listener. 674 * 675 * @param listener 676 * The Group Implementation configuration add listener. 677 */ 678 void removeGroupImplementationAddListener(ConfigurationAddListener<GroupImplementationCfg> listener); 679 680 681 682 /** 683 * Registers to be notified when existing Group Implementations are deleted. 684 * 685 * @param listener 686 * The Group Implementation configuration delete listener. 687 * @throws ConfigException 688 * If the delete listener could not be registered. 689 */ 690 void addGroupImplementationDeleteListener(ConfigurationDeleteListener<GroupImplementationCfg> listener) throws ConfigException; 691 692 693 694 /** 695 * Deregisters an existing Group Implementation configuration delete listener. 696 * 697 * @param listener 698 * The Group Implementation configuration delete listener. 699 */ 700 void removeGroupImplementationDeleteListener(ConfigurationDeleteListener<GroupImplementationCfg> listener); 701 702 703 704 /** 705 * Lists the HTTP Authorization Mechanisms. 706 * 707 * @return Returns an array containing the names of the 708 * HTTP Authorization Mechanisms. 709 */ 710 String[] listHTTPAuthorizationMechanisms(); 711 712 713 714 /** 715 * Gets the named HTTP Authorization Mechanism. 716 * 717 * @param name 718 * The name of the HTTP Authorization Mechanism to retrieve. 719 * @return Returns the named HTTP Authorization Mechanism. 720 * @throws ConfigException 721 * If the HTTP Authorization Mechanism could not be found or it 722 * could not be successfully decoded. 723 */ 724 HTTPAuthorizationMechanismCfg getHTTPAuthorizationMechanism(String name) throws ConfigException; 725 726 727 728 /** 729 * Registers to be notified when new HTTP Authorization Mechanisms are added. 730 * 731 * @param listener 732 * The HTTP Authorization Mechanism configuration add listener. 733 * @throws ConfigException 734 * If the add listener could not be registered. 735 */ 736 void addHTTPAuthorizationMechanismAddListener(ConfigurationAddListener<HTTPAuthorizationMechanismCfg> listener) throws ConfigException; 737 738 739 740 /** 741 * Deregisters an existing HTTP Authorization Mechanism configuration add listener. 742 * 743 * @param listener 744 * The HTTP Authorization Mechanism configuration add listener. 745 */ 746 void removeHTTPAuthorizationMechanismAddListener(ConfigurationAddListener<HTTPAuthorizationMechanismCfg> listener); 747 748 749 750 /** 751 * Registers to be notified when existing HTTP Authorization Mechanisms are deleted. 752 * 753 * @param listener 754 * The HTTP Authorization Mechanism configuration delete listener. 755 * @throws ConfigException 756 * If the delete listener could not be registered. 757 */ 758 void addHTTPAuthorizationMechanismDeleteListener(ConfigurationDeleteListener<HTTPAuthorizationMechanismCfg> listener) throws ConfigException; 759 760 761 762 /** 763 * Deregisters an existing HTTP Authorization Mechanism configuration delete listener. 764 * 765 * @param listener 766 * The HTTP Authorization Mechanism configuration delete listener. 767 */ 768 void removeHTTPAuthorizationMechanismDeleteListener(ConfigurationDeleteListener<HTTPAuthorizationMechanismCfg> listener); 769 770 771 772 /** 773 * Lists the HTTP Endpoints. 774 * 775 * @return Returns an array containing the names of the 776 * HTTP Endpoints. 777 */ 778 String[] listHTTPEndpoints(); 779 780 781 782 /** 783 * Gets the named HTTP Endpoint. 784 * 785 * @param name 786 * The name of the HTTP Endpoint to retrieve. 787 * @return Returns the named HTTP Endpoint. 788 * @throws ConfigException 789 * If the HTTP Endpoint could not be found or it 790 * could not be successfully decoded. 791 */ 792 HTTPEndpointCfg getHTTPEndpoint(String name) throws ConfigException; 793 794 795 796 /** 797 * Registers to be notified when new HTTP Endpoints are added. 798 * 799 * @param listener 800 * The HTTP Endpoint configuration add listener. 801 * @throws ConfigException 802 * If the add listener could not be registered. 803 */ 804 void addHTTPEndpointAddListener(ConfigurationAddListener<HTTPEndpointCfg> listener) throws ConfigException; 805 806 807 808 /** 809 * Deregisters an existing HTTP Endpoint configuration add listener. 810 * 811 * @param listener 812 * The HTTP Endpoint configuration add listener. 813 */ 814 void removeHTTPEndpointAddListener(ConfigurationAddListener<HTTPEndpointCfg> listener); 815 816 817 818 /** 819 * Registers to be notified when existing HTTP Endpoints are deleted. 820 * 821 * @param listener 822 * The HTTP Endpoint configuration delete listener. 823 * @throws ConfigException 824 * If the delete listener could not be registered. 825 */ 826 void addHTTPEndpointDeleteListener(ConfigurationDeleteListener<HTTPEndpointCfg> listener) throws ConfigException; 827 828 829 830 /** 831 * Deregisters an existing HTTP Endpoint configuration delete listener. 832 * 833 * @param listener 834 * The HTTP Endpoint configuration delete listener. 835 */ 836 void removeHTTPEndpointDeleteListener(ConfigurationDeleteListener<HTTPEndpointCfg> listener); 837 838 839 840 /** 841 * Lists the Identity Mappers. 842 * 843 * @return Returns an array containing the names of the 844 * Identity Mappers. 845 */ 846 String[] listIdentityMappers(); 847 848 849 850 /** 851 * Gets the named Identity Mapper. 852 * 853 * @param name 854 * The name of the Identity Mapper to retrieve. 855 * @return Returns the named Identity Mapper. 856 * @throws ConfigException 857 * If the Identity Mapper could not be found or it 858 * could not be successfully decoded. 859 */ 860 IdentityMapperCfg getIdentityMapper(String name) throws ConfigException; 861 862 863 864 /** 865 * Registers to be notified when new Identity Mappers are added. 866 * 867 * @param listener 868 * The Identity Mapper configuration add listener. 869 * @throws ConfigException 870 * If the add listener could not be registered. 871 */ 872 void addIdentityMapperAddListener(ConfigurationAddListener<IdentityMapperCfg> listener) throws ConfigException; 873 874 875 876 /** 877 * Deregisters an existing Identity Mapper configuration add listener. 878 * 879 * @param listener 880 * The Identity Mapper configuration add listener. 881 */ 882 void removeIdentityMapperAddListener(ConfigurationAddListener<IdentityMapperCfg> listener); 883 884 885 886 /** 887 * Registers to be notified when existing Identity Mappers are deleted. 888 * 889 * @param listener 890 * The Identity Mapper configuration delete listener. 891 * @throws ConfigException 892 * If the delete listener could not be registered. 893 */ 894 void addIdentityMapperDeleteListener(ConfigurationDeleteListener<IdentityMapperCfg> listener) throws ConfigException; 895 896 897 898 /** 899 * Deregisters an existing Identity Mapper configuration delete listener. 900 * 901 * @param listener 902 * The Identity Mapper configuration delete listener. 903 */ 904 void removeIdentityMapperDeleteListener(ConfigurationDeleteListener<IdentityMapperCfg> listener); 905 906 907 908 /** 909 * Lists the Key Manager Providers. 910 * 911 * @return Returns an array containing the names of the 912 * Key Manager Providers. 913 */ 914 String[] listKeyManagerProviders(); 915 916 917 918 /** 919 * Gets the named Key Manager Provider. 920 * 921 * @param name 922 * The name of the Key Manager Provider to retrieve. 923 * @return Returns the named Key Manager Provider. 924 * @throws ConfigException 925 * If the Key Manager Provider could not be found or it 926 * could not be successfully decoded. 927 */ 928 KeyManagerProviderCfg getKeyManagerProvider(String name) throws ConfigException; 929 930 931 932 /** 933 * Registers to be notified when new Key Manager Providers are added. 934 * 935 * @param listener 936 * The Key Manager Provider configuration add listener. 937 * @throws ConfigException 938 * If the add listener could not be registered. 939 */ 940 void addKeyManagerProviderAddListener(ConfigurationAddListener<KeyManagerProviderCfg> listener) throws ConfigException; 941 942 943 944 /** 945 * Deregisters an existing Key Manager Provider configuration add listener. 946 * 947 * @param listener 948 * The Key Manager Provider configuration add listener. 949 */ 950 void removeKeyManagerProviderAddListener(ConfigurationAddListener<KeyManagerProviderCfg> listener); 951 952 953 954 /** 955 * Registers to be notified when existing Key Manager Providers are deleted. 956 * 957 * @param listener 958 * The Key Manager Provider configuration delete listener. 959 * @throws ConfigException 960 * If the delete listener could not be registered. 961 */ 962 void addKeyManagerProviderDeleteListener(ConfigurationDeleteListener<KeyManagerProviderCfg> listener) throws ConfigException; 963 964 965 966 /** 967 * Deregisters an existing Key Manager Provider configuration delete listener. 968 * 969 * @param listener 970 * The Key Manager Provider configuration delete listener. 971 */ 972 void removeKeyManagerProviderDeleteListener(ConfigurationDeleteListener<KeyManagerProviderCfg> listener); 973 974 975 976 /** 977 * Lists the Log Publishers. 978 * 979 * @return Returns an array containing the names of the 980 * Log Publishers. 981 */ 982 String[] listLogPublishers(); 983 984 985 986 /** 987 * Gets the named Log Publisher. 988 * 989 * @param name 990 * The name of the Log Publisher to retrieve. 991 * @return Returns the named Log Publisher. 992 * @throws ConfigException 993 * If the Log Publisher could not be found or it 994 * could not be successfully decoded. 995 */ 996 LogPublisherCfg getLogPublisher(String name) throws ConfigException; 997 998 999 1000 /** 1001 * Registers to be notified when new Log Publishers are added. 1002 * 1003 * @param listener 1004 * The Log Publisher configuration add listener. 1005 * @throws ConfigException 1006 * If the add listener could not be registered. 1007 */ 1008 void addLogPublisherAddListener(ConfigurationAddListener<LogPublisherCfg> listener) throws ConfigException; 1009 1010 1011 1012 /** 1013 * Deregisters an existing Log Publisher configuration add listener. 1014 * 1015 * @param listener 1016 * The Log Publisher configuration add listener. 1017 */ 1018 void removeLogPublisherAddListener(ConfigurationAddListener<LogPublisherCfg> listener); 1019 1020 1021 1022 /** 1023 * Registers to be notified when existing Log Publishers are deleted. 1024 * 1025 * @param listener 1026 * The Log Publisher configuration delete listener. 1027 * @throws ConfigException 1028 * If the delete listener could not be registered. 1029 */ 1030 void addLogPublisherDeleteListener(ConfigurationDeleteListener<LogPublisherCfg> listener) throws ConfigException; 1031 1032 1033 1034 /** 1035 * Deregisters an existing Log Publisher configuration delete listener. 1036 * 1037 * @param listener 1038 * The Log Publisher configuration delete listener. 1039 */ 1040 void removeLogPublisherDeleteListener(ConfigurationDeleteListener<LogPublisherCfg> listener); 1041 1042 1043 1044 /** 1045 * Lists the Log Retention Policies. 1046 * 1047 * @return Returns an array containing the names of the 1048 * Log Retention Policies. 1049 */ 1050 String[] listLogRetentionPolicies(); 1051 1052 1053 1054 /** 1055 * Gets the named Log Retention Policy. 1056 * 1057 * @param name 1058 * The name of the Log Retention Policy to retrieve. 1059 * @return Returns the named Log Retention Policy. 1060 * @throws ConfigException 1061 * If the Log Retention Policy could not be found or it 1062 * could not be successfully decoded. 1063 */ 1064 LogRetentionPolicyCfg getLogRetentionPolicy(String name) throws ConfigException; 1065 1066 1067 1068 /** 1069 * Registers to be notified when new Log Retention Policies are added. 1070 * 1071 * @param listener 1072 * The Log Retention Policy configuration add listener. 1073 * @throws ConfigException 1074 * If the add listener could not be registered. 1075 */ 1076 void addLogRetentionPolicyAddListener(ConfigurationAddListener<LogRetentionPolicyCfg> listener) throws ConfigException; 1077 1078 1079 1080 /** 1081 * Deregisters an existing Log Retention Policy configuration add listener. 1082 * 1083 * @param listener 1084 * The Log Retention Policy configuration add listener. 1085 */ 1086 void removeLogRetentionPolicyAddListener(ConfigurationAddListener<LogRetentionPolicyCfg> listener); 1087 1088 1089 1090 /** 1091 * Registers to be notified when existing Log Retention Policies are deleted. 1092 * 1093 * @param listener 1094 * The Log Retention Policy configuration delete listener. 1095 * @throws ConfigException 1096 * If the delete listener could not be registered. 1097 */ 1098 void addLogRetentionPolicyDeleteListener(ConfigurationDeleteListener<LogRetentionPolicyCfg> listener) throws ConfigException; 1099 1100 1101 1102 /** 1103 * Deregisters an existing Log Retention Policy configuration delete listener. 1104 * 1105 * @param listener 1106 * The Log Retention Policy configuration delete listener. 1107 */ 1108 void removeLogRetentionPolicyDeleteListener(ConfigurationDeleteListener<LogRetentionPolicyCfg> listener); 1109 1110 1111 1112 /** 1113 * Lists the Log Rotation Policies. 1114 * 1115 * @return Returns an array containing the names of the 1116 * Log Rotation Policies. 1117 */ 1118 String[] listLogRotationPolicies(); 1119 1120 1121 1122 /** 1123 * Gets the named Log Rotation Policy. 1124 * 1125 * @param name 1126 * The name of the Log Rotation Policy to retrieve. 1127 * @return Returns the named Log Rotation Policy. 1128 * @throws ConfigException 1129 * If the Log Rotation Policy could not be found or it 1130 * could not be successfully decoded. 1131 */ 1132 LogRotationPolicyCfg getLogRotationPolicy(String name) throws ConfigException; 1133 1134 1135 1136 /** 1137 * Registers to be notified when new Log Rotation Policies are added. 1138 * 1139 * @param listener 1140 * The Log Rotation Policy configuration add listener. 1141 * @throws ConfigException 1142 * If the add listener could not be registered. 1143 */ 1144 void addLogRotationPolicyAddListener(ConfigurationAddListener<LogRotationPolicyCfg> listener) throws ConfigException; 1145 1146 1147 1148 /** 1149 * Deregisters an existing Log Rotation Policy configuration add listener. 1150 * 1151 * @param listener 1152 * The Log Rotation Policy configuration add listener. 1153 */ 1154 void removeLogRotationPolicyAddListener(ConfigurationAddListener<LogRotationPolicyCfg> listener); 1155 1156 1157 1158 /** 1159 * Registers to be notified when existing Log Rotation Policies are deleted. 1160 * 1161 * @param listener 1162 * The Log Rotation Policy configuration delete listener. 1163 * @throws ConfigException 1164 * If the delete listener could not be registered. 1165 */ 1166 void addLogRotationPolicyDeleteListener(ConfigurationDeleteListener<LogRotationPolicyCfg> listener) throws ConfigException; 1167 1168 1169 1170 /** 1171 * Deregisters an existing Log Rotation Policy configuration delete listener. 1172 * 1173 * @param listener 1174 * The Log Rotation Policy configuration delete listener. 1175 */ 1176 void removeLogRotationPolicyDeleteListener(ConfigurationDeleteListener<LogRotationPolicyCfg> listener); 1177 1178 1179 1180 /** 1181 * Lists the Matching Rules. 1182 * 1183 * @return Returns an array containing the names of the 1184 * Matching Rules. 1185 */ 1186 String[] listMatchingRules(); 1187 1188 1189 1190 /** 1191 * Gets the named Matching Rule. 1192 * 1193 * @param name 1194 * The name of the Matching Rule to retrieve. 1195 * @return Returns the named Matching Rule. 1196 * @throws ConfigException 1197 * If the Matching Rule could not be found or it 1198 * could not be successfully decoded. 1199 */ 1200 MatchingRuleCfg getMatchingRule(String name) throws ConfigException; 1201 1202 1203 1204 /** 1205 * Registers to be notified when new Matching Rules are added. 1206 * 1207 * @param listener 1208 * The Matching Rule configuration add listener. 1209 * @throws ConfigException 1210 * If the add listener could not be registered. 1211 */ 1212 void addMatchingRuleAddListener(ConfigurationAddListener<MatchingRuleCfg> listener) throws ConfigException; 1213 1214 1215 1216 /** 1217 * Deregisters an existing Matching Rule configuration add listener. 1218 * 1219 * @param listener 1220 * The Matching Rule configuration add listener. 1221 */ 1222 void removeMatchingRuleAddListener(ConfigurationAddListener<MatchingRuleCfg> listener); 1223 1224 1225 1226 /** 1227 * Registers to be notified when existing Matching Rules are deleted. 1228 * 1229 * @param listener 1230 * The Matching Rule configuration delete listener. 1231 * @throws ConfigException 1232 * If the delete listener could not be registered. 1233 */ 1234 void addMatchingRuleDeleteListener(ConfigurationDeleteListener<MatchingRuleCfg> listener) throws ConfigException; 1235 1236 1237 1238 /** 1239 * Deregisters an existing Matching Rule configuration delete listener. 1240 * 1241 * @param listener 1242 * The Matching Rule configuration delete listener. 1243 */ 1244 void removeMatchingRuleDeleteListener(ConfigurationDeleteListener<MatchingRuleCfg> listener); 1245 1246 1247 1248 /** 1249 * Lists the Monitor Providers. 1250 * 1251 * @return Returns an array containing the names of the 1252 * Monitor Providers. 1253 */ 1254 String[] listMonitorProviders(); 1255 1256 1257 1258 /** 1259 * Gets the named Monitor Provider. 1260 * 1261 * @param name 1262 * The name of the Monitor Provider to retrieve. 1263 * @return Returns the named Monitor Provider. 1264 * @throws ConfigException 1265 * If the Monitor Provider could not be found or it 1266 * could not be successfully decoded. 1267 */ 1268 MonitorProviderCfg getMonitorProvider(String name) throws ConfigException; 1269 1270 1271 1272 /** 1273 * Registers to be notified when new Monitor Providers are added. 1274 * 1275 * @param listener 1276 * The Monitor Provider configuration add listener. 1277 * @throws ConfigException 1278 * If the add listener could not be registered. 1279 */ 1280 void addMonitorProviderAddListener(ConfigurationAddListener<MonitorProviderCfg> listener) throws ConfigException; 1281 1282 1283 1284 /** 1285 * Deregisters an existing Monitor Provider configuration add listener. 1286 * 1287 * @param listener 1288 * The Monitor Provider configuration add listener. 1289 */ 1290 void removeMonitorProviderAddListener(ConfigurationAddListener<MonitorProviderCfg> listener); 1291 1292 1293 1294 /** 1295 * Registers to be notified when existing Monitor Providers are deleted. 1296 * 1297 * @param listener 1298 * The Monitor Provider configuration delete listener. 1299 * @throws ConfigException 1300 * If the delete listener could not be registered. 1301 */ 1302 void addMonitorProviderDeleteListener(ConfigurationDeleteListener<MonitorProviderCfg> listener) throws ConfigException; 1303 1304 1305 1306 /** 1307 * Deregisters an existing Monitor Provider configuration delete listener. 1308 * 1309 * @param listener 1310 * The Monitor Provider configuration delete listener. 1311 */ 1312 void removeMonitorProviderDeleteListener(ConfigurationDeleteListener<MonitorProviderCfg> listener); 1313 1314 1315 1316 /** 1317 * Lists the Password Generators. 1318 * 1319 * @return Returns an array containing the names of the 1320 * Password Generators. 1321 */ 1322 String[] listPasswordGenerators(); 1323 1324 1325 1326 /** 1327 * Gets the named Password Generator. 1328 * 1329 * @param name 1330 * The name of the Password Generator to retrieve. 1331 * @return Returns the named Password Generator. 1332 * @throws ConfigException 1333 * If the Password Generator could not be found or it 1334 * could not be successfully decoded. 1335 */ 1336 PasswordGeneratorCfg getPasswordGenerator(String name) throws ConfigException; 1337 1338 1339 1340 /** 1341 * Registers to be notified when new Password Generators are added. 1342 * 1343 * @param listener 1344 * The Password Generator configuration add listener. 1345 * @throws ConfigException 1346 * If the add listener could not be registered. 1347 */ 1348 void addPasswordGeneratorAddListener(ConfigurationAddListener<PasswordGeneratorCfg> listener) throws ConfigException; 1349 1350 1351 1352 /** 1353 * Deregisters an existing Password Generator configuration add listener. 1354 * 1355 * @param listener 1356 * The Password Generator configuration add listener. 1357 */ 1358 void removePasswordGeneratorAddListener(ConfigurationAddListener<PasswordGeneratorCfg> listener); 1359 1360 1361 1362 /** 1363 * Registers to be notified when existing Password Generators are deleted. 1364 * 1365 * @param listener 1366 * The Password Generator configuration delete listener. 1367 * @throws ConfigException 1368 * If the delete listener could not be registered. 1369 */ 1370 void addPasswordGeneratorDeleteListener(ConfigurationDeleteListener<PasswordGeneratorCfg> listener) throws ConfigException; 1371 1372 1373 1374 /** 1375 * Deregisters an existing Password Generator configuration delete listener. 1376 * 1377 * @param listener 1378 * The Password Generator configuration delete listener. 1379 */ 1380 void removePasswordGeneratorDeleteListener(ConfigurationDeleteListener<PasswordGeneratorCfg> listener); 1381 1382 1383 1384 /** 1385 * Lists the Password Policies. 1386 * 1387 * @return Returns an array containing the names of the 1388 * Password Policies. 1389 */ 1390 String[] listPasswordPolicies(); 1391 1392 1393 1394 /** 1395 * Gets the named Password Policy. 1396 * 1397 * @param name 1398 * The name of the Password Policy to retrieve. 1399 * @return Returns the named Password Policy. 1400 * @throws ConfigException 1401 * If the Password Policy could not be found or it 1402 * could not be successfully decoded. 1403 */ 1404 AuthenticationPolicyCfg getPasswordPolicy(String name) throws ConfigException; 1405 1406 1407 1408 /** 1409 * Registers to be notified when new Password Policies are added. 1410 * 1411 * @param listener 1412 * The Password Policy configuration add listener. 1413 * @throws ConfigException 1414 * If the add listener could not be registered. 1415 */ 1416 void addPasswordPolicyAddListener(ConfigurationAddListener<AuthenticationPolicyCfg> listener) throws ConfigException; 1417 1418 1419 1420 /** 1421 * Deregisters an existing Password Policy configuration add listener. 1422 * 1423 * @param listener 1424 * The Password Policy configuration add listener. 1425 */ 1426 void removePasswordPolicyAddListener(ConfigurationAddListener<AuthenticationPolicyCfg> listener); 1427 1428 1429 1430 /** 1431 * Registers to be notified when existing Password Policies are deleted. 1432 * 1433 * @param listener 1434 * The Password Policy configuration delete listener. 1435 * @throws ConfigException 1436 * If the delete listener could not be registered. 1437 */ 1438 void addPasswordPolicyDeleteListener(ConfigurationDeleteListener<AuthenticationPolicyCfg> listener) throws ConfigException; 1439 1440 1441 1442 /** 1443 * Deregisters an existing Password Policy configuration delete listener. 1444 * 1445 * @param listener 1446 * The Password Policy configuration delete listener. 1447 */ 1448 void removePasswordPolicyDeleteListener(ConfigurationDeleteListener<AuthenticationPolicyCfg> listener); 1449 1450 1451 1452 /** 1453 * Lists the Password Storage Schemes. 1454 * 1455 * @return Returns an array containing the names of the 1456 * Password Storage Schemes. 1457 */ 1458 String[] listPasswordStorageSchemes(); 1459 1460 1461 1462 /** 1463 * Gets the named Password Storage Scheme. 1464 * 1465 * @param name 1466 * The name of the Password Storage Scheme to retrieve. 1467 * @return Returns the named Password Storage Scheme. 1468 * @throws ConfigException 1469 * If the Password Storage Scheme could not be found or it 1470 * could not be successfully decoded. 1471 */ 1472 PasswordStorageSchemeCfg getPasswordStorageScheme(String name) throws ConfigException; 1473 1474 1475 1476 /** 1477 * Registers to be notified when new Password Storage Schemes are added. 1478 * 1479 * @param listener 1480 * The Password Storage Scheme configuration add listener. 1481 * @throws ConfigException 1482 * If the add listener could not be registered. 1483 */ 1484 void addPasswordStorageSchemeAddListener(ConfigurationAddListener<PasswordStorageSchemeCfg> listener) throws ConfigException; 1485 1486 1487 1488 /** 1489 * Deregisters an existing Password Storage Scheme configuration add listener. 1490 * 1491 * @param listener 1492 * The Password Storage Scheme configuration add listener. 1493 */ 1494 void removePasswordStorageSchemeAddListener(ConfigurationAddListener<PasswordStorageSchemeCfg> listener); 1495 1496 1497 1498 /** 1499 * Registers to be notified when existing Password Storage Schemes are deleted. 1500 * 1501 * @param listener 1502 * The Password Storage Scheme configuration delete listener. 1503 * @throws ConfigException 1504 * If the delete listener could not be registered. 1505 */ 1506 void addPasswordStorageSchemeDeleteListener(ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener) throws ConfigException; 1507 1508 1509 1510 /** 1511 * Deregisters an existing Password Storage Scheme configuration delete listener. 1512 * 1513 * @param listener 1514 * The Password Storage Scheme configuration delete listener. 1515 */ 1516 void removePasswordStorageSchemeDeleteListener(ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener); 1517 1518 1519 1520 /** 1521 * Lists the Password Validators. 1522 * 1523 * @return Returns an array containing the names of the 1524 * Password Validators. 1525 */ 1526 String[] listPasswordValidators(); 1527 1528 1529 1530 /** 1531 * Gets the named Password Validator. 1532 * 1533 * @param name 1534 * The name of the Password Validator to retrieve. 1535 * @return Returns the named Password Validator. 1536 * @throws ConfigException 1537 * If the Password Validator could not be found or it 1538 * could not be successfully decoded. 1539 */ 1540 PasswordValidatorCfg getPasswordValidator(String name) throws ConfigException; 1541 1542 1543 1544 /** 1545 * Registers to be notified when new Password Validators are added. 1546 * 1547 * @param listener 1548 * The Password Validator configuration add listener. 1549 * @throws ConfigException 1550 * If the add listener could not be registered. 1551 */ 1552 void addPasswordValidatorAddListener(ConfigurationAddListener<PasswordValidatorCfg> listener) throws ConfigException; 1553 1554 1555 1556 /** 1557 * Deregisters an existing Password Validator configuration add listener. 1558 * 1559 * @param listener 1560 * The Password Validator configuration add listener. 1561 */ 1562 void removePasswordValidatorAddListener(ConfigurationAddListener<PasswordValidatorCfg> listener); 1563 1564 1565 1566 /** 1567 * Registers to be notified when existing Password Validators are deleted. 1568 * 1569 * @param listener 1570 * The Password Validator configuration delete listener. 1571 * @throws ConfigException 1572 * If the delete listener could not be registered. 1573 */ 1574 void addPasswordValidatorDeleteListener(ConfigurationDeleteListener<PasswordValidatorCfg> listener) throws ConfigException; 1575 1576 1577 1578 /** 1579 * Deregisters an existing Password Validator configuration delete listener. 1580 * 1581 * @param listener 1582 * The Password Validator configuration delete listener. 1583 */ 1584 void removePasswordValidatorDeleteListener(ConfigurationDeleteListener<PasswordValidatorCfg> listener); 1585 1586 1587 1588 /** 1589 * Gets the Plugin Root. 1590 * 1591 * @return Returns the Plugin Root. 1592 * @throws ConfigException 1593 * If the Plugin Root could not be found or it could not 1594 * be successfully decoded. 1595 */ 1596 PluginRootCfg getPluginRoot() throws ConfigException; 1597 1598 1599 1600 /** 1601 * Gets the Root DN. 1602 * 1603 * @return Returns the Root DN. 1604 * @throws ConfigException 1605 * If the Root DN could not be found or it could not 1606 * be successfully decoded. 1607 */ 1608 RootDNCfg getRootDN() throws ConfigException; 1609 1610 1611 1612 /** 1613 * Gets the Root DSE Backend. 1614 * 1615 * @return Returns the Root DSE Backend. 1616 * @throws ConfigException 1617 * If the Root DSE Backend could not be found or it could not 1618 * be successfully decoded. 1619 */ 1620 RootDSEBackendCfg getRootDSEBackend() throws ConfigException; 1621 1622 1623 1624 /** 1625 * Lists the SASL Mechanism Handlers. 1626 * 1627 * @return Returns an array containing the names of the 1628 * SASL Mechanism Handlers. 1629 */ 1630 String[] listSASLMechanismHandlers(); 1631 1632 1633 1634 /** 1635 * Gets the named SASL Mechanism Handler. 1636 * 1637 * @param name 1638 * The name of the SASL Mechanism Handler to retrieve. 1639 * @return Returns the named SASL Mechanism Handler. 1640 * @throws ConfigException 1641 * If the SASL Mechanism Handler could not be found or it 1642 * could not be successfully decoded. 1643 */ 1644 SASLMechanismHandlerCfg getSASLMechanismHandler(String name) throws ConfigException; 1645 1646 1647 1648 /** 1649 * Registers to be notified when new SASL Mechanism Handlers are added. 1650 * 1651 * @param listener 1652 * The SASL Mechanism Handler configuration add listener. 1653 * @throws ConfigException 1654 * If the add listener could not be registered. 1655 */ 1656 void addSASLMechanismHandlerAddListener(ConfigurationAddListener<SASLMechanismHandlerCfg> listener) throws ConfigException; 1657 1658 1659 1660 /** 1661 * Deregisters an existing SASL Mechanism Handler configuration add listener. 1662 * 1663 * @param listener 1664 * The SASL Mechanism Handler configuration add listener. 1665 */ 1666 void removeSASLMechanismHandlerAddListener(ConfigurationAddListener<SASLMechanismHandlerCfg> listener); 1667 1668 1669 1670 /** 1671 * Registers to be notified when existing SASL Mechanism Handlers are deleted. 1672 * 1673 * @param listener 1674 * The SASL Mechanism Handler configuration delete listener. 1675 * @throws ConfigException 1676 * If the delete listener could not be registered. 1677 */ 1678 void addSASLMechanismHandlerDeleteListener(ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener) throws ConfigException; 1679 1680 1681 1682 /** 1683 * Deregisters an existing SASL Mechanism Handler configuration delete listener. 1684 * 1685 * @param listener 1686 * The SASL Mechanism Handler configuration delete listener. 1687 */ 1688 void removeSASLMechanismHandlerDeleteListener(ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener); 1689 1690 1691 1692 /** 1693 * Lists the Schema Providers. 1694 * 1695 * @return Returns an array containing the names of the 1696 * Schema Providers. 1697 */ 1698 String[] listSchemaProviders(); 1699 1700 1701 1702 /** 1703 * Gets the named Schema Provider. 1704 * 1705 * @param name 1706 * The name of the Schema Provider to retrieve. 1707 * @return Returns the named Schema Provider. 1708 * @throws ConfigException 1709 * If the Schema Provider could not be found or it 1710 * could not be successfully decoded. 1711 */ 1712 SchemaProviderCfg getSchemaProvider(String name) throws ConfigException; 1713 1714 1715 1716 /** 1717 * Registers to be notified when new Schema Providers are added. 1718 * 1719 * @param listener 1720 * The Schema Provider configuration add listener. 1721 * @throws ConfigException 1722 * If the add listener could not be registered. 1723 */ 1724 void addSchemaProviderAddListener(ConfigurationAddListener<SchemaProviderCfg> listener) throws ConfigException; 1725 1726 1727 1728 /** 1729 * Deregisters an existing Schema Provider configuration add listener. 1730 * 1731 * @param listener 1732 * The Schema Provider configuration add listener. 1733 */ 1734 void removeSchemaProviderAddListener(ConfigurationAddListener<SchemaProviderCfg> listener); 1735 1736 1737 1738 /** 1739 * Registers to be notified when existing Schema Providers are deleted. 1740 * 1741 * @param listener 1742 * The Schema Provider configuration delete listener. 1743 * @throws ConfigException 1744 * If the delete listener could not be registered. 1745 */ 1746 void addSchemaProviderDeleteListener(ConfigurationDeleteListener<SchemaProviderCfg> listener) throws ConfigException; 1747 1748 1749 1750 /** 1751 * Deregisters an existing Schema Provider configuration delete listener. 1752 * 1753 * @param listener 1754 * The Schema Provider configuration delete listener. 1755 */ 1756 void removeSchemaProviderDeleteListener(ConfigurationDeleteListener<SchemaProviderCfg> listener); 1757 1758 1759 1760 /** 1761 * Lists the Synchronization Providers. 1762 * 1763 * @return Returns an array containing the names of the 1764 * Synchronization Providers. 1765 */ 1766 String[] listSynchronizationProviders(); 1767 1768 1769 1770 /** 1771 * Gets the named Synchronization Provider. 1772 * 1773 * @param name 1774 * The name of the Synchronization Provider to retrieve. 1775 * @return Returns the named Synchronization Provider. 1776 * @throws ConfigException 1777 * If the Synchronization Provider could not be found or it 1778 * could not be successfully decoded. 1779 */ 1780 SynchronizationProviderCfg getSynchronizationProvider(String name) throws ConfigException; 1781 1782 1783 1784 /** 1785 * Registers to be notified when new Synchronization Providers are added. 1786 * 1787 * @param listener 1788 * The Synchronization Provider configuration add listener. 1789 * @throws ConfigException 1790 * If the add listener could not be registered. 1791 */ 1792 void addSynchronizationProviderAddListener(ConfigurationAddListener<SynchronizationProviderCfg> listener) throws ConfigException; 1793 1794 1795 1796 /** 1797 * Deregisters an existing Synchronization Provider configuration add listener. 1798 * 1799 * @param listener 1800 * The Synchronization Provider configuration add listener. 1801 */ 1802 void removeSynchronizationProviderAddListener(ConfigurationAddListener<SynchronizationProviderCfg> listener); 1803 1804 1805 1806 /** 1807 * Registers to be notified when existing Synchronization Providers are deleted. 1808 * 1809 * @param listener 1810 * The Synchronization Provider configuration delete listener. 1811 * @throws ConfigException 1812 * If the delete listener could not be registered. 1813 */ 1814 void addSynchronizationProviderDeleteListener(ConfigurationDeleteListener<SynchronizationProviderCfg> listener) throws ConfigException; 1815 1816 1817 1818 /** 1819 * Deregisters an existing Synchronization Provider configuration delete listener. 1820 * 1821 * @param listener 1822 * The Synchronization Provider configuration delete listener. 1823 */ 1824 void removeSynchronizationProviderDeleteListener(ConfigurationDeleteListener<SynchronizationProviderCfg> listener); 1825 1826 1827 1828 /** 1829 * Lists the Trust Manager Providers. 1830 * 1831 * @return Returns an array containing the names of the 1832 * Trust Manager Providers. 1833 */ 1834 String[] listTrustManagerProviders(); 1835 1836 1837 1838 /** 1839 * Gets the named Trust Manager Provider. 1840 * 1841 * @param name 1842 * The name of the Trust Manager Provider to retrieve. 1843 * @return Returns the named Trust Manager Provider. 1844 * @throws ConfigException 1845 * If the Trust Manager Provider could not be found or it 1846 * could not be successfully decoded. 1847 */ 1848 TrustManagerProviderCfg getTrustManagerProvider(String name) throws ConfigException; 1849 1850 1851 1852 /** 1853 * Registers to be notified when new Trust Manager Providers are added. 1854 * 1855 * @param listener 1856 * The Trust Manager Provider configuration add listener. 1857 * @throws ConfigException 1858 * If the add listener could not be registered. 1859 */ 1860 void addTrustManagerProviderAddListener(ConfigurationAddListener<TrustManagerProviderCfg> listener) throws ConfigException; 1861 1862 1863 1864 /** 1865 * Deregisters an existing Trust Manager Provider configuration add listener. 1866 * 1867 * @param listener 1868 * The Trust Manager Provider configuration add listener. 1869 */ 1870 void removeTrustManagerProviderAddListener(ConfigurationAddListener<TrustManagerProviderCfg> listener); 1871 1872 1873 1874 /** 1875 * Registers to be notified when existing Trust Manager Providers are deleted. 1876 * 1877 * @param listener 1878 * The Trust Manager Provider configuration delete listener. 1879 * @throws ConfigException 1880 * If the delete listener could not be registered. 1881 */ 1882 void addTrustManagerProviderDeleteListener(ConfigurationDeleteListener<TrustManagerProviderCfg> listener) throws ConfigException; 1883 1884 1885 1886 /** 1887 * Deregisters an existing Trust Manager Provider configuration delete listener. 1888 * 1889 * @param listener 1890 * The Trust Manager Provider configuration delete listener. 1891 */ 1892 void removeTrustManagerProviderDeleteListener(ConfigurationDeleteListener<TrustManagerProviderCfg> listener); 1893 1894 1895 1896 /** 1897 * Lists the Virtual Attributes. 1898 * 1899 * @return Returns an array containing the names of the 1900 * Virtual Attributes. 1901 */ 1902 String[] listVirtualAttributes(); 1903 1904 1905 1906 /** 1907 * Gets the named Virtual Attribute. 1908 * 1909 * @param name 1910 * The name of the Virtual Attribute to retrieve. 1911 * @return Returns the named Virtual Attribute. 1912 * @throws ConfigException 1913 * If the Virtual Attribute could not be found or it 1914 * could not be successfully decoded. 1915 */ 1916 VirtualAttributeCfg getVirtualAttribute(String name) throws ConfigException; 1917 1918 1919 1920 /** 1921 * Registers to be notified when new Virtual Attributes are added. 1922 * 1923 * @param listener 1924 * The Virtual Attribute configuration add listener. 1925 * @throws ConfigException 1926 * If the add listener could not be registered. 1927 */ 1928 void addVirtualAttributeAddListener(ConfigurationAddListener<VirtualAttributeCfg> listener) throws ConfigException; 1929 1930 1931 1932 /** 1933 * Deregisters an existing Virtual Attribute configuration add listener. 1934 * 1935 * @param listener 1936 * The Virtual Attribute configuration add listener. 1937 */ 1938 void removeVirtualAttributeAddListener(ConfigurationAddListener<VirtualAttributeCfg> listener); 1939 1940 1941 1942 /** 1943 * Registers to be notified when existing Virtual Attributes are deleted. 1944 * 1945 * @param listener 1946 * The Virtual Attribute configuration delete listener. 1947 * @throws ConfigException 1948 * If the delete listener could not be registered. 1949 */ 1950 void addVirtualAttributeDeleteListener(ConfigurationDeleteListener<VirtualAttributeCfg> listener) throws ConfigException; 1951 1952 1953 1954 /** 1955 * Deregisters an existing Virtual Attribute configuration delete listener. 1956 * 1957 * @param listener 1958 * The Virtual Attribute configuration delete listener. 1959 */ 1960 void removeVirtualAttributeDeleteListener(ConfigurationDeleteListener<VirtualAttributeCfg> listener); 1961 1962 1963 1964 /** 1965 * Gets the Work Queue. 1966 * 1967 * @return Returns the Work Queue. 1968 * @throws ConfigException 1969 * If the Work Queue could not be found or it could not 1970 * be successfully decoded. 1971 */ 1972 WorkQueueCfg getWorkQueue() throws ConfigException; 1973 1974}