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