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