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 legal-notices/CDDLv1_0.txt 010 * or http://forgerock.org/license/CDDLv1.0.html. 011 * See the License for the specific language governing permissions 012 * and limitations under the License. 013 * 014 * When distributing Covered Code, include this CDDL HEADER in each 015 * file and include the License file at legal-notices/CDDLv1_0.txt. 016 * If applicable, add the following below this CDDL HEADER, with the 017 * fields enclosed by brackets "[]" replaced with your own identifying 018 * information: 019 * Portions Copyright [yyyy] [name of copyright owner] 020 * 021 * CDDL HEADER END 022 * 023 * 024 * Copyright 2008 Sun Microsystems, Inc. 025 */ 026package org.forgerock.opendj.server.config.client; 027 028 029 030import java.util.Collection; 031import org.forgerock.opendj.config.client.ConcurrentModificationException; 032import org.forgerock.opendj.config.client.IllegalManagedObjectNameException; 033import org.forgerock.opendj.config.client.ManagedObjectDecodingException; 034import org.forgerock.opendj.config.client.OperationRejectedException; 035import org.forgerock.opendj.config.ConfigurationClient; 036import org.forgerock.opendj.config.DefinitionDecodingException; 037import org.forgerock.opendj.config.ManagedObjectDefinition; 038import org.forgerock.opendj.config.ManagedObjectNotFoundException; 039import org.forgerock.opendj.config.PropertyException; 040import org.forgerock.opendj.ldap.LdapException; 041import org.forgerock.opendj.server.config.server.AccountStatusNotificationHandlerCfg; 042import org.forgerock.opendj.server.config.server.AlertHandlerCfg; 043import org.forgerock.opendj.server.config.server.AttributeSyntaxCfg; 044import org.forgerock.opendj.server.config.server.AuthenticationPolicyCfg; 045import org.forgerock.opendj.server.config.server.BackendCfg; 046import org.forgerock.opendj.server.config.server.CertificateMapperCfg; 047import org.forgerock.opendj.server.config.server.ConnectionHandlerCfg; 048import org.forgerock.opendj.server.config.server.EntryCacheCfg; 049import org.forgerock.opendj.server.config.server.ExtendedOperationHandlerCfg; 050import org.forgerock.opendj.server.config.server.GroupImplementationCfg; 051import org.forgerock.opendj.server.config.server.IdentityMapperCfg; 052import org.forgerock.opendj.server.config.server.KeyManagerProviderCfg; 053import org.forgerock.opendj.server.config.server.LogPublisherCfg; 054import org.forgerock.opendj.server.config.server.LogRetentionPolicyCfg; 055import org.forgerock.opendj.server.config.server.LogRotationPolicyCfg; 056import org.forgerock.opendj.server.config.server.MatchingRuleCfg; 057import org.forgerock.opendj.server.config.server.MonitorProviderCfg; 058import org.forgerock.opendj.server.config.server.PasswordGeneratorCfg; 059import org.forgerock.opendj.server.config.server.PasswordStorageSchemeCfg; 060import org.forgerock.opendj.server.config.server.PasswordValidatorCfg; 061import org.forgerock.opendj.server.config.server.RootCfg; 062import org.forgerock.opendj.server.config.server.SASLMechanismHandlerCfg; 063import org.forgerock.opendj.server.config.server.SchemaProviderCfg; 064import org.forgerock.opendj.server.config.server.SynchronizationProviderCfg; 065import org.forgerock.opendj.server.config.server.TrustManagerProviderCfg; 066import org.forgerock.opendj.server.config.server.VirtualAttributeCfg; 067 068 069 070/** 071 * A client-side interface for reading and modifying Root settings. 072 * <p> 073 * The root configuration provides an entry point to the rest of the 074 * OpenDJ configuration. 075 */ 076public interface RootCfgClient extends ConfigurationClient { 077 078 /** 079 * Get the configuration definition associated with this Root. 080 * 081 * @return Returns the configuration definition associated with this Root. 082 */ 083 ManagedObjectDefinition<? extends RootCfgClient, ? extends RootCfg> definition(); 084 085 086 087 /** 088 * Gets the Access Control Handler. 089 * 090 * @return Returns the Access Control Handler. 091 * @throws DefinitionDecodingException 092 * If the Access Control Handler was found but its type 093 * could not be determined. 094 * @throws ManagedObjectDecodingException 095 * If the Access Control Handler was found but one or more 096 * of its properties could not be decoded. 097 * @throws ManagedObjectNotFoundException 098 * If the Access Control Handler could not be found on the 099 * server. 100 * @throws ConcurrentModificationException 101 * If this Root has been removed from the server by 102 * another client. 103 * @throws LdapException 104 * If any other error occurs. 105 */ 106 AccessControlHandlerCfgClient getAccessControlHandler() 107 throws DefinitionDecodingException, ManagedObjectDecodingException, 108 ManagedObjectNotFoundException, ConcurrentModificationException, 109 LdapException; 110 111 112 113 /** 114 * Lists the Account Status Notification Handlers. 115 * 116 * @return Returns an array containing the names of the Account 117 * Status Notification Handlers. 118 * @throws ConcurrentModificationException 119 * If this Root has been removed from the server by 120 * another client. 121 * @throws LdapException 122 * If any other error occurs. 123 */ 124 String[] listAccountStatusNotificationHandlers() throws ConcurrentModificationException, 125 LdapException; 126 127 128 129 /** 130 * Gets the named Account Status Notification Handler. 131 * 132 * @param name 133 * The name of the Account Status Notification Handler to 134 * retrieve. 135 * @return Returns the named Account Status Notification Handler. 136 * @throws DefinitionDecodingException 137 * If the named Account Status Notification Handler was 138 * found but its type could not be determined. 139 * @throws ManagedObjectDecodingException 140 * If the named Account Status Notification Handler was 141 * found but one or more of its properties could not be 142 * decoded. 143 * @throws ManagedObjectNotFoundException 144 * If the named Account Status Notification Handler was 145 * not found on the server. 146 * @throws ConcurrentModificationException 147 * If this Root has been removed from the server by 148 * another client. 149 * @throws LdapException 150 * If any other error occurs. 151 */ 152 AccountStatusNotificationHandlerCfgClient getAccountStatusNotificationHandler(String name) 153 throws DefinitionDecodingException, ManagedObjectDecodingException, 154 ManagedObjectNotFoundException, ConcurrentModificationException, 155 LdapException; 156 157 158 159 /** 160 * Creates a new Account Status Notification Handler. The new 161 * Account Status Notification Handler will initially not contain any 162 * property values (including mandatory properties). Once the Account 163 * Status Notification Handler has been configured it can be added to 164 * the server using the {@link #commit()} method. 165 * 166 * @param <C> 167 * The type of the Account Status Notification Handler 168 * being created. 169 * @param d 170 * The definition of the Account Status Notification 171 * Handler to be created. 172 * @param name 173 * The name of the new Account Status Notification Handler. 174 * @param exceptions 175 * An optional collection in which to place any {@link 176 * PropertyException}s that occurred whilst attempting to 177 * determine the default values of the Account Status 178 * Notification Handler. This argument can be 179 * <code>null<code>. 180 * @return Returns a new Account Status Notification Handler 181 * configuration instance. 182 * @throws IllegalManagedObjectNameException 183 * If the name of the new Account Status Notification 184 * Handler is invalid. 185 */ 186 <C extends AccountStatusNotificationHandlerCfgClient> C createAccountStatusNotificationHandler( 187 ManagedObjectDefinition<C, ? extends AccountStatusNotificationHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 188 189 190 191 /** 192 * Removes the named Account Status Notification Handler. 193 * 194 * @param name 195 * The name of the Account Status Notification Handler to 196 * remove. 197 * @throws ManagedObjectNotFoundException 198 * If the Account Status Notification Handler does not 199 * exist. 200 * @throws OperationRejectedException 201 * If the server refuses to remove the Account Status 202 * Notification Handler due to some server-side constraint 203 * which cannot be satisfied (for example, if it is 204 * referenced by another managed object). 205 * @throws ConcurrentModificationException 206 * If this Root has been removed from the server by 207 * another client. 208 * @throws LdapException 209 * If any other error occurs. 210 */ 211 void removeAccountStatusNotificationHandler(String name) 212 throws ManagedObjectNotFoundException, OperationRejectedException, 213 ConcurrentModificationException, LdapException; 214 215 216 217 /** 218 * Gets the Administration Connector. 219 * 220 * @return Returns the Administration Connector. 221 * @throws DefinitionDecodingException 222 * If the Administration Connector was found but its type 223 * could not be determined. 224 * @throws ManagedObjectDecodingException 225 * If the Administration Connector was found but one or 226 * more of its properties could not be decoded. 227 * @throws ManagedObjectNotFoundException 228 * If the Administration Connector could not be found on 229 * the server. 230 * @throws ConcurrentModificationException 231 * If this Root has been removed from the server by 232 * another client. 233 * @throws LdapException 234 * If any other error occurs. 235 */ 236 AdministrationConnectorCfgClient getAdministrationConnector() 237 throws DefinitionDecodingException, ManagedObjectDecodingException, 238 ManagedObjectNotFoundException, ConcurrentModificationException, 239 LdapException; 240 241 242 243 /** 244 * Lists the Alert Handlers. 245 * 246 * @return Returns an array containing the names of the Alert 247 * Handlers. 248 * @throws ConcurrentModificationException 249 * If this Root has been removed from the server by 250 * another client. 251 * @throws LdapException 252 * If any other error occurs. 253 */ 254 String[] listAlertHandlers() throws ConcurrentModificationException, 255 LdapException; 256 257 258 259 /** 260 * Gets the named Alert Handler. 261 * 262 * @param name 263 * The name of the Alert Handler to retrieve. 264 * @return Returns the named Alert Handler. 265 * @throws DefinitionDecodingException 266 * If the named Alert Handler was found but its type could 267 * not be determined. 268 * @throws ManagedObjectDecodingException 269 * If the named Alert Handler was found but one or more of 270 * its properties could not be decoded. 271 * @throws ManagedObjectNotFoundException 272 * If the named Alert Handler was not found on the server. 273 * @throws ConcurrentModificationException 274 * If this Root has been removed from the server by 275 * another client. 276 * @throws LdapException 277 * If any other error occurs. 278 */ 279 AlertHandlerCfgClient getAlertHandler(String name) 280 throws DefinitionDecodingException, ManagedObjectDecodingException, 281 ManagedObjectNotFoundException, ConcurrentModificationException, 282 LdapException; 283 284 285 286 /** 287 * Creates a new Alert Handler. The new Alert Handler will initially 288 * not contain any property values (including mandatory properties). 289 * Once the Alert Handler has been configured it can be added to the 290 * server using the {@link #commit()} method. 291 * 292 * @param <C> 293 * The type of the Alert Handler being created. 294 * @param d 295 * The definition of the Alert Handler to be created. 296 * @param name 297 * The name of the new Alert Handler. 298 * @param exceptions 299 * An optional collection in which to place any {@link 300 * PropertyException}s that occurred whilst attempting to 301 * determine the default values of the Alert Handler. This 302 * argument can be <code>null<code>. 303 * @return Returns a new Alert Handler configuration instance. 304 * @throws IllegalManagedObjectNameException 305 * If the name of the new Alert Handler is invalid. 306 */ 307 <C extends AlertHandlerCfgClient> C createAlertHandler( 308 ManagedObjectDefinition<C, ? extends AlertHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 309 310 311 312 /** 313 * Removes the named Alert Handler. 314 * 315 * @param name 316 * The name of the Alert Handler to remove. 317 * @throws ManagedObjectNotFoundException 318 * If the Alert Handler does not exist. 319 * @throws OperationRejectedException 320 * If the server refuses to remove the Alert Handler due 321 * to some server-side constraint which cannot be satisfied 322 * (for example, if it is referenced by another managed 323 * object). 324 * @throws ConcurrentModificationException 325 * If this Root has been removed from the server by 326 * another client. 327 * @throws LdapException 328 * If any other error occurs. 329 */ 330 void removeAlertHandler(String name) 331 throws ManagedObjectNotFoundException, OperationRejectedException, 332 ConcurrentModificationException, LdapException; 333 334 335 336 /** 337 * Lists the Attribute Syntaxes. 338 * 339 * @return Returns an array containing the names of the Attribute 340 * Syntaxes. 341 * @throws ConcurrentModificationException 342 * If this Root has been removed from the server by 343 * another client. 344 * @throws LdapException 345 * If any other error occurs. 346 */ 347 String[] listAttributeSyntaxes() throws ConcurrentModificationException, 348 LdapException; 349 350 351 352 /** 353 * Gets the named Attribute Syntax. 354 * 355 * @param name 356 * The name of the Attribute Syntax to retrieve. 357 * @return Returns the named Attribute Syntax. 358 * @throws DefinitionDecodingException 359 * If the named Attribute Syntax was found but its type 360 * could not be determined. 361 * @throws ManagedObjectDecodingException 362 * If the named Attribute Syntax was found but one or more 363 * of its properties could not be decoded. 364 * @throws ManagedObjectNotFoundException 365 * If the named Attribute Syntax was not found on the 366 * server. 367 * @throws ConcurrentModificationException 368 * If this Root has been removed from the server by 369 * another client. 370 * @throws LdapException 371 * If any other error occurs. 372 */ 373 AttributeSyntaxCfgClient getAttributeSyntax(String name) 374 throws DefinitionDecodingException, ManagedObjectDecodingException, 375 ManagedObjectNotFoundException, ConcurrentModificationException, 376 LdapException; 377 378 379 380 /** 381 * Creates a new Attribute Syntax. The new Attribute Syntax will 382 * initially not contain any property values (including mandatory 383 * properties). Once the Attribute Syntax has been configured it can 384 * be added to the server using the {@link #commit()} method. 385 * 386 * @param <C> 387 * The type of the Attribute Syntax being created. 388 * @param d 389 * The definition of the Attribute Syntax to be created. 390 * @param name 391 * The name of the new Attribute Syntax. 392 * @param exceptions 393 * An optional collection in which to place any {@link 394 * PropertyException}s that occurred whilst attempting to 395 * determine the default values of the Attribute Syntax. 396 * This argument can be <code>null<code>. 397 * @return Returns a new Attribute Syntax configuration instance. 398 * @throws IllegalManagedObjectNameException 399 * If the name of the new Attribute Syntax is invalid. 400 */ 401 <C extends AttributeSyntaxCfgClient> C createAttributeSyntax( 402 ManagedObjectDefinition<C, ? extends AttributeSyntaxCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 403 404 405 406 /** 407 * Removes the named Attribute Syntax. 408 * 409 * @param name 410 * The name of the Attribute Syntax to remove. 411 * @throws ManagedObjectNotFoundException 412 * If the Attribute Syntax does not exist. 413 * @throws OperationRejectedException 414 * If the server refuses to remove the Attribute Syntax 415 * due to some server-side constraint which cannot be 416 * satisfied (for example, if it is referenced by another 417 * managed object). 418 * @throws ConcurrentModificationException 419 * If this Root has been removed from the server by 420 * another client. 421 * @throws LdapException 422 * If any other error occurs. 423 */ 424 void removeAttributeSyntax(String name) 425 throws ManagedObjectNotFoundException, OperationRejectedException, 426 ConcurrentModificationException, LdapException; 427 428 429 430 /** 431 * Lists the Backends. 432 * 433 * @return Returns an array containing the names of the Backends. 434 * @throws ConcurrentModificationException 435 * If this Root has been removed from the server by 436 * another client. 437 * @throws LdapException 438 * If any other error occurs. 439 */ 440 String[] listBackends() throws ConcurrentModificationException, 441 LdapException; 442 443 444 445 /** 446 * Gets the named Backend. 447 * 448 * @param name 449 * The name of the Backend to retrieve. 450 * @return Returns the named Backend. 451 * @throws DefinitionDecodingException 452 * If the named Backend was found but its type could not 453 * be determined. 454 * @throws ManagedObjectDecodingException 455 * If the named Backend was found but one or more of its 456 * properties could not be decoded. 457 * @throws ManagedObjectNotFoundException 458 * If the named Backend was not found on the server. 459 * @throws ConcurrentModificationException 460 * If this Root has been removed from the server by 461 * another client. 462 * @throws LdapException 463 * If any other error occurs. 464 */ 465 BackendCfgClient getBackend(String name) 466 throws DefinitionDecodingException, ManagedObjectDecodingException, 467 ManagedObjectNotFoundException, ConcurrentModificationException, 468 LdapException; 469 470 471 472 /** 473 * Creates a new Backend. The new Backend will initially not contain 474 * any property values (including mandatory properties). Once the 475 * Backend has been configured it can be added to the server using 476 * the {@link #commit()} method. 477 * 478 * @param <C> 479 * The type of the Backend being created. 480 * @param d 481 * The definition of the Backend to be created. 482 * @param name 483 * The name of the new Backend. 484 * @param exceptions 485 * An optional collection in which to place any {@link 486 * PropertyException}s that occurred whilst attempting to 487 * determine the default values of the Backend. This 488 * argument can be <code>null<code>. 489 * @return Returns a new Backend configuration instance. 490 * @throws IllegalManagedObjectNameException 491 * If the name of the new Backend is invalid. 492 */ 493 <C extends BackendCfgClient> C createBackend( 494 ManagedObjectDefinition<C, ? extends BackendCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 495 496 497 498 /** 499 * Removes the named Backend. 500 * 501 * @param name 502 * The name of the Backend to remove. 503 * @throws ManagedObjectNotFoundException 504 * If the Backend does not exist. 505 * @throws OperationRejectedException 506 * If the server refuses to remove the Backend due to some 507 * server-side constraint which cannot be satisfied (for 508 * example, if it is referenced by another managed object). 509 * @throws ConcurrentModificationException 510 * If this Root has been removed from the server by 511 * another client. 512 * @throws LdapException 513 * If any other error occurs. 514 */ 515 void removeBackend(String name) 516 throws ManagedObjectNotFoundException, OperationRejectedException, 517 ConcurrentModificationException, LdapException; 518 519 520 521 /** 522 * Lists the Certificate Mappers. 523 * 524 * @return Returns an array containing the names of the Certificate 525 * Mappers. 526 * @throws ConcurrentModificationException 527 * If this Root has been removed from the server by 528 * another client. 529 * @throws LdapException 530 * If any other error occurs. 531 */ 532 String[] listCertificateMappers() throws ConcurrentModificationException, 533 LdapException; 534 535 536 537 /** 538 * Gets the named Certificate Mapper. 539 * 540 * @param name 541 * The name of the Certificate Mapper to retrieve. 542 * @return Returns the named Certificate Mapper. 543 * @throws DefinitionDecodingException 544 * If the named Certificate Mapper was found but its type 545 * could not be determined. 546 * @throws ManagedObjectDecodingException 547 * If the named Certificate Mapper was found but one or 548 * more of its properties could not be decoded. 549 * @throws ManagedObjectNotFoundException 550 * If the named Certificate Mapper was not found on the 551 * server. 552 * @throws ConcurrentModificationException 553 * If this Root has been removed from the server by 554 * another client. 555 * @throws LdapException 556 * If any other error occurs. 557 */ 558 CertificateMapperCfgClient getCertificateMapper(String name) 559 throws DefinitionDecodingException, ManagedObjectDecodingException, 560 ManagedObjectNotFoundException, ConcurrentModificationException, 561 LdapException; 562 563 564 565 /** 566 * Creates a new Certificate Mapper. The new Certificate Mapper will 567 * initially not contain any property values (including mandatory 568 * properties). Once the Certificate Mapper has been configured it 569 * can be added to the server using the {@link #commit()} method. 570 * 571 * @param <C> 572 * The type of the Certificate Mapper being created. 573 * @param d 574 * The definition of the Certificate Mapper to be created. 575 * @param name 576 * The name of the new Certificate Mapper. 577 * @param exceptions 578 * An optional collection in which to place any {@link 579 * PropertyException}s that occurred whilst attempting to 580 * determine the default values of the Certificate Mapper. 581 * This argument can be <code>null<code>. 582 * @return Returns a new Certificate Mapper configuration instance. 583 * @throws IllegalManagedObjectNameException 584 * If the name of the new Certificate Mapper is invalid. 585 */ 586 <C extends CertificateMapperCfgClient> C createCertificateMapper( 587 ManagedObjectDefinition<C, ? extends CertificateMapperCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 588 589 590 591 /** 592 * Removes the named Certificate Mapper. 593 * 594 * @param name 595 * The name of the Certificate Mapper to remove. 596 * @throws ManagedObjectNotFoundException 597 * If the Certificate Mapper does not exist. 598 * @throws OperationRejectedException 599 * If the server refuses to remove the Certificate Mapper 600 * due to some server-side constraint which cannot be 601 * satisfied (for example, if it is referenced by another 602 * managed object). 603 * @throws ConcurrentModificationException 604 * If this Root has been removed from the server by 605 * another client. 606 * @throws LdapException 607 * If any other error occurs. 608 */ 609 void removeCertificateMapper(String name) 610 throws ManagedObjectNotFoundException, OperationRejectedException, 611 ConcurrentModificationException, LdapException; 612 613 614 615 /** 616 * Lists the Connection Handlers. 617 * 618 * @return Returns an array containing the names of the Connection 619 * Handlers. 620 * @throws ConcurrentModificationException 621 * If this Root has been removed from the server by 622 * another client. 623 * @throws LdapException 624 * If any other error occurs. 625 */ 626 String[] listConnectionHandlers() throws ConcurrentModificationException, 627 LdapException; 628 629 630 631 /** 632 * Gets the named Connection Handler. 633 * 634 * @param name 635 * The name of the Connection Handler to retrieve. 636 * @return Returns the named Connection Handler. 637 * @throws DefinitionDecodingException 638 * If the named Connection Handler was found but its type 639 * could not be determined. 640 * @throws ManagedObjectDecodingException 641 * If the named Connection Handler was found but one or 642 * more of its properties could not be decoded. 643 * @throws ManagedObjectNotFoundException 644 * If the named Connection Handler was not found on the 645 * server. 646 * @throws ConcurrentModificationException 647 * If this Root has been removed from the server by 648 * another client. 649 * @throws LdapException 650 * If any other error occurs. 651 */ 652 ConnectionHandlerCfgClient getConnectionHandler(String name) 653 throws DefinitionDecodingException, ManagedObjectDecodingException, 654 ManagedObjectNotFoundException, ConcurrentModificationException, 655 LdapException; 656 657 658 659 /** 660 * Creates a new Connection Handler. The new Connection Handler will 661 * initially not contain any property values (including mandatory 662 * properties). Once the Connection Handler has been configured it 663 * can be added to the server using the {@link #commit()} method. 664 * 665 * @param <C> 666 * The type of the Connection Handler being created. 667 * @param d 668 * The definition of the Connection Handler to be created. 669 * @param name 670 * The name of the new Connection Handler. 671 * @param exceptions 672 * An optional collection in which to place any {@link 673 * PropertyException}s that occurred whilst attempting to 674 * determine the default values of the Connection Handler. 675 * This argument can be <code>null<code>. 676 * @return Returns a new Connection Handler configuration instance. 677 * @throws IllegalManagedObjectNameException 678 * If the name of the new Connection Handler is invalid. 679 */ 680 <C extends ConnectionHandlerCfgClient> C createConnectionHandler( 681 ManagedObjectDefinition<C, ? extends ConnectionHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 682 683 684 685 /** 686 * Removes the named Connection Handler. 687 * 688 * @param name 689 * The name of the Connection Handler to remove. 690 * @throws ManagedObjectNotFoundException 691 * If the Connection Handler does not exist. 692 * @throws OperationRejectedException 693 * If the server refuses to remove the Connection Handler 694 * due to some server-side constraint which cannot be 695 * satisfied (for example, if it is referenced by another 696 * managed object). 697 * @throws ConcurrentModificationException 698 * If this Root has been removed from the server by 699 * another client. 700 * @throws LdapException 701 * If any other error occurs. 702 */ 703 void removeConnectionHandler(String name) 704 throws ManagedObjectNotFoundException, OperationRejectedException, 705 ConcurrentModificationException, LdapException; 706 707 708 709 /** 710 * Gets the Crypto Manager. 711 * 712 * @return Returns the Crypto Manager. 713 * @throws DefinitionDecodingException 714 * If the Crypto Manager was found but its type could not 715 * be determined. 716 * @throws ManagedObjectDecodingException 717 * If the Crypto Manager was found but one or more of its 718 * properties could not be decoded. 719 * @throws ManagedObjectNotFoundException 720 * If the Crypto Manager could not be found on the server. 721 * @throws ConcurrentModificationException 722 * If this Root has been removed from the server by 723 * another client. 724 * @throws LdapException 725 * If any other error occurs. 726 */ 727 CryptoManagerCfgClient getCryptoManager() 728 throws DefinitionDecodingException, ManagedObjectDecodingException, 729 ManagedObjectNotFoundException, ConcurrentModificationException, 730 LdapException; 731 732 733 734 /** 735 * Lists the Entry Caches. 736 * 737 * @return Returns an array containing the names of the Entry 738 * Caches. 739 * @throws ConcurrentModificationException 740 * If this Root has been removed from the server by 741 * another client. 742 * @throws LdapException 743 * If any other error occurs. 744 */ 745 String[] listEntryCaches() throws ConcurrentModificationException, 746 LdapException; 747 748 749 750 /** 751 * Gets the named Entry Cache. 752 * 753 * @param name 754 * The name of the Entry Cache to retrieve. 755 * @return Returns the named Entry Cache. 756 * @throws DefinitionDecodingException 757 * If the named Entry Cache was found but its type could 758 * not be determined. 759 * @throws ManagedObjectDecodingException 760 * If the named Entry Cache was found but one or more of 761 * its properties could not be decoded. 762 * @throws ManagedObjectNotFoundException 763 * If the named Entry Cache was not found on the server. 764 * @throws ConcurrentModificationException 765 * If this Root has been removed from the server by 766 * another client. 767 * @throws LdapException 768 * If any other error occurs. 769 */ 770 EntryCacheCfgClient getEntryCache(String name) 771 throws DefinitionDecodingException, ManagedObjectDecodingException, 772 ManagedObjectNotFoundException, ConcurrentModificationException, 773 LdapException; 774 775 776 777 /** 778 * Creates a new Entry Cache. The new Entry Cache will initially not 779 * contain any property values (including mandatory properties). Once 780 * the Entry Cache has been configured it can be added to the server 781 * using the {@link #commit()} method. 782 * 783 * @param <C> 784 * The type of the Entry Cache being created. 785 * @param d 786 * The definition of the Entry Cache to be created. 787 * @param name 788 * The name of the new Entry Cache. 789 * @param exceptions 790 * An optional collection in which to place any {@link 791 * PropertyException}s that occurred whilst attempting to 792 * determine the default values of the Entry Cache. This 793 * argument can be <code>null<code>. 794 * @return Returns a new Entry Cache configuration instance. 795 * @throws IllegalManagedObjectNameException 796 * If the name of the new Entry Cache is invalid. 797 */ 798 <C extends EntryCacheCfgClient> C createEntryCache( 799 ManagedObjectDefinition<C, ? extends EntryCacheCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 800 801 802 803 /** 804 * Removes the named Entry Cache. 805 * 806 * @param name 807 * The name of the Entry Cache to remove. 808 * @throws ManagedObjectNotFoundException 809 * If the Entry Cache does not exist. 810 * @throws OperationRejectedException 811 * If the server refuses to remove the Entry Cache due to 812 * some server-side constraint which cannot be satisfied 813 * (for example, if it is referenced by another managed 814 * object). 815 * @throws ConcurrentModificationException 816 * If this Root has been removed from the server by 817 * another client. 818 * @throws LdapException 819 * If any other error occurs. 820 */ 821 void removeEntryCache(String name) 822 throws ManagedObjectNotFoundException, OperationRejectedException, 823 ConcurrentModificationException, LdapException; 824 825 826 827 /** 828 * Lists the Extended Operation Handlers. 829 * 830 * @return Returns an array containing the names of the Extended 831 * Operation Handlers. 832 * @throws ConcurrentModificationException 833 * If this Root has been removed from the server by 834 * another client. 835 * @throws LdapException 836 * If any other error occurs. 837 */ 838 String[] listExtendedOperationHandlers() throws ConcurrentModificationException, 839 LdapException; 840 841 842 843 /** 844 * Gets the named Extended Operation Handler. 845 * 846 * @param name 847 * The name of the Extended Operation Handler to retrieve. 848 * @return Returns the named Extended Operation Handler. 849 * @throws DefinitionDecodingException 850 * If the named Extended Operation Handler was found but 851 * its type could not be determined. 852 * @throws ManagedObjectDecodingException 853 * If the named Extended Operation Handler was found but 854 * one or more of its properties could not be decoded. 855 * @throws ManagedObjectNotFoundException 856 * If the named Extended Operation Handler was not found 857 * on the server. 858 * @throws ConcurrentModificationException 859 * If this Root has been removed from the server by 860 * another client. 861 * @throws LdapException 862 * If any other error occurs. 863 */ 864 ExtendedOperationHandlerCfgClient getExtendedOperationHandler(String name) 865 throws DefinitionDecodingException, ManagedObjectDecodingException, 866 ManagedObjectNotFoundException, ConcurrentModificationException, 867 LdapException; 868 869 870 871 /** 872 * Creates a new Extended Operation Handler. The new Extended 873 * Operation Handler will initially not contain any property values 874 * (including mandatory properties). Once the Extended Operation 875 * Handler has been configured it can be added to the server using 876 * the {@link #commit()} method. 877 * 878 * @param <C> 879 * The type of the Extended Operation Handler being 880 * created. 881 * @param d 882 * The definition of the Extended Operation Handler to be 883 * created. 884 * @param name 885 * The name of the new Extended Operation Handler. 886 * @param exceptions 887 * An optional collection in which to place any {@link 888 * PropertyException}s that occurred whilst attempting to 889 * determine the default values of the Extended Operation 890 * Handler. This argument can be <code>null<code>. 891 * @return Returns a new Extended Operation Handler configuration 892 * instance. 893 * @throws IllegalManagedObjectNameException 894 * If the name of the new Extended Operation Handler is 895 * invalid. 896 */ 897 <C extends ExtendedOperationHandlerCfgClient> C createExtendedOperationHandler( 898 ManagedObjectDefinition<C, ? extends ExtendedOperationHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 899 900 901 902 /** 903 * Removes the named Extended Operation Handler. 904 * 905 * @param name 906 * The name of the Extended Operation Handler to remove. 907 * @throws ManagedObjectNotFoundException 908 * If the Extended Operation Handler does not exist. 909 * @throws OperationRejectedException 910 * If the server refuses to remove the Extended Operation 911 * Handler due to some server-side constraint which cannot 912 * be satisfied (for example, if it is referenced by 913 * another managed object). 914 * @throws ConcurrentModificationException 915 * If this Root has been removed from the server by 916 * another client. 917 * @throws LdapException 918 * If any other error occurs. 919 */ 920 void removeExtendedOperationHandler(String name) 921 throws ManagedObjectNotFoundException, OperationRejectedException, 922 ConcurrentModificationException, LdapException; 923 924 925 926 /** 927 * Gets the Global Configuration. 928 * 929 * @return Returns the Global Configuration. 930 * @throws DefinitionDecodingException 931 * If the Global Configuration was found but its type 932 * could not be determined. 933 * @throws ManagedObjectDecodingException 934 * If the Global Configuration was found but one or more 935 * of its properties could not be decoded. 936 * @throws ManagedObjectNotFoundException 937 * If the Global Configuration could not be found on the 938 * server. 939 * @throws ConcurrentModificationException 940 * If this Root has been removed from the server by 941 * another client. 942 * @throws LdapException 943 * If any other error occurs. 944 */ 945 GlobalCfgClient getGlobalConfiguration() 946 throws DefinitionDecodingException, ManagedObjectDecodingException, 947 ManagedObjectNotFoundException, ConcurrentModificationException, 948 LdapException; 949 950 951 952 /** 953 * Lists the Group Implementations. 954 * 955 * @return Returns an array containing the names of the Group 956 * Implementations. 957 * @throws ConcurrentModificationException 958 * If this Root has been removed from the server by 959 * another client. 960 * @throws LdapException 961 * If any other error occurs. 962 */ 963 String[] listGroupImplementations() throws ConcurrentModificationException, 964 LdapException; 965 966 967 968 /** 969 * Gets the named Group Implementation. 970 * 971 * @param name 972 * The name of the Group Implementation to retrieve. 973 * @return Returns the named Group Implementation. 974 * @throws DefinitionDecodingException 975 * If the named Group Implementation was found but its 976 * type could not be determined. 977 * @throws ManagedObjectDecodingException 978 * If the named Group Implementation was found but one or 979 * more of its properties could not be decoded. 980 * @throws ManagedObjectNotFoundException 981 * If the named Group Implementation was not found on the 982 * server. 983 * @throws ConcurrentModificationException 984 * If this Root has been removed from the server by 985 * another client. 986 * @throws LdapException 987 * If any other error occurs. 988 */ 989 GroupImplementationCfgClient getGroupImplementation(String name) 990 throws DefinitionDecodingException, ManagedObjectDecodingException, 991 ManagedObjectNotFoundException, ConcurrentModificationException, 992 LdapException; 993 994 995 996 /** 997 * Creates a new Group Implementation. The new Group Implementation 998 * will initially not contain any property values (including 999 * mandatory properties). Once the Group Implementation has been 1000 * configured it can be added to the server using the {@link 1001 * #commit()} method. 1002 * 1003 * @param <C> 1004 * The type of the Group Implementation being created. 1005 * @param d 1006 * The definition of the Group Implementation to be 1007 * created. 1008 * @param name 1009 * The name of the new Group Implementation. 1010 * @param exceptions 1011 * An optional collection in which to place any {@link 1012 * PropertyException}s that occurred whilst attempting to 1013 * determine the default values of the Group Implementation. 1014 * This argument can be <code>null<code>. 1015 * @return Returns a new Group Implementation configuration 1016 * instance. 1017 * @throws IllegalManagedObjectNameException 1018 * If the name of the new Group Implementation is invalid. 1019 */ 1020 <C extends GroupImplementationCfgClient> C createGroupImplementation( 1021 ManagedObjectDefinition<C, ? extends GroupImplementationCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1022 1023 1024 1025 /** 1026 * Removes the named Group Implementation. 1027 * 1028 * @param name 1029 * The name of the Group Implementation to remove. 1030 * @throws ManagedObjectNotFoundException 1031 * If the Group Implementation does not exist. 1032 * @throws OperationRejectedException 1033 * If the server refuses to remove the Group 1034 * Implementation due to some server-side constraint which 1035 * cannot be satisfied (for example, if it is referenced by 1036 * another managed object). 1037 * @throws ConcurrentModificationException 1038 * If this Root has been removed from the server by 1039 * another client. 1040 * @throws LdapException 1041 * If any other error occurs. 1042 */ 1043 void removeGroupImplementation(String name) 1044 throws ManagedObjectNotFoundException, OperationRejectedException, 1045 ConcurrentModificationException, LdapException; 1046 1047 1048 1049 /** 1050 * Lists the Identity Mappers. 1051 * 1052 * @return Returns an array containing the names of the Identity 1053 * Mappers. 1054 * @throws ConcurrentModificationException 1055 * If this Root has been removed from the server by 1056 * another client. 1057 * @throws LdapException 1058 * If any other error occurs. 1059 */ 1060 String[] listIdentityMappers() throws ConcurrentModificationException, 1061 LdapException; 1062 1063 1064 1065 /** 1066 * Gets the named Identity Mapper. 1067 * 1068 * @param name 1069 * The name of the Identity Mapper to retrieve. 1070 * @return Returns the named Identity Mapper. 1071 * @throws DefinitionDecodingException 1072 * If the named Identity Mapper was found but its type 1073 * could not be determined. 1074 * @throws ManagedObjectDecodingException 1075 * If the named Identity Mapper was found but one or more 1076 * of its properties could not be decoded. 1077 * @throws ManagedObjectNotFoundException 1078 * If the named Identity Mapper was not found on the 1079 * server. 1080 * @throws ConcurrentModificationException 1081 * If this Root has been removed from the server by 1082 * another client. 1083 * @throws LdapException 1084 * If any other error occurs. 1085 */ 1086 IdentityMapperCfgClient getIdentityMapper(String name) 1087 throws DefinitionDecodingException, ManagedObjectDecodingException, 1088 ManagedObjectNotFoundException, ConcurrentModificationException, 1089 LdapException; 1090 1091 1092 1093 /** 1094 * Creates a new Identity Mapper. The new Identity Mapper will 1095 * initially not contain any property values (including mandatory 1096 * properties). Once the Identity Mapper has been configured it can 1097 * be added to the server using the {@link #commit()} method. 1098 * 1099 * @param <C> 1100 * The type of the Identity Mapper being created. 1101 * @param d 1102 * The definition of the Identity Mapper to be created. 1103 * @param name 1104 * The name of the new Identity Mapper. 1105 * @param exceptions 1106 * An optional collection in which to place any {@link 1107 * PropertyException}s that occurred whilst attempting to 1108 * determine the default values of the Identity Mapper. This 1109 * argument can be <code>null<code>. 1110 * @return Returns a new Identity Mapper configuration instance. 1111 * @throws IllegalManagedObjectNameException 1112 * If the name of the new Identity Mapper is invalid. 1113 */ 1114 <C extends IdentityMapperCfgClient> C createIdentityMapper( 1115 ManagedObjectDefinition<C, ? extends IdentityMapperCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1116 1117 1118 1119 /** 1120 * Removes the named Identity Mapper. 1121 * 1122 * @param name 1123 * The name of the Identity Mapper to remove. 1124 * @throws ManagedObjectNotFoundException 1125 * If the Identity Mapper does not exist. 1126 * @throws OperationRejectedException 1127 * If the server refuses to remove the Identity Mapper due 1128 * to some server-side constraint which cannot be satisfied 1129 * (for example, if it is referenced by another managed 1130 * object). 1131 * @throws ConcurrentModificationException 1132 * If this Root has been removed from the server by 1133 * another client. 1134 * @throws LdapException 1135 * If any other error occurs. 1136 */ 1137 void removeIdentityMapper(String name) 1138 throws ManagedObjectNotFoundException, OperationRejectedException, 1139 ConcurrentModificationException, LdapException; 1140 1141 1142 1143 /** 1144 * Lists the Key Manager Providers. 1145 * 1146 * @return Returns an array containing the names of the Key Manager 1147 * Providers. 1148 * @throws ConcurrentModificationException 1149 * If this Root has been removed from the server by 1150 * another client. 1151 * @throws LdapException 1152 * If any other error occurs. 1153 */ 1154 String[] listKeyManagerProviders() throws ConcurrentModificationException, 1155 LdapException; 1156 1157 1158 1159 /** 1160 * Gets the named Key Manager Provider. 1161 * 1162 * @param name 1163 * The name of the Key Manager Provider to retrieve. 1164 * @return Returns the named Key Manager Provider. 1165 * @throws DefinitionDecodingException 1166 * If the named Key Manager Provider was found but its 1167 * type could not be determined. 1168 * @throws ManagedObjectDecodingException 1169 * If the named Key Manager Provider was found but one or 1170 * more of its properties could not be decoded. 1171 * @throws ManagedObjectNotFoundException 1172 * If the named Key Manager Provider was not found on the 1173 * server. 1174 * @throws ConcurrentModificationException 1175 * If this Root has been removed from the server by 1176 * another client. 1177 * @throws LdapException 1178 * If any other error occurs. 1179 */ 1180 KeyManagerProviderCfgClient getKeyManagerProvider(String name) 1181 throws DefinitionDecodingException, ManagedObjectDecodingException, 1182 ManagedObjectNotFoundException, ConcurrentModificationException, 1183 LdapException; 1184 1185 1186 1187 /** 1188 * Creates a new Key Manager Provider. The new Key Manager Provider 1189 * will initially not contain any property values (including 1190 * mandatory properties). Once the Key Manager Provider has been 1191 * configured it can be added to the server using the {@link 1192 * #commit()} method. 1193 * 1194 * @param <C> 1195 * The type of the Key Manager Provider being created. 1196 * @param d 1197 * The definition of the Key Manager Provider to be 1198 * created. 1199 * @param name 1200 * The name of the new Key Manager Provider. 1201 * @param exceptions 1202 * An optional collection in which to place any {@link 1203 * PropertyException}s that occurred whilst attempting to 1204 * determine the default values of the Key Manager Provider. 1205 * This argument can be <code>null<code>. 1206 * @return Returns a new Key Manager Provider configuration 1207 * instance. 1208 * @throws IllegalManagedObjectNameException 1209 * If the name of the new Key Manager Provider is invalid. 1210 */ 1211 <C extends KeyManagerProviderCfgClient> C createKeyManagerProvider( 1212 ManagedObjectDefinition<C, ? extends KeyManagerProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1213 1214 1215 1216 /** 1217 * Removes the named Key Manager Provider. 1218 * 1219 * @param name 1220 * The name of the Key Manager Provider to remove. 1221 * @throws ManagedObjectNotFoundException 1222 * If the Key Manager Provider does not exist. 1223 * @throws OperationRejectedException 1224 * If the server refuses to remove the Key Manager 1225 * Provider due to some server-side constraint which cannot 1226 * be satisfied (for example, if it is referenced by 1227 * another managed object). 1228 * @throws ConcurrentModificationException 1229 * If this Root has been removed from the server by 1230 * another client. 1231 * @throws LdapException 1232 * If any other error occurs. 1233 */ 1234 void removeKeyManagerProvider(String name) 1235 throws ManagedObjectNotFoundException, OperationRejectedException, 1236 ConcurrentModificationException, LdapException; 1237 1238 1239 1240 /** 1241 * Lists the Log Publishers. 1242 * 1243 * @return Returns an array containing the names of the Log 1244 * Publishers. 1245 * @throws ConcurrentModificationException 1246 * If this Root has been removed from the server by 1247 * another client. 1248 * @throws LdapException 1249 * If any other error occurs. 1250 */ 1251 String[] listLogPublishers() throws ConcurrentModificationException, 1252 LdapException; 1253 1254 1255 1256 /** 1257 * Gets the named Log Publisher. 1258 * 1259 * @param name 1260 * The name of the Log Publisher to retrieve. 1261 * @return Returns the named Log Publisher. 1262 * @throws DefinitionDecodingException 1263 * If the named Log Publisher was found but its type could 1264 * not be determined. 1265 * @throws ManagedObjectDecodingException 1266 * If the named Log Publisher was found but one or more of 1267 * its properties could not be decoded. 1268 * @throws ManagedObjectNotFoundException 1269 * If the named Log Publisher was not found on the server. 1270 * @throws ConcurrentModificationException 1271 * If this Root has been removed from the server by 1272 * another client. 1273 * @throws LdapException 1274 * If any other error occurs. 1275 */ 1276 LogPublisherCfgClient getLogPublisher(String name) 1277 throws DefinitionDecodingException, ManagedObjectDecodingException, 1278 ManagedObjectNotFoundException, ConcurrentModificationException, 1279 LdapException; 1280 1281 1282 1283 /** 1284 * Creates a new Log Publisher. The new Log Publisher will initially 1285 * not contain any property values (including mandatory properties). 1286 * Once the Log Publisher has been configured it can be added to the 1287 * server using the {@link #commit()} method. 1288 * 1289 * @param <C> 1290 * The type of the Log Publisher being created. 1291 * @param d 1292 * The definition of the Log Publisher to be created. 1293 * @param name 1294 * The name of the new Log Publisher. 1295 * @param exceptions 1296 * An optional collection in which to place any {@link 1297 * PropertyException}s that occurred whilst attempting to 1298 * determine the default values of the Log Publisher. This 1299 * argument can be <code>null<code>. 1300 * @return Returns a new Log Publisher configuration instance. 1301 * @throws IllegalManagedObjectNameException 1302 * If the name of the new Log Publisher is invalid. 1303 */ 1304 <C extends LogPublisherCfgClient> C createLogPublisher( 1305 ManagedObjectDefinition<C, ? extends LogPublisherCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1306 1307 1308 1309 /** 1310 * Removes the named Log Publisher. 1311 * 1312 * @param name 1313 * The name of the Log Publisher to remove. 1314 * @throws ManagedObjectNotFoundException 1315 * If the Log Publisher does not exist. 1316 * @throws OperationRejectedException 1317 * If the server refuses to remove the Log Publisher due 1318 * to some server-side constraint which cannot be satisfied 1319 * (for example, if it is referenced by another managed 1320 * object). 1321 * @throws ConcurrentModificationException 1322 * If this Root has been removed from the server by 1323 * another client. 1324 * @throws LdapException 1325 * If any other error occurs. 1326 */ 1327 void removeLogPublisher(String name) 1328 throws ManagedObjectNotFoundException, OperationRejectedException, 1329 ConcurrentModificationException, LdapException; 1330 1331 1332 1333 /** 1334 * Lists the Log Retention Policies. 1335 * 1336 * @return Returns an array containing the names of the Log 1337 * Retention Policies. 1338 * @throws ConcurrentModificationException 1339 * If this Root has been removed from the server by 1340 * another client. 1341 * @throws LdapException 1342 * If any other error occurs. 1343 */ 1344 String[] listLogRetentionPolicies() throws ConcurrentModificationException, 1345 LdapException; 1346 1347 1348 1349 /** 1350 * Gets the named Log Retention Policy. 1351 * 1352 * @param name 1353 * The name of the Log Retention Policy to retrieve. 1354 * @return Returns the named Log Retention Policy. 1355 * @throws DefinitionDecodingException 1356 * If the named Log Retention Policy was found but its 1357 * type could not be determined. 1358 * @throws ManagedObjectDecodingException 1359 * If the named Log Retention Policy was found but one or 1360 * more of its properties could not be decoded. 1361 * @throws ManagedObjectNotFoundException 1362 * If the named Log Retention Policy was not found on the 1363 * server. 1364 * @throws ConcurrentModificationException 1365 * If this Root has been removed from the server by 1366 * another client. 1367 * @throws LdapException 1368 * If any other error occurs. 1369 */ 1370 LogRetentionPolicyCfgClient getLogRetentionPolicy(String name) 1371 throws DefinitionDecodingException, ManagedObjectDecodingException, 1372 ManagedObjectNotFoundException, ConcurrentModificationException, 1373 LdapException; 1374 1375 1376 1377 /** 1378 * Creates a new Log Retention Policy. The new Log Retention Policy 1379 * will initially not contain any property values (including 1380 * mandatory properties). Once the Log Retention Policy has been 1381 * configured it can be added to the server using the {@link 1382 * #commit()} method. 1383 * 1384 * @param <C> 1385 * The type of the Log Retention Policy being created. 1386 * @param d 1387 * The definition of the Log Retention Policy to be 1388 * created. 1389 * @param name 1390 * The name of the new Log Retention Policy. 1391 * @param exceptions 1392 * An optional collection in which to place any {@link 1393 * PropertyException}s that occurred whilst attempting to 1394 * determine the default values of the Log Retention Policy. 1395 * This argument can be <code>null<code>. 1396 * @return Returns a new Log Retention Policy configuration 1397 * instance. 1398 * @throws IllegalManagedObjectNameException 1399 * If the name of the new Log Retention Policy is invalid. 1400 */ 1401 <C extends LogRetentionPolicyCfgClient> C createLogRetentionPolicy( 1402 ManagedObjectDefinition<C, ? extends LogRetentionPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1403 1404 1405 1406 /** 1407 * Removes the named Log Retention Policy. 1408 * 1409 * @param name 1410 * The name of the Log Retention Policy to remove. 1411 * @throws ManagedObjectNotFoundException 1412 * If the Log Retention Policy does not exist. 1413 * @throws OperationRejectedException 1414 * If the server refuses to remove the Log Retention 1415 * Policy due to some server-side constraint which cannot 1416 * be satisfied (for example, if it is referenced by 1417 * another managed object). 1418 * @throws ConcurrentModificationException 1419 * If this Root has been removed from the server by 1420 * another client. 1421 * @throws LdapException 1422 * If any other error occurs. 1423 */ 1424 void removeLogRetentionPolicy(String name) 1425 throws ManagedObjectNotFoundException, OperationRejectedException, 1426 ConcurrentModificationException, LdapException; 1427 1428 1429 1430 /** 1431 * Lists the Log Rotation Policies. 1432 * 1433 * @return Returns an array containing the names of the Log Rotation 1434 * Policies. 1435 * @throws ConcurrentModificationException 1436 * If this Root has been removed from the server by 1437 * another client. 1438 * @throws LdapException 1439 * If any other error occurs. 1440 */ 1441 String[] listLogRotationPolicies() throws ConcurrentModificationException, 1442 LdapException; 1443 1444 1445 1446 /** 1447 * Gets the named Log Rotation Policy. 1448 * 1449 * @param name 1450 * The name of the Log Rotation Policy to retrieve. 1451 * @return Returns the named Log Rotation Policy. 1452 * @throws DefinitionDecodingException 1453 * If the named Log Rotation Policy was found but its type 1454 * could not be determined. 1455 * @throws ManagedObjectDecodingException 1456 * If the named Log Rotation Policy was found but one or 1457 * more of its properties could not be decoded. 1458 * @throws ManagedObjectNotFoundException 1459 * If the named Log Rotation Policy was not found on the 1460 * server. 1461 * @throws ConcurrentModificationException 1462 * If this Root has been removed from the server by 1463 * another client. 1464 * @throws LdapException 1465 * If any other error occurs. 1466 */ 1467 LogRotationPolicyCfgClient getLogRotationPolicy(String name) 1468 throws DefinitionDecodingException, ManagedObjectDecodingException, 1469 ManagedObjectNotFoundException, ConcurrentModificationException, 1470 LdapException; 1471 1472 1473 1474 /** 1475 * Creates a new Log Rotation Policy. The new Log Rotation Policy 1476 * will initially not contain any property values (including 1477 * mandatory properties). Once the Log Rotation Policy has been 1478 * configured it can be added to the server using the {@link 1479 * #commit()} method. 1480 * 1481 * @param <C> 1482 * The type of the Log Rotation Policy being created. 1483 * @param d 1484 * The definition of the Log Rotation Policy to be created. 1485 * @param name 1486 * The name of the new Log Rotation Policy. 1487 * @param exceptions 1488 * An optional collection in which to place any {@link 1489 * PropertyException}s that occurred whilst attempting to 1490 * determine the default values of the Log Rotation Policy. 1491 * This argument can be <code>null<code>. 1492 * @return Returns a new Log Rotation Policy configuration instance. 1493 * @throws IllegalManagedObjectNameException 1494 * If the name of the new Log Rotation Policy is invalid. 1495 */ 1496 <C extends LogRotationPolicyCfgClient> C createLogRotationPolicy( 1497 ManagedObjectDefinition<C, ? extends LogRotationPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1498 1499 1500 1501 /** 1502 * Removes the named Log Rotation Policy. 1503 * 1504 * @param name 1505 * The name of the Log Rotation Policy to remove. 1506 * @throws ManagedObjectNotFoundException 1507 * If the Log Rotation Policy does not exist. 1508 * @throws OperationRejectedException 1509 * If the server refuses to remove the Log Rotation Policy 1510 * due to some server-side constraint which cannot be 1511 * satisfied (for example, if it is referenced by another 1512 * managed object). 1513 * @throws ConcurrentModificationException 1514 * If this Root has been removed from the server by 1515 * another client. 1516 * @throws LdapException 1517 * If any other error occurs. 1518 */ 1519 void removeLogRotationPolicy(String name) 1520 throws ManagedObjectNotFoundException, OperationRejectedException, 1521 ConcurrentModificationException, LdapException; 1522 1523 1524 1525 /** 1526 * Lists the Matching Rules. 1527 * 1528 * @return Returns an array containing the names of the Matching 1529 * Rules. 1530 * @throws ConcurrentModificationException 1531 * If this Root has been removed from the server by 1532 * another client. 1533 * @throws LdapException 1534 * If any other error occurs. 1535 */ 1536 String[] listMatchingRules() throws ConcurrentModificationException, 1537 LdapException; 1538 1539 1540 1541 /** 1542 * Gets the named Matching Rule. 1543 * 1544 * @param name 1545 * The name of the Matching Rule to retrieve. 1546 * @return Returns the named Matching Rule. 1547 * @throws DefinitionDecodingException 1548 * If the named Matching Rule was found but its type could 1549 * not be determined. 1550 * @throws ManagedObjectDecodingException 1551 * If the named Matching Rule was found but one or more of 1552 * its properties could not be decoded. 1553 * @throws ManagedObjectNotFoundException 1554 * If the named Matching Rule was not found on the server. 1555 * @throws ConcurrentModificationException 1556 * If this Root has been removed from the server by 1557 * another client. 1558 * @throws LdapException 1559 * If any other error occurs. 1560 */ 1561 MatchingRuleCfgClient getMatchingRule(String name) 1562 throws DefinitionDecodingException, ManagedObjectDecodingException, 1563 ManagedObjectNotFoundException, ConcurrentModificationException, 1564 LdapException; 1565 1566 1567 1568 /** 1569 * Creates a new Matching Rule. The new Matching Rule will initially 1570 * not contain any property values (including mandatory properties). 1571 * Once the Matching Rule has been configured it can be added to the 1572 * server using the {@link #commit()} method. 1573 * 1574 * @param <C> 1575 * The type of the Matching Rule being created. 1576 * @param d 1577 * The definition of the Matching Rule to be created. 1578 * @param name 1579 * The name of the new Matching Rule. 1580 * @param exceptions 1581 * An optional collection in which to place any {@link 1582 * PropertyException}s that occurred whilst attempting to 1583 * determine the default values of the Matching Rule. This 1584 * argument can be <code>null<code>. 1585 * @return Returns a new Matching Rule configuration instance. 1586 * @throws IllegalManagedObjectNameException 1587 * If the name of the new Matching Rule is invalid. 1588 */ 1589 <C extends MatchingRuleCfgClient> C createMatchingRule( 1590 ManagedObjectDefinition<C, ? extends MatchingRuleCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1591 1592 1593 1594 /** 1595 * Removes the named Matching Rule. 1596 * 1597 * @param name 1598 * The name of the Matching Rule to remove. 1599 * @throws ManagedObjectNotFoundException 1600 * If the Matching Rule does not exist. 1601 * @throws OperationRejectedException 1602 * If the server refuses to remove the Matching Rule due 1603 * to some server-side constraint which cannot be satisfied 1604 * (for example, if it is referenced by another managed 1605 * object). 1606 * @throws ConcurrentModificationException 1607 * If this Root has been removed from the server by 1608 * another client. 1609 * @throws LdapException 1610 * If any other error occurs. 1611 */ 1612 void removeMatchingRule(String name) 1613 throws ManagedObjectNotFoundException, OperationRejectedException, 1614 ConcurrentModificationException, LdapException; 1615 1616 1617 1618 /** 1619 * Lists the Monitor Providers. 1620 * 1621 * @return Returns an array containing the names of the Monitor 1622 * Providers. 1623 * @throws ConcurrentModificationException 1624 * If this Root has been removed from the server by 1625 * another client. 1626 * @throws LdapException 1627 * If any other error occurs. 1628 */ 1629 String[] listMonitorProviders() throws ConcurrentModificationException, 1630 LdapException; 1631 1632 1633 1634 /** 1635 * Gets the named Monitor Provider. 1636 * 1637 * @param name 1638 * The name of the Monitor Provider to retrieve. 1639 * @return Returns the named Monitor Provider. 1640 * @throws DefinitionDecodingException 1641 * If the named Monitor Provider was found but its type 1642 * could not be determined. 1643 * @throws ManagedObjectDecodingException 1644 * If the named Monitor Provider was found but one or more 1645 * of its properties could not be decoded. 1646 * @throws ManagedObjectNotFoundException 1647 * If the named Monitor Provider was not found on the 1648 * server. 1649 * @throws ConcurrentModificationException 1650 * If this Root has been removed from the server by 1651 * another client. 1652 * @throws LdapException 1653 * If any other error occurs. 1654 */ 1655 MonitorProviderCfgClient getMonitorProvider(String name) 1656 throws DefinitionDecodingException, ManagedObjectDecodingException, 1657 ManagedObjectNotFoundException, ConcurrentModificationException, 1658 LdapException; 1659 1660 1661 1662 /** 1663 * Creates a new Monitor Provider. The new Monitor Provider will 1664 * initially not contain any property values (including mandatory 1665 * properties). Once the Monitor Provider has been configured it can 1666 * be added to the server using the {@link #commit()} method. 1667 * 1668 * @param <C> 1669 * The type of the Monitor Provider being created. 1670 * @param d 1671 * The definition of the Monitor Provider to be created. 1672 * @param name 1673 * The name of the new Monitor Provider. 1674 * @param exceptions 1675 * An optional collection in which to place any {@link 1676 * PropertyException}s that occurred whilst attempting to 1677 * determine the default values of the Monitor Provider. 1678 * This argument can be <code>null<code>. 1679 * @return Returns a new Monitor Provider configuration instance. 1680 * @throws IllegalManagedObjectNameException 1681 * If the name of the new Monitor Provider is invalid. 1682 */ 1683 <C extends MonitorProviderCfgClient> C createMonitorProvider( 1684 ManagedObjectDefinition<C, ? extends MonitorProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1685 1686 1687 1688 /** 1689 * Removes the named Monitor Provider. 1690 * 1691 * @param name 1692 * The name of the Monitor Provider to remove. 1693 * @throws ManagedObjectNotFoundException 1694 * If the Monitor Provider does not exist. 1695 * @throws OperationRejectedException 1696 * If the server refuses to remove the Monitor Provider 1697 * due to some server-side constraint which cannot be 1698 * satisfied (for example, if it is referenced by another 1699 * managed object). 1700 * @throws ConcurrentModificationException 1701 * If this Root has been removed from the server by 1702 * another client. 1703 * @throws LdapException 1704 * If any other error occurs. 1705 */ 1706 void removeMonitorProvider(String name) 1707 throws ManagedObjectNotFoundException, OperationRejectedException, 1708 ConcurrentModificationException, LdapException; 1709 1710 1711 1712 /** 1713 * Lists the Password Generators. 1714 * 1715 * @return Returns an array containing the names of the Password 1716 * Generators. 1717 * @throws ConcurrentModificationException 1718 * If this Root has been removed from the server by 1719 * another client. 1720 * @throws LdapException 1721 * If any other error occurs. 1722 */ 1723 String[] listPasswordGenerators() throws ConcurrentModificationException, 1724 LdapException; 1725 1726 1727 1728 /** 1729 * Gets the named Password Generator. 1730 * 1731 * @param name 1732 * The name of the Password Generator to retrieve. 1733 * @return Returns the named Password Generator. 1734 * @throws DefinitionDecodingException 1735 * If the named Password Generator was found but its type 1736 * could not be determined. 1737 * @throws ManagedObjectDecodingException 1738 * If the named Password Generator was found but one or 1739 * more of its properties could not be decoded. 1740 * @throws ManagedObjectNotFoundException 1741 * If the named Password Generator was not found on the 1742 * server. 1743 * @throws ConcurrentModificationException 1744 * If this Root has been removed from the server by 1745 * another client. 1746 * @throws LdapException 1747 * If any other error occurs. 1748 */ 1749 PasswordGeneratorCfgClient getPasswordGenerator(String name) 1750 throws DefinitionDecodingException, ManagedObjectDecodingException, 1751 ManagedObjectNotFoundException, ConcurrentModificationException, 1752 LdapException; 1753 1754 1755 1756 /** 1757 * Creates a new Password Generator. The new Password Generator will 1758 * initially not contain any property values (including mandatory 1759 * properties). Once the Password Generator has been configured it 1760 * can be added to the server using the {@link #commit()} method. 1761 * 1762 * @param <C> 1763 * The type of the Password Generator being created. 1764 * @param d 1765 * The definition of the Password Generator to be created. 1766 * @param name 1767 * The name of the new Password Generator. 1768 * @param exceptions 1769 * An optional collection in which to place any {@link 1770 * PropertyException}s that occurred whilst attempting to 1771 * determine the default values of the Password Generator. 1772 * This argument can be <code>null<code>. 1773 * @return Returns a new Password Generator configuration instance. 1774 * @throws IllegalManagedObjectNameException 1775 * If the name of the new Password Generator is invalid. 1776 */ 1777 <C extends PasswordGeneratorCfgClient> C createPasswordGenerator( 1778 ManagedObjectDefinition<C, ? extends PasswordGeneratorCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1779 1780 1781 1782 /** 1783 * Removes the named Password Generator. 1784 * 1785 * @param name 1786 * The name of the Password Generator to remove. 1787 * @throws ManagedObjectNotFoundException 1788 * If the Password Generator does not exist. 1789 * @throws OperationRejectedException 1790 * If the server refuses to remove the Password Generator 1791 * due to some server-side constraint which cannot be 1792 * satisfied (for example, if it is referenced by another 1793 * managed object). 1794 * @throws ConcurrentModificationException 1795 * If this Root has been removed from the server by 1796 * another client. 1797 * @throws LdapException 1798 * If any other error occurs. 1799 */ 1800 void removePasswordGenerator(String name) 1801 throws ManagedObjectNotFoundException, OperationRejectedException, 1802 ConcurrentModificationException, LdapException; 1803 1804 1805 1806 /** 1807 * Lists the Password Policies. 1808 * 1809 * @return Returns an array containing the names of the Password 1810 * Policies. 1811 * @throws ConcurrentModificationException 1812 * If this Root has been removed from the server by 1813 * another client. 1814 * @throws LdapException 1815 * If any other error occurs. 1816 */ 1817 String[] listPasswordPolicies() throws ConcurrentModificationException, 1818 LdapException; 1819 1820 1821 1822 /** 1823 * Gets the named Password Policy. 1824 * 1825 * @param name 1826 * The name of the Password Policy to retrieve. 1827 * @return Returns the named Password Policy. 1828 * @throws DefinitionDecodingException 1829 * If the named Password Policy was found but its type 1830 * could not be determined. 1831 * @throws ManagedObjectDecodingException 1832 * If the named Password Policy was found but one or more 1833 * of its properties could not be decoded. 1834 * @throws ManagedObjectNotFoundException 1835 * If the named Password Policy was not found on the 1836 * server. 1837 * @throws ConcurrentModificationException 1838 * If this Root has been removed from the server by 1839 * another client. 1840 * @throws LdapException 1841 * If any other error occurs. 1842 */ 1843 AuthenticationPolicyCfgClient getPasswordPolicy(String name) 1844 throws DefinitionDecodingException, ManagedObjectDecodingException, 1845 ManagedObjectNotFoundException, ConcurrentModificationException, 1846 LdapException; 1847 1848 1849 1850 /** 1851 * Creates a new Password Policy. The new Password Policy will 1852 * initially not contain any property values (including mandatory 1853 * properties). Once the Password Policy has been configured it can 1854 * be added to the server using the {@link #commit()} method. 1855 * 1856 * @param <C> 1857 * The type of the Password Policy being created. 1858 * @param d 1859 * The definition of the Password Policy to be created. 1860 * @param name 1861 * The name of the new Password Policy. 1862 * @param exceptions 1863 * An optional collection in which to place any {@link 1864 * PropertyException}s that occurred whilst attempting to 1865 * determine the default values of the Password Policy. This 1866 * argument can be <code>null<code>. 1867 * @return Returns a new Password Policy configuration instance. 1868 * @throws IllegalManagedObjectNameException 1869 * If the name of the new Password Policy is invalid. 1870 */ 1871 <C extends AuthenticationPolicyCfgClient> C createPasswordPolicy( 1872 ManagedObjectDefinition<C, ? extends AuthenticationPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1873 1874 1875 1876 /** 1877 * Removes the named Password Policy. 1878 * 1879 * @param name 1880 * The name of the Password Policy to remove. 1881 * @throws ManagedObjectNotFoundException 1882 * If the Password Policy does not exist. 1883 * @throws OperationRejectedException 1884 * If the server refuses to remove the Password Policy due 1885 * to some server-side constraint which cannot be satisfied 1886 * (for example, if it is referenced by another managed 1887 * object). 1888 * @throws ConcurrentModificationException 1889 * If this Root has been removed from the server by 1890 * another client. 1891 * @throws LdapException 1892 * If any other error occurs. 1893 */ 1894 void removePasswordPolicy(String name) 1895 throws ManagedObjectNotFoundException, OperationRejectedException, 1896 ConcurrentModificationException, LdapException; 1897 1898 1899 1900 /** 1901 * Lists the Password Storage Schemes. 1902 * 1903 * @return Returns an array containing the names of the Password 1904 * Storage Schemes. 1905 * @throws ConcurrentModificationException 1906 * If this Root has been removed from the server by 1907 * another client. 1908 * @throws LdapException 1909 * If any other error occurs. 1910 */ 1911 String[] listPasswordStorageSchemes() throws ConcurrentModificationException, 1912 LdapException; 1913 1914 1915 1916 /** 1917 * Gets the named Password Storage Scheme. 1918 * 1919 * @param name 1920 * The name of the Password Storage Scheme to retrieve. 1921 * @return Returns the named Password Storage Scheme. 1922 * @throws DefinitionDecodingException 1923 * If the named Password Storage Scheme was found but its 1924 * type could not be determined. 1925 * @throws ManagedObjectDecodingException 1926 * If the named Password Storage Scheme was found but one 1927 * or more of its properties could not be decoded. 1928 * @throws ManagedObjectNotFoundException 1929 * If the named Password Storage Scheme was not found on 1930 * the server. 1931 * @throws ConcurrentModificationException 1932 * If this Root has been removed from the server by 1933 * another client. 1934 * @throws LdapException 1935 * If any other error occurs. 1936 */ 1937 PasswordStorageSchemeCfgClient getPasswordStorageScheme(String name) 1938 throws DefinitionDecodingException, ManagedObjectDecodingException, 1939 ManagedObjectNotFoundException, ConcurrentModificationException, 1940 LdapException; 1941 1942 1943 1944 /** 1945 * Creates a new Password Storage Scheme. The new Password Storage 1946 * Scheme will initially not contain any property values (including 1947 * mandatory properties). Once the Password Storage Scheme has been 1948 * configured it can be added to the server using the {@link 1949 * #commit()} method. 1950 * 1951 * @param <C> 1952 * The type of the Password Storage Scheme being created. 1953 * @param d 1954 * The definition of the Password Storage Scheme to be 1955 * created. 1956 * @param name 1957 * The name of the new Password Storage Scheme. 1958 * @param exceptions 1959 * An optional collection in which to place any {@link 1960 * PropertyException}s that occurred whilst attempting to 1961 * determine the default values of the Password Storage 1962 * Scheme. This argument can be <code>null<code>. 1963 * @return Returns a new Password Storage Scheme configuration 1964 * instance. 1965 * @throws IllegalManagedObjectNameException 1966 * If the name of the new Password Storage Scheme is 1967 * invalid. 1968 */ 1969 <C extends PasswordStorageSchemeCfgClient> C createPasswordStorageScheme( 1970 ManagedObjectDefinition<C, ? extends PasswordStorageSchemeCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1971 1972 1973 1974 /** 1975 * Removes the named Password Storage Scheme. 1976 * 1977 * @param name 1978 * The name of the Password Storage Scheme to remove. 1979 * @throws ManagedObjectNotFoundException 1980 * If the Password Storage Scheme does not exist. 1981 * @throws OperationRejectedException 1982 * If the server refuses to remove the Password Storage 1983 * Scheme due to some server-side constraint which cannot 1984 * be satisfied (for example, if it is referenced by 1985 * another managed object). 1986 * @throws ConcurrentModificationException 1987 * If this Root has been removed from the server by 1988 * another client. 1989 * @throws LdapException 1990 * If any other error occurs. 1991 */ 1992 void removePasswordStorageScheme(String name) 1993 throws ManagedObjectNotFoundException, OperationRejectedException, 1994 ConcurrentModificationException, LdapException; 1995 1996 1997 1998 /** 1999 * Lists the Password Validators. 2000 * 2001 * @return Returns an array containing the names of the Password 2002 * Validators. 2003 * @throws ConcurrentModificationException 2004 * If this Root has been removed from the server by 2005 * another client. 2006 * @throws LdapException 2007 * If any other error occurs. 2008 */ 2009 String[] listPasswordValidators() throws ConcurrentModificationException, 2010 LdapException; 2011 2012 2013 2014 /** 2015 * Gets the named Password Validator. 2016 * 2017 * @param name 2018 * The name of the Password Validator to retrieve. 2019 * @return Returns the named Password Validator. 2020 * @throws DefinitionDecodingException 2021 * If the named Password Validator was found but its type 2022 * could not be determined. 2023 * @throws ManagedObjectDecodingException 2024 * If the named Password Validator was found but one or 2025 * more of its properties could not be decoded. 2026 * @throws ManagedObjectNotFoundException 2027 * If the named Password Validator was not found on the 2028 * server. 2029 * @throws ConcurrentModificationException 2030 * If this Root has been removed from the server by 2031 * another client. 2032 * @throws LdapException 2033 * If any other error occurs. 2034 */ 2035 PasswordValidatorCfgClient getPasswordValidator(String name) 2036 throws DefinitionDecodingException, ManagedObjectDecodingException, 2037 ManagedObjectNotFoundException, ConcurrentModificationException, 2038 LdapException; 2039 2040 2041 2042 /** 2043 * Creates a new Password Validator. The new Password Validator will 2044 * initially not contain any property values (including mandatory 2045 * properties). Once the Password Validator has been configured it 2046 * can be added to the server using the {@link #commit()} method. 2047 * 2048 * @param <C> 2049 * The type of the Password Validator being created. 2050 * @param d 2051 * The definition of the Password Validator to be created. 2052 * @param name 2053 * The name of the new Password Validator. 2054 * @param exceptions 2055 * An optional collection in which to place any {@link 2056 * PropertyException}s that occurred whilst attempting to 2057 * determine the default values of the Password Validator. 2058 * This argument can be <code>null<code>. 2059 * @return Returns a new Password Validator configuration instance. 2060 * @throws IllegalManagedObjectNameException 2061 * If the name of the new Password Validator is invalid. 2062 */ 2063 <C extends PasswordValidatorCfgClient> C createPasswordValidator( 2064 ManagedObjectDefinition<C, ? extends PasswordValidatorCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2065 2066 2067 2068 /** 2069 * Removes the named Password Validator. 2070 * 2071 * @param name 2072 * The name of the Password Validator to remove. 2073 * @throws ManagedObjectNotFoundException 2074 * If the Password Validator does not exist. 2075 * @throws OperationRejectedException 2076 * If the server refuses to remove the Password Validator 2077 * due to some server-side constraint which cannot be 2078 * satisfied (for example, if it is referenced by another 2079 * managed object). 2080 * @throws ConcurrentModificationException 2081 * If this Root has been removed from the server by 2082 * another client. 2083 * @throws LdapException 2084 * If any other error occurs. 2085 */ 2086 void removePasswordValidator(String name) 2087 throws ManagedObjectNotFoundException, OperationRejectedException, 2088 ConcurrentModificationException, LdapException; 2089 2090 2091 2092 /** 2093 * Gets the Plugin Root. 2094 * 2095 * @return Returns the Plugin Root. 2096 * @throws DefinitionDecodingException 2097 * If the Plugin Root was found but its type could not be 2098 * determined. 2099 * @throws ManagedObjectDecodingException 2100 * If the Plugin Root was found but one or more of its 2101 * properties could not be decoded. 2102 * @throws ManagedObjectNotFoundException 2103 * If the Plugin Root could not be found on the server. 2104 * @throws ConcurrentModificationException 2105 * If this Root has been removed from the server by 2106 * another client. 2107 * @throws LdapException 2108 * If any other error occurs. 2109 */ 2110 PluginRootCfgClient getPluginRoot() 2111 throws DefinitionDecodingException, ManagedObjectDecodingException, 2112 ManagedObjectNotFoundException, ConcurrentModificationException, 2113 LdapException; 2114 2115 2116 2117 /** 2118 * Gets the Root DN. 2119 * 2120 * @return Returns the Root DN. 2121 * @throws DefinitionDecodingException 2122 * If the Root DN was found but its type could not be 2123 * determined. 2124 * @throws ManagedObjectDecodingException 2125 * If the Root DN was found but one or more of its 2126 * properties could not be decoded. 2127 * @throws ManagedObjectNotFoundException 2128 * If the Root DN could not be found on the server. 2129 * @throws ConcurrentModificationException 2130 * If this Root has been removed from the server by 2131 * another client. 2132 * @throws LdapException 2133 * If any other error occurs. 2134 */ 2135 RootDNCfgClient getRootDN() 2136 throws DefinitionDecodingException, ManagedObjectDecodingException, 2137 ManagedObjectNotFoundException, ConcurrentModificationException, 2138 LdapException; 2139 2140 2141 2142 /** 2143 * Gets the Root DSE Backend. 2144 * 2145 * @return Returns the Root DSE Backend. 2146 * @throws DefinitionDecodingException 2147 * If the Root DSE Backend was found but its type could 2148 * not be determined. 2149 * @throws ManagedObjectDecodingException 2150 * If the Root DSE Backend was found but one or more of 2151 * its properties could not be decoded. 2152 * @throws ManagedObjectNotFoundException 2153 * If the Root DSE Backend could not be found on the 2154 * server. 2155 * @throws ConcurrentModificationException 2156 * If this Root has been removed from the server by 2157 * another client. 2158 * @throws LdapException 2159 * If any other error occurs. 2160 */ 2161 RootDSEBackendCfgClient getRootDSEBackend() 2162 throws DefinitionDecodingException, ManagedObjectDecodingException, 2163 ManagedObjectNotFoundException, ConcurrentModificationException, 2164 LdapException; 2165 2166 2167 2168 /** 2169 * Lists the SASL Mechanism Handlers. 2170 * 2171 * @return Returns an array containing the names of the SASL 2172 * Mechanism Handlers. 2173 * @throws ConcurrentModificationException 2174 * If this Root has been removed from the server by 2175 * another client. 2176 * @throws LdapException 2177 * If any other error occurs. 2178 */ 2179 String[] listSASLMechanismHandlers() throws ConcurrentModificationException, 2180 LdapException; 2181 2182 2183 2184 /** 2185 * Gets the named SASL Mechanism Handler. 2186 * 2187 * @param name 2188 * The name of the SASL Mechanism Handler to retrieve. 2189 * @return Returns the named SASL Mechanism Handler. 2190 * @throws DefinitionDecodingException 2191 * If the named SASL Mechanism Handler was found but its 2192 * type could not be determined. 2193 * @throws ManagedObjectDecodingException 2194 * If the named SASL Mechanism Handler was found but one 2195 * or more of its properties could not be decoded. 2196 * @throws ManagedObjectNotFoundException 2197 * If the named SASL Mechanism Handler was not found on 2198 * the server. 2199 * @throws ConcurrentModificationException 2200 * If this Root has been removed from the server by 2201 * another client. 2202 * @throws LdapException 2203 * If any other error occurs. 2204 */ 2205 SASLMechanismHandlerCfgClient getSASLMechanismHandler(String name) 2206 throws DefinitionDecodingException, ManagedObjectDecodingException, 2207 ManagedObjectNotFoundException, ConcurrentModificationException, 2208 LdapException; 2209 2210 2211 2212 /** 2213 * Creates a new SASL Mechanism Handler. The new SASL Mechanism 2214 * Handler will initially not contain any property values (including 2215 * mandatory properties). Once the SASL Mechanism Handler has been 2216 * configured it can be added to the server using the {@link 2217 * #commit()} method. 2218 * 2219 * @param <C> 2220 * The type of the SASL Mechanism Handler being created. 2221 * @param d 2222 * The definition of the SASL Mechanism Handler to be 2223 * created. 2224 * @param name 2225 * The name of the new SASL Mechanism Handler. 2226 * @param exceptions 2227 * An optional collection in which to place any {@link 2228 * PropertyException}s that occurred whilst attempting to 2229 * determine the default values of the SASL Mechanism 2230 * Handler. This argument can be <code>null<code>. 2231 * @return Returns a new SASL Mechanism Handler configuration 2232 * instance. 2233 * @throws IllegalManagedObjectNameException 2234 * If the name of the new SASL Mechanism Handler is 2235 * invalid. 2236 */ 2237 <C extends SASLMechanismHandlerCfgClient> C createSASLMechanismHandler( 2238 ManagedObjectDefinition<C, ? extends SASLMechanismHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2239 2240 2241 2242 /** 2243 * Removes the named SASL Mechanism Handler. 2244 * 2245 * @param name 2246 * The name of the SASL Mechanism Handler to remove. 2247 * @throws ManagedObjectNotFoundException 2248 * If the SASL Mechanism Handler does not exist. 2249 * @throws OperationRejectedException 2250 * If the server refuses to remove the SASL Mechanism 2251 * Handler due to some server-side constraint which cannot 2252 * be satisfied (for example, if it is referenced by 2253 * another managed object). 2254 * @throws ConcurrentModificationException 2255 * If this Root has been removed from the server by 2256 * another client. 2257 * @throws LdapException 2258 * If any other error occurs. 2259 */ 2260 void removeSASLMechanismHandler(String name) 2261 throws ManagedObjectNotFoundException, OperationRejectedException, 2262 ConcurrentModificationException, LdapException; 2263 2264 2265 2266 /** 2267 * Lists the Schema Providers. 2268 * 2269 * @return Returns an array containing the names of the Schema 2270 * Providers. 2271 * @throws ConcurrentModificationException 2272 * If this Root has been removed from the server by 2273 * another client. 2274 * @throws LdapException 2275 * If any other error occurs. 2276 */ 2277 String[] listSchemaProviders() throws ConcurrentModificationException, 2278 LdapException; 2279 2280 2281 2282 /** 2283 * Gets the named Schema Provider. 2284 * 2285 * @param name 2286 * The name of the Schema Provider to retrieve. 2287 * @return Returns the named Schema Provider. 2288 * @throws DefinitionDecodingException 2289 * If the named Schema Provider was found but its type 2290 * could not be determined. 2291 * @throws ManagedObjectDecodingException 2292 * If the named Schema Provider was found but one or more 2293 * of its properties could not be decoded. 2294 * @throws ManagedObjectNotFoundException 2295 * If the named Schema Provider was not found on the 2296 * server. 2297 * @throws ConcurrentModificationException 2298 * If this Root has been removed from the server by 2299 * another client. 2300 * @throws LdapException 2301 * If any other error occurs. 2302 */ 2303 SchemaProviderCfgClient getSchemaProvider(String name) 2304 throws DefinitionDecodingException, ManagedObjectDecodingException, 2305 ManagedObjectNotFoundException, ConcurrentModificationException, 2306 LdapException; 2307 2308 2309 2310 /** 2311 * Creates a new Schema Provider. The new Schema Provider will 2312 * initially not contain any property values (including mandatory 2313 * properties). Once the Schema Provider has been configured it can 2314 * be added to the server using the {@link #commit()} method. 2315 * 2316 * @param <C> 2317 * The type of the Schema Provider being created. 2318 * @param d 2319 * The definition of the Schema Provider to be created. 2320 * @param name 2321 * The name of the new Schema Provider. 2322 * @param exceptions 2323 * An optional collection in which to place any {@link 2324 * PropertyException}s that occurred whilst attempting to 2325 * determine the default values of the Schema Provider. This 2326 * argument can be <code>null<code>. 2327 * @return Returns a new Schema Provider configuration instance. 2328 * @throws IllegalManagedObjectNameException 2329 * If the name of the new Schema Provider is invalid. 2330 */ 2331 <C extends SchemaProviderCfgClient> C createSchemaProvider( 2332 ManagedObjectDefinition<C, ? extends SchemaProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2333 2334 2335 2336 /** 2337 * Removes the named Schema Provider. 2338 * 2339 * @param name 2340 * The name of the Schema Provider to remove. 2341 * @throws ManagedObjectNotFoundException 2342 * If the Schema Provider does not exist. 2343 * @throws OperationRejectedException 2344 * If the server refuses to remove the Schema Provider due 2345 * to some server-side constraint which cannot be satisfied 2346 * (for example, if it is referenced by another managed 2347 * object). 2348 * @throws ConcurrentModificationException 2349 * If this Root has been removed from the server by 2350 * another client. 2351 * @throws LdapException 2352 * If any other error occurs. 2353 */ 2354 void removeSchemaProvider(String name) 2355 throws ManagedObjectNotFoundException, OperationRejectedException, 2356 ConcurrentModificationException, LdapException; 2357 2358 2359 2360 /** 2361 * Lists the Synchronization Providers. 2362 * 2363 * @return Returns an array containing the names of the 2364 * Synchronization Providers. 2365 * @throws ConcurrentModificationException 2366 * If this Root has been removed from the server by 2367 * another client. 2368 * @throws LdapException 2369 * If any other error occurs. 2370 */ 2371 String[] listSynchronizationProviders() throws ConcurrentModificationException, 2372 LdapException; 2373 2374 2375 2376 /** 2377 * Gets the named Synchronization Provider. 2378 * 2379 * @param name 2380 * The name of the Synchronization Provider to retrieve. 2381 * @return Returns the named Synchronization Provider. 2382 * @throws DefinitionDecodingException 2383 * If the named Synchronization Provider was found but its 2384 * type could not be determined. 2385 * @throws ManagedObjectDecodingException 2386 * If the named Synchronization Provider was found but one 2387 * or more of its properties could not be decoded. 2388 * @throws ManagedObjectNotFoundException 2389 * If the named Synchronization Provider was not found on 2390 * the server. 2391 * @throws ConcurrentModificationException 2392 * If this Root has been removed from the server by 2393 * another client. 2394 * @throws LdapException 2395 * If any other error occurs. 2396 */ 2397 SynchronizationProviderCfgClient getSynchronizationProvider(String name) 2398 throws DefinitionDecodingException, ManagedObjectDecodingException, 2399 ManagedObjectNotFoundException, ConcurrentModificationException, 2400 LdapException; 2401 2402 2403 2404 /** 2405 * Creates a new Synchronization Provider. The new Synchronization 2406 * Provider will initially not contain any property values (including 2407 * mandatory properties). Once the Synchronization Provider has been 2408 * configured it can be added to the server using the {@link 2409 * #commit()} method. 2410 * 2411 * @param <C> 2412 * The type of the Synchronization Provider being created. 2413 * @param d 2414 * The definition of the Synchronization Provider to be 2415 * created. 2416 * @param name 2417 * The name of the new Synchronization Provider. 2418 * @param exceptions 2419 * An optional collection in which to place any {@link 2420 * PropertyException}s that occurred whilst attempting to 2421 * determine the default values of the Synchronization 2422 * Provider. This argument can be <code>null<code>. 2423 * @return Returns a new Synchronization Provider configuration 2424 * instance. 2425 * @throws IllegalManagedObjectNameException 2426 * If the name of the new Synchronization Provider is 2427 * invalid. 2428 */ 2429 <C extends SynchronizationProviderCfgClient> C createSynchronizationProvider( 2430 ManagedObjectDefinition<C, ? extends SynchronizationProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2431 2432 2433 2434 /** 2435 * Removes the named Synchronization Provider. 2436 * 2437 * @param name 2438 * The name of the Synchronization Provider to remove. 2439 * @throws ManagedObjectNotFoundException 2440 * If the Synchronization Provider does not exist. 2441 * @throws OperationRejectedException 2442 * If the server refuses to remove the Synchronization 2443 * Provider due to some server-side constraint which cannot 2444 * be satisfied (for example, if it is referenced by 2445 * another managed object). 2446 * @throws ConcurrentModificationException 2447 * If this Root has been removed from the server by 2448 * another client. 2449 * @throws LdapException 2450 * If any other error occurs. 2451 */ 2452 void removeSynchronizationProvider(String name) 2453 throws ManagedObjectNotFoundException, OperationRejectedException, 2454 ConcurrentModificationException, LdapException; 2455 2456 2457 2458 /** 2459 * Lists the Trust Manager Providers. 2460 * 2461 * @return Returns an array containing the names of the Trust 2462 * Manager Providers. 2463 * @throws ConcurrentModificationException 2464 * If this Root has been removed from the server by 2465 * another client. 2466 * @throws LdapException 2467 * If any other error occurs. 2468 */ 2469 String[] listTrustManagerProviders() throws ConcurrentModificationException, 2470 LdapException; 2471 2472 2473 2474 /** 2475 * Gets the named Trust Manager Provider. 2476 * 2477 * @param name 2478 * The name of the Trust Manager Provider to retrieve. 2479 * @return Returns the named Trust Manager Provider. 2480 * @throws DefinitionDecodingException 2481 * If the named Trust Manager Provider was found but its 2482 * type could not be determined. 2483 * @throws ManagedObjectDecodingException 2484 * If the named Trust Manager Provider was found but one 2485 * or more of its properties could not be decoded. 2486 * @throws ManagedObjectNotFoundException 2487 * If the named Trust Manager Provider was not found on 2488 * the server. 2489 * @throws ConcurrentModificationException 2490 * If this Root has been removed from the server by 2491 * another client. 2492 * @throws LdapException 2493 * If any other error occurs. 2494 */ 2495 TrustManagerProviderCfgClient getTrustManagerProvider(String name) 2496 throws DefinitionDecodingException, ManagedObjectDecodingException, 2497 ManagedObjectNotFoundException, ConcurrentModificationException, 2498 LdapException; 2499 2500 2501 2502 /** 2503 * Creates a new Trust Manager Provider. The new Trust Manager 2504 * Provider will initially not contain any property values (including 2505 * mandatory properties). Once the Trust Manager Provider has been 2506 * configured it can be added to the server using the {@link 2507 * #commit()} method. 2508 * 2509 * @param <C> 2510 * The type of the Trust Manager Provider being created. 2511 * @param d 2512 * The definition of the Trust Manager Provider to be 2513 * created. 2514 * @param name 2515 * The name of the new Trust Manager Provider. 2516 * @param exceptions 2517 * An optional collection in which to place any {@link 2518 * PropertyException}s that occurred whilst attempting to 2519 * determine the default values of the Trust Manager 2520 * Provider. This argument can be <code>null<code>. 2521 * @return Returns a new Trust Manager Provider configuration 2522 * instance. 2523 * @throws IllegalManagedObjectNameException 2524 * If the name of the new Trust Manager Provider is 2525 * invalid. 2526 */ 2527 <C extends TrustManagerProviderCfgClient> C createTrustManagerProvider( 2528 ManagedObjectDefinition<C, ? extends TrustManagerProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2529 2530 2531 2532 /** 2533 * Removes the named Trust Manager Provider. 2534 * 2535 * @param name 2536 * The name of the Trust Manager Provider to remove. 2537 * @throws ManagedObjectNotFoundException 2538 * If the Trust Manager Provider does not exist. 2539 * @throws OperationRejectedException 2540 * If the server refuses to remove the Trust Manager 2541 * Provider due to some server-side constraint which cannot 2542 * be satisfied (for example, if it is referenced by 2543 * another managed object). 2544 * @throws ConcurrentModificationException 2545 * If this Root has been removed from the server by 2546 * another client. 2547 * @throws LdapException 2548 * If any other error occurs. 2549 */ 2550 void removeTrustManagerProvider(String name) 2551 throws ManagedObjectNotFoundException, OperationRejectedException, 2552 ConcurrentModificationException, LdapException; 2553 2554 2555 2556 /** 2557 * Lists the Virtual Attributes. 2558 * 2559 * @return Returns an array containing the names of the Virtual 2560 * Attributes. 2561 * @throws ConcurrentModificationException 2562 * If this Root has been removed from the server by 2563 * another client. 2564 * @throws LdapException 2565 * If any other error occurs. 2566 */ 2567 String[] listVirtualAttributes() throws ConcurrentModificationException, 2568 LdapException; 2569 2570 2571 2572 /** 2573 * Gets the named Virtual Attribute. 2574 * 2575 * @param name 2576 * The name of the Virtual Attribute to retrieve. 2577 * @return Returns the named Virtual Attribute. 2578 * @throws DefinitionDecodingException 2579 * If the named Virtual Attribute was found but its type 2580 * could not be determined. 2581 * @throws ManagedObjectDecodingException 2582 * If the named Virtual Attribute was found but one or 2583 * more of its properties could not be decoded. 2584 * @throws ManagedObjectNotFoundException 2585 * If the named Virtual Attribute was not found on the 2586 * server. 2587 * @throws ConcurrentModificationException 2588 * If this Root has been removed from the server by 2589 * another client. 2590 * @throws LdapException 2591 * If any other error occurs. 2592 */ 2593 VirtualAttributeCfgClient getVirtualAttribute(String name) 2594 throws DefinitionDecodingException, ManagedObjectDecodingException, 2595 ManagedObjectNotFoundException, ConcurrentModificationException, 2596 LdapException; 2597 2598 2599 2600 /** 2601 * Creates a new Virtual Attribute. The new Virtual Attribute will 2602 * initially not contain any property values (including mandatory 2603 * properties). Once the Virtual Attribute has been configured it can 2604 * be added to the server using the {@link #commit()} method. 2605 * 2606 * @param <C> 2607 * The type of the Virtual Attribute being created. 2608 * @param d 2609 * The definition of the Virtual Attribute to be created. 2610 * @param name 2611 * The name of the new Virtual Attribute. 2612 * @param exceptions 2613 * An optional collection in which to place any {@link 2614 * PropertyException}s that occurred whilst attempting to 2615 * determine the default values of the Virtual Attribute. 2616 * This argument can be <code>null<code>. 2617 * @return Returns a new Virtual Attribute configuration instance. 2618 * @throws IllegalManagedObjectNameException 2619 * If the name of the new Virtual Attribute is invalid. 2620 */ 2621 <C extends VirtualAttributeCfgClient> C createVirtualAttribute( 2622 ManagedObjectDefinition<C, ? extends VirtualAttributeCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 2623 2624 2625 2626 /** 2627 * Removes the named Virtual Attribute. 2628 * 2629 * @param name 2630 * The name of the Virtual Attribute to remove. 2631 * @throws ManagedObjectNotFoundException 2632 * If the Virtual Attribute does not exist. 2633 * @throws OperationRejectedException 2634 * If the server refuses to remove the Virtual Attribute 2635 * due to some server-side constraint which cannot be 2636 * satisfied (for example, if it is referenced by another 2637 * managed object). 2638 * @throws ConcurrentModificationException 2639 * If this Root has been removed from the server by 2640 * another client. 2641 * @throws LdapException 2642 * If any other error occurs. 2643 */ 2644 void removeVirtualAttribute(String name) 2645 throws ManagedObjectNotFoundException, OperationRejectedException, 2646 ConcurrentModificationException, LdapException; 2647 2648 2649 2650 /** 2651 * Gets the Work Queue. 2652 * 2653 * @return Returns the Work Queue. 2654 * @throws DefinitionDecodingException 2655 * If the Work Queue was found but its type could not be 2656 * determined. 2657 * @throws ManagedObjectDecodingException 2658 * If the Work Queue was found but one or more of its 2659 * properties could not be decoded. 2660 * @throws ManagedObjectNotFoundException 2661 * If the Work Queue could not be found on the server. 2662 * @throws ConcurrentModificationException 2663 * If this Root has been removed from the server by 2664 * another client. 2665 * @throws LdapException 2666 * If any other error occurs. 2667 */ 2668 WorkQueueCfgClient getWorkQueue() 2669 throws DefinitionDecodingException, ManagedObjectDecodingException, 2670 ManagedObjectNotFoundException, ConcurrentModificationException, 2671 LdapException; 2672 2673}