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