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 }