From 70b0e3d553e5a2a896337730b6c0540488b78f08 Mon Sep 17 00:00:00 2001
From: Nicolas Capponi <nicolas.capponi@forgerock.com>
Date: Tue, 10 Dec 2013 12:43:16 +0000
Subject: [PATCH] OpenDJ 3 : config framework
---
opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPNameBuilder.java | 338 ++--
opendj-admin/src/main/java/org/opends/server/admin/client/ClientConstraintHandler.java | 215 +-
opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPManagedObject.java | 561 +++----
opendj-admin/src/main/java/org/opends/server/admin/condition/Condition.java | 86
opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPDriver.java | 247 +--
opendj-admin/src/main/java/org/opends/server/admin/condition/ANDCondition.java | 6
opendj-admin/src/main/java/org/opends/server/admin/GenericConstraint.java | 7
opendj-admin/src/main/java/org/opends/server/admin/ConfigurationClient.java | 13
opendj-admin/src/main/java/org/opends/server/admin/AggregationPropertyDefinition.java | 16
opendj-admin/src/main/java/org/opends/server/admin/client/spi/Driver.java | 101 -
/dev/null | 290 ----
opendj-admin/src/main/java/org/opends/server/admin/condition/NOTCondition.java | 6
opendj-admin/src/main/java/org/opends/server/admin/client/spi/AbstractManagedObject.java | 66
opendj-admin/src/main/resources/stylesheets/clientMO.xsl | 63
opendj-admin/src/main/java/org/opends/server/admin/condition/ContainsCondition.java | 9
opendj-admin/src/main/java/org/opends/server/admin/client/ManagedObject.java | 1520 +++++++++------------
opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPConnection.java | 187 +-
opendj-admin/src/main/java/org/opends/server/admin/condition/IsPresentCondition.java | 6
opendj-admin/src/main/java/org/opends/server/admin/condition/ORCondition.java | 6
opendj-admin/src/main/resources/stylesheets/metaMO.xsl | 22
opendj-admin/src/main/java/org/opends/server/admin/condition/Conditions.java | 295 +--
opendj-admin/src/main/java/org/opends/server/admin/client/ManagementContext.java | 105 -
22 files changed, 1,654 insertions(+), 2,511 deletions(-)
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/AggregationPropertyDefinition.java b/opendj-admin/src/main/java/org/opends/server/admin/AggregationPropertyDefinition.java
index 651b95e..8207390 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/AggregationPropertyDefinition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/AggregationPropertyDefinition.java
@@ -42,9 +42,7 @@
import java.util.MissingResourceException;
import java.util.SortedSet;
-import org.opends.server.admin.client.AuthorizationException;
import org.opends.server.admin.client.ClientConstraintHandler;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagedObjectDecodingException;
import org.opends.server.admin.client.ManagementContext;
@@ -63,6 +61,7 @@
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.admin.meta.RootCfgDefn;
import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.forgerock.opendj.ldap.ResultCode;
/**
@@ -495,7 +494,7 @@
*/
@Override
public boolean isAddAcceptable(ManagementContext context, ManagedObject<?> managedObject,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
// If all of this managed object's "enabled" properties are true
// then any referenced managed objects must also be enabled.
boolean needsEnabling = targetNeedsEnablingCondition.evaluate(context, managedObject);
@@ -547,7 +546,7 @@
*/
@Override
public boolean isModifyAcceptable(ManagementContext context, ManagedObject<?> managedObject,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
// The same constraint applies as for adds.
return isAddAcceptable(context, managedObject, unacceptableReasons);
}
@@ -566,7 +565,7 @@
*/
@Override
public boolean isDeleteAcceptable(ManagementContext context, ManagedObjectPath<?, ?> path,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
// Any references to the deleted managed object should cause a
// constraint violation.
boolean isAcceptable = true;
@@ -593,7 +592,7 @@
*/
@Override
public boolean isModifyAcceptable(ManagementContext context, ManagedObject<?> managedObject,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
// If the modified managed object is disabled and there are some
// active references then refuse the change.
if (targetIsEnabledCondition.evaluate(context, managedObject)) {
@@ -628,7 +627,7 @@
// object using this property.
private <CC extends ConfigurationClient> List<ManagedObject<? extends CC>> findReferences(
ManagementContext context, AbstractManagedObjectDefinition<CC, ?> mod, String name)
- throws AuthorizationException, CommunicationException {
+ throws ErrorResultException {
List<ManagedObject<? extends CC>> instances = findInstances(context, mod);
Iterator<ManagedObject<? extends CC>> i = instances.iterator();
@@ -654,8 +653,7 @@
// Find all instances of a specific type of managed object.
@SuppressWarnings("unchecked")
private <CC extends ConfigurationClient> List<ManagedObject<? extends CC>> findInstances(
- ManagementContext context, AbstractManagedObjectDefinition<CC, ?> mod) throws AuthorizationException,
- CommunicationException {
+ ManagementContext context, AbstractManagedObjectDefinition<CC, ?> mod) throws ErrorResultException {
List<ManagedObject<? extends CC>> instances = new LinkedList<ManagedObject<? extends CC>>();
if (mod == RootCfgDefn.getInstance()) {
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/ConfigurationClient.java b/opendj-admin/src/main/java/org/opends/server/admin/ConfigurationClient.java
index 5dd3ae7..281205453 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/ConfigurationClient.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/ConfigurationClient.java
@@ -27,8 +27,7 @@
package org.opends.server.admin;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.client.ConcurrentModificationException;
import org.opends.server.admin.client.MissingMandatoryPropertiesException;
import org.opends.server.admin.client.OperationRejectedException;
@@ -71,14 +70,10 @@
* @throws OperationRejectedException
* If the server refuses to add or modify this configuration due
* to some server-side constraint which cannot be satisfied.
- * @throws AuthorizationException
- * If the server refuses to add or modify this configuration
- * because the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
void commit() throws ManagedObjectAlreadyExistsException, MissingMandatoryPropertiesException,
- ConcurrentModificationException, OperationRejectedException, AuthorizationException, CommunicationException;
+ ConcurrentModificationException, OperationRejectedException, ErrorResultException;
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/GenericConstraint.java b/opendj-admin/src/main/java/org/opends/server/admin/GenericConstraint.java
index 5e4dbde..59e52c4 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/GenericConstraint.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/GenericConstraint.java
@@ -31,9 +31,8 @@
import java.util.Locale;
import org.forgerock.i18n.LocalizableMessage;
-import org.opends.server.admin.client.AuthorizationException;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.client.ClientConstraintHandler;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.condition.Condition;
@@ -63,7 +62,7 @@
*/
@Override
public boolean isAddAcceptable(ManagementContext context, ManagedObject<?> managedObject,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
if (!condition.evaluate(context, managedObject)) {
unacceptableReasons.add(getSynopsis());
return false;
@@ -77,7 +76,7 @@
*/
@Override
public boolean isModifyAcceptable(ManagementContext context, ManagedObject<?> managedObject,
- Collection<LocalizableMessage> unacceptableReasons) throws AuthorizationException, CommunicationException {
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
if (!condition.evaluate(context, managedObject)) {
unacceptableReasons.add(getSynopsis());
return false;
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/AuthorizationException.java b/opendj-admin/src/main/java/org/opends/server/admin/client/AuthorizationException.java
deleted file mode 100644
index 7629c03..0000000
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/AuthorizationException.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License"). You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE
- * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
- * add the following below this CDDL HEADER, with the fields enclosed
- * by brackets "[]" replaced with your own identifying information:
- * Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- *
- *
- * Copyright 2008 Sun Microsystems, Inc.
- */
-
-package org.opends.server.admin.client;
-
-import org.forgerock.i18n.LocalizableMessage;
-
-import static com.forgerock.opendj.ldap.AdminMessages.*;
-
-/**
- * This exception is thrown when an authorization error occurs while interacting
- * with the Directory Server. Authorization errors can occur when a client
- * attempts to perform an administrative operation which they are not permitted
- * to perform.
- */
-public class AuthorizationException extends AdminSecurityException {
-
- /**
- * Serialization ID.
- */
- private static final long serialVersionUID = 8414248362572933814L;
-
- /**
- * Create an authorization exception with a default message.
- */
- public AuthorizationException() {
- super(ERR_AUTHORIZATION_EXCEPTION_DEFAULT.get());
- }
-
- /**
- * Create an authorization exception with a cause and a default message.
- *
- * @param cause
- * The cause.
- */
- public AuthorizationException(Throwable cause) {
- super(ERR_AUTHORIZATION_EXCEPTION_DEFAULT.get(), cause);
- }
-
- /**
- * Create an authorization exception with a message and cause.
- *
- * @param message
- * The message.
- * @param cause
- * The cause.
- */
- public AuthorizationException(LocalizableMessage message, Throwable cause) {
- super(message, cause);
- }
-
- /**
- * Create an authorization exception with a message.
- *
- * @param message
- * The message.
- */
- public AuthorizationException(LocalizableMessage message) {
- super(message);
- }
-}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ClientConstraintHandler.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ClientConstraintHandler.java
index f9bac2c..008d892 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ClientConstraintHandler.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ClientConstraintHandler.java
@@ -26,140 +26,117 @@
*/
package org.opends.server.admin.client;
-
-
import java.util.Collection;
import org.forgerock.i18n.LocalizableMessage;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.ManagedObjectPath;
-
-
/**
* An interface for performing client-side constraint validation.
* <p>
- * Constraints are evaluated immediately before the client performs a
- * write operation. If one or more constraints fails, the write
- * operation is refused and fails with an
- * {@link OperationRejectedException}.
+ * Constraints are evaluated immediately before the client performs a write
+ * operation. If one or more constraints fails, the write operation is refused
+ * and fails with an {@link OperationRejectedException}.
* <p>
- * A client constraint handler must override at least one of the
- * provided methods.
+ * A client constraint handler must override at least one of the provided
+ * methods.
*
* @see org.opends.server.admin.Constraint
*/
public abstract class ClientConstraintHandler {
- /**
- * Creates a new client constraint handler.
- */
- protected ClientConstraintHandler() {
- // No implementation required.
- }
+ /**
+ * Creates a new client constraint handler.
+ */
+ protected ClientConstraintHandler() {
+ // No implementation required.
+ }
+ /**
+ * Determines whether or not the newly created managed object which is about
+ * to be added to the server configuration satisfies this constraint.
+ * <p>
+ * If the constraint is not satisfied, the implementation must return
+ * <code>false</code> and add a message describing why the constraint was
+ * not satisfied.
+ * <p>
+ * The default implementation is to return <code>true</code>.
+ *
+ * @param context
+ * The management context.
+ * @param managedObject
+ * The new managed object.
+ * @param unacceptableReasons
+ * A list of messages to which error messages should be added.
+ * @return Returns <code>true</code> if this constraint is satisfied, or
+ * <code>false</code> if it is not.
+ * @throws AuthorizationException
+ * If an authorization failure prevented this constraint from
+ * being evaluated.
+ * @throws CommunicationException
+ * If a communications problem prevented this constraint from
+ * being evaluated.
+ */
+ public boolean isAddAcceptable(ManagementContext context, ManagedObject<?> managedObject,
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
+ return true;
+ }
+ /**
+ * Determines whether or not the changes to an existing managed object which
+ * are about to be committed to the server configuration satisfies this
+ * constraint.
+ * <p>
+ * If the constraint is not satisfied, the implementation must return
+ * <code>false</code> and add a message describing why the constraint was
+ * not satisfied.
+ * <p>
+ * The default implementation is to return <code>true</code>.
+ *
+ * @param context
+ * The management context.
+ * @param managedObject
+ * The modified managed object.
+ * @param unacceptableReasons
+ * A list of messages to which error messages should be added.
+ * @return Returns <code>true</code> if this modify is satisfied, or
+ * <code>false</code> if it is not.
+ * @throws AuthorizationException
+ * If an authorization failure prevented this constraint from
+ * being evaluated.
+ * @throws CommunicationException
+ * If a communications problem prevented this constraint from
+ * being evaluated.
+ */
+ public boolean isModifyAcceptable(ManagementContext context, ManagedObject<?> managedObject,
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
+ return true;
+ }
- /**
- * Determines whether or not the newly created managed object which
- * is about to be added to the server configuration satisfies this
- * constraint.
- * <p>
- * If the constraint is not satisfied, the implementation must
- * return <code>false</code> and add a message describing why the
- * constraint was not satisfied.
- * <p>
- * The default implementation is to return <code>true</code>.
- *
- * @param context
- * The management context.
- * @param managedObject
- * The new managed object.
- * @param unacceptableReasons
- * A list of messages to which error messages should be
- * added.
- * @return Returns <code>true</code> if this constraint is
- * satisfied, or <code>false</code> if it is not.
- * @throws AuthorizationException
- * If an authorization failure prevented this constraint
- * from being evaluated.
- * @throws CommunicationException
- * If a communications problem prevented this constraint
- * from being evaluated.
- */
- public boolean isAddAcceptable(ManagementContext context,
- ManagedObject<?> managedObject, Collection<LocalizableMessage> unacceptableReasons)
- throws AuthorizationException, CommunicationException {
- return true;
- }
-
-
-
- /**
- * Determines whether or not the changes to an existing managed
- * object which are about to be committed to the server
- * configuration satisfies this constraint.
- * <p>
- * If the constraint is not satisfied, the implementation must
- * return <code>false</code> and add a message describing why the
- * constraint was not satisfied.
- * <p>
- * The default implementation is to return <code>true</code>.
- *
- * @param context
- * The management context.
- * @param managedObject
- * The modified managed object.
- * @param unacceptableReasons
- * A list of messages to which error messages should be
- * added.
- * @return Returns <code>true</code> if this modify is satisfied,
- * or <code>false</code> if it is not.
- * @throws AuthorizationException
- * If an authorization failure prevented this constraint
- * from being evaluated.
- * @throws CommunicationException
- * If a communications problem prevented this constraint
- * from being evaluated.
- */
- public boolean isModifyAcceptable(ManagementContext context,
- ManagedObject<?> managedObject, Collection<LocalizableMessage> unacceptableReasons)
- throws AuthorizationException, CommunicationException {
- return true;
- }
-
-
-
- /**
- * Determines whether or not the existing managed object which is
- * about to be deleted from the server configuration satisfies this
- * constraint.
- * <p>
- * If the constraint is not satisfied, the implementation must
- * return <code>false</code> and add a message describing why the
- * constraint was not satisfied.
- * <p>
- * The default implementation is to return <code>true</code>.
- *
- * @param context
- * The management context.
- * @param path
- * The path of the managed object which is about to be
- * deleted.
- * @param unacceptableReasons
- * A list of messages to which error messages should be
- * added.
- * @return Returns <code>true</code> if this constraint is
- * satisfied, or <code>false</code> if it is not.
- * @throws AuthorizationException
- * If an authorization failure prevented this constraint
- * from being evaluated.
- * @throws CommunicationException
- * If a communications problem prevented this constraint
- * from being evaluated.
- */
- public boolean isDeleteAcceptable(ManagementContext context,
- ManagedObjectPath<?, ?> path, Collection<LocalizableMessage> unacceptableReasons)
- throws AuthorizationException, CommunicationException {
- return true;
- }
+ /**
+ * Determines whether or not the existing managed object which is about to
+ * be deleted from the server configuration satisfies this constraint.
+ * <p>
+ * If the constraint is not satisfied, the implementation must return
+ * <code>false</code> and add a message describing why the constraint was
+ * not satisfied.
+ * <p>
+ * The default implementation is to return <code>true</code>.
+ *
+ * @param context
+ * The management context.
+ * @param path
+ * The path of the managed object which is about to be deleted.
+ * @param unacceptableReasons
+ * A list of messages to which error messages should be added.
+ * @return Returns <code>true</code> if this constraint is satisfied, or
+ * <code>false</code> if it is not.
+ * @throws ErrorResultException
+ * If an error occurs.
+ */
+ public boolean isDeleteAcceptable(ManagementContext context, ManagedObjectPath<?, ?> path,
+ Collection<LocalizableMessage> unacceptableReasons) throws ErrorResultException {
+ return true;
+ }
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/CommunicationException.java b/opendj-admin/src/main/java/org/opends/server/admin/client/CommunicationException.java
deleted file mode 100644
index ea18c76..0000000
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/CommunicationException.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License"). You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE
- * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
- * add the following below this CDDL HEADER, with the fields enclosed
- * by brackets "[]" replaced with your own identifying information:
- * Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- *
- *
- * Copyright 2008 Sun Microsystems, Inc.
- */
-
-package org.opends.server.admin.client;
-
-
-
-import org.forgerock.i18n.LocalizableMessage;
-
-import static com.forgerock.opendj.ldap.AdminMessages.*;
-
-
-
-/**
- * This exception is thrown when a communications related problem
- * occurs whilst interacting with the Directory Server. This may be
- * caused by problems such as network partitioning, the unavailability
- * of the Directory Server, or other failures on the client or server
- * side.
- */
-public class CommunicationException extends AdminClientException {
-
- /**
- * Serialization ID.
- */
- private static final long serialVersionUID = 9093195928501281027L;
-
-
-
- /**
- * Create a communication exception with a default message.
- */
- public CommunicationException() {
- super(ERR_COMMUNICATION_EXCEPTION_DEFAULT.get());
- }
-
-
-
- /**
- * Create a communication exception with a cause and a default
- * message.
- *
- * @param cause
- * The cause.
- */
- public CommunicationException(Throwable cause) {
- super(ERR_COMMUNICATION_EXCEPTION_DEFAULT_CAUSE.get(cause.getMessage()),
- cause);
- }
-
-
-
- /**
- * Create a communication exception with a message and cause.
- *
- * @param message
- * The message.
- * @param cause
- * The cause.
- */
- public CommunicationException(LocalizableMessage message, Throwable cause) {
- super(message, cause);
- }
-
-
-
- /**
- * Create a communication exception with a message.
- *
- * @param message
- * The message.
- */
- public CommunicationException(LocalizableMessage message) {
- super(message);
- }
-}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ManagedObject.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ManagedObject.java
index 3b16697..a6b58a0 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ManagedObject.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ManagedObject.java
@@ -27,11 +27,10 @@
package org.opends.server.admin.client;
-
-
import java.util.Collection;
import java.util.SortedSet;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.Configuration;
import org.opends.server.admin.DefaultBehaviorException;
@@ -52,887 +51,720 @@
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.SingletonRelationDefinition;
-
-
/**
* A generic interface for accessing client-side managed objects.
* <p>
- * A managed object comprises of zero or more properties. A property
- * has associated with it three sets of property value(s). These are:
+ * A managed object comprises of zero or more properties. A property has
+ * associated with it three sets of property value(s). These are:
* <ul>
- * <li><i>default value(s)</i> - these value(s) represent the
- * default behavior for the property when it has no active values.
- * When a property inherits its default value(s) from elsewhere (i.e.
- * a property in another managed object), the default value(s)
- * represent the active value(s) of the inherited property at the time
- * the managed object was retrieved
- * <li><i>active value(s)</i> - these value(s) represent the state
- * of the property at the time the managed object was retrieved
- * <li><i>pending value(s)</i> - these value(s) represent any
- * modifications made to the property's value(s) since the managed
- * object object was retrieved and before the changes have been
- * committed using the {@link #commit()} method, the pending values
- * can be empty indicating that the property should be modified back
- * to its default values.
+ * <li><i>default value(s)</i> - these value(s) represent the default behavior
+ * for the property when it has no active values. When a property inherits its
+ * default value(s) from elsewhere (i.e. a property in another managed object),
+ * the default value(s) represent the active value(s) of the inherited property
+ * at the time the managed object was retrieved
+ * <li><i>active value(s)</i> - these value(s) represent the state of the
+ * property at the time the managed object was retrieved
+ * <li><i>pending value(s)</i> - these value(s) represent any modifications made
+ * to the property's value(s) since the managed object object was retrieved and
+ * before the changes have been committed using the {@link #commit()} method,
+ * the pending values can be empty indicating that the property should be
+ * modified back to its default values.
* </ul>
- * In addition, a property has an <i>effective state</i> defined by
- * its <i>effective values</i> which are derived by evaluating the
- * following rules in the order presented:
+ * In addition, a property has an <i>effective state</i> defined by its
+ * <i>effective values</i> which are derived by evaluating the following rules
+ * in the order presented:
* <ul>
* <li>the <i>pending values</i> if defined and non-empty
- * <li>or, the <i>default values</i> if the pending values are
- * defined but are empty
+ * <li>or, the <i>default values</i> if the pending values are defined but are
+ * empty
* <li>or, the <i>active values</i> if defined and non-empty
* <li>or, the <i>default values</i> if there are no active values
* <li>or, an empty set of values, if there are no default values.
* </ul>
*
* @param <T>
- * The type of client configuration represented by the client
- * managed object.
+ * The type of client configuration represented by the client managed
+ * object.
*/
-public interface ManagedObject<T extends ConfigurationClient> extends
- PropertyProvider {
+public interface ManagedObject<T extends ConfigurationClient> extends PropertyProvider {
- /**
- * Adds this managed object to the server or commits any changes
- * made to it depending on whether or not the managed object already
- * exists on the server. Pending property values will be committed
- * to the managed object. If successful, the pending values will
- * become active values.
- * <p>
- * See the class description for more information regarding pending
- * and active values.
- *
- * @throws ManagedObjectAlreadyExistsException
- * If the managed object cannot be added to the server
- * because it already exists.
- * @throws MissingMandatoryPropertiesException
- * If the managed object contains some mandatory
- * properties which have been left undefined.
- * @throws ConcurrentModificationException
- * If the managed object is being added to the server but
- * its parent has been removed by another client, or if
- * this managed object is being modified but it has been
- * removed from the server by another client.
- * @throws OperationRejectedException
- * If this managed object cannot be added or modified due
- * to some client-side or server-side constraint which
- * cannot be satisfied.
- * @throws AuthorizationException
- * If the server refuses to add or modify this managed
- * object because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- void commit() throws ManagedObjectAlreadyExistsException,
- MissingMandatoryPropertiesException, ConcurrentModificationException,
- OperationRejectedException, AuthorizationException,
- CommunicationException;
+ /**
+ * Adds this managed object to the server or commits any changes made to it
+ * depending on whether or not the managed object already exists on the
+ * server. Pending property values will be committed to the managed object.
+ * If successful, the pending values will become active values.
+ * <p>
+ * See the class description for more information regarding pending and
+ * active values.
+ *
+ * @throws ManagedObjectAlreadyExistsException
+ * If the managed object cannot be added to the server because
+ * it already exists.
+ * @throws MissingMandatoryPropertiesException
+ * If the managed object contains some mandatory properties
+ * which have been left undefined.
+ * @throws ConcurrentModificationException
+ * If the managed object is being added to the server but its
+ * parent has been removed by another client, or if this managed
+ * object is being modified but it has been removed from the
+ * server by another client.
+ * @throws OperationRejectedException
+ * If this managed object cannot be added or modified due to
+ * some client-side or server-side constraint which cannot be
+ * satisfied.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ void commit() throws ManagedObjectAlreadyExistsException, MissingMandatoryPropertiesException,
+ ConcurrentModificationException, OperationRejectedException, ErrorResultException;
+ /**
+ * Determines whether or not this managed object has been modified since it
+ * was constructed. In other words, whether or not the set of pending values
+ * differs from the set of active values.
+ *
+ * @return Returns <code>true</code> if this managed object has been
+ * modified since it was constructed.
+ */
+ boolean isModified();
- /**
- * Determines whether or not this managed object has been modified since it
- * was constructed.
- * In other words, whether or not the set of pending values differs from
- * the set of active values.
- *
- * @return Returns <code>true</code> if this managed object has been
- * modified since it was constructed.
- */
- boolean isModified();
+ /**
+ * Creates a new child managed object bound to the specified instantiable
+ * relation. The new managed object will initially not contain any property
+ * values (including mandatory properties). Once the managed object has been
+ * configured it can be added to the server using the {@link #commit()}
+ * method.
+ *
+ * @param <C>
+ * The expected type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The expected type of the child managed object server
+ * configuration.
+ * @param <CC>
+ * The actual type of the added managed object configuration
+ * client.
+ * @param r
+ * The instantiable relation definition.
+ * @param d
+ * The definition of the managed object to be created.
+ * @param name
+ * The name of the child managed object.
+ * @param exceptions
+ * A collection in which to place any
+ * {@link DefaultBehaviorException}s that occurred whilst
+ * attempting to determine the managed object's default values.
+ * @return Returns a new child managed object bound to the specified
+ * instantiable relation.
+ * @throws IllegalManagedObjectNameException
+ * If the name of the child managed object is invalid.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ */
+ <C extends ConfigurationClient, S extends Configuration, CC extends C> ManagedObject<CC> createChild(
+ InstantiableRelationDefinition<C, S> r, ManagedObjectDefinition<CC, ? extends S> d, String name,
+ Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException,
+ IllegalArgumentException;
+ /**
+ * Creates a new child managed object bound to the specified optional
+ * relation. The new managed object will initially not contain any property
+ * values (including mandatory properties). Once the managed object has been
+ * configured it can be added to the server using the {@link #commit()}
+ * method.
+ *
+ * @param <C>
+ * The expected type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The expected type of the child managed object server
+ * configuration.
+ * @param <CC>
+ * The actual type of the added managed object configuration
+ * client.
+ * @param r
+ * The optional relation definition.
+ * @param d
+ * The definition of the managed object to be created.
+ * @param exceptions
+ * A collection in which to place any
+ * {@link DefaultBehaviorException}s that occurred whilst
+ * attempting to determine the managed object's default values.
+ * @return Returns a new child managed object bound to the specified
+ * optional relation.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ */
+ <C extends ConfigurationClient, S extends Configuration, CC extends C> ManagedObject<CC> createChild(
+ OptionalRelationDefinition<C, S> r, ManagedObjectDefinition<CC, ? extends S> d,
+ Collection<DefaultBehaviorException> exceptions) throws IllegalArgumentException;
- /**
- * Creates a new child managed object bound to the specified
- * instantiable relation. The new managed object will initially not
- * contain any property values (including mandatory properties).
- * Once the managed object has been configured it can be added to
- * the server using the {@link #commit()} method.
- *
- * @param <C>
- * The expected type of the child managed object
- * configuration client.
- * @param <S>
- * The expected type of the child managed object
- * server configuration.
- * @param <CC>
- * The actual type of the added managed object
- * configuration client.
- * @param r
- * The instantiable relation definition.
- * @param d
- * The definition of the managed object to be created.
- * @param name
- * The name of the child managed object.
- * @param exceptions
- * A collection in which to place any
- * {@link DefaultBehaviorException}s that occurred whilst
- * attempting to determine the managed object's default
- * values.
- * @return Returns a new child managed object bound to the specified
- * instantiable relation.
- * @throws IllegalManagedObjectNameException
- * If the name of the child managed object is invalid.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- */
- <C extends ConfigurationClient, S extends Configuration, CC extends C>
- ManagedObject<CC> createChild(InstantiableRelationDefinition<C, S> r,
- ManagedObjectDefinition<CC, ? extends S> d, String name,
- Collection<DefaultBehaviorException> exceptions)
- throws IllegalManagedObjectNameException, IllegalArgumentException;
+ /**
+ * Creates a new child managed object bound to the specified set relation.
+ * The new managed object will initially not contain any property values
+ * (including mandatory properties). Once the managed object has been
+ * configured it can be added to the server using the {@link #commit()}
+ * method.
+ *
+ * @param <C>
+ * The expected type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The expected type of the child managed object server
+ * configuration.
+ * @param <CC>
+ * The actual type of the added managed object configuration
+ * client.
+ * @param r
+ * The set relation definition.
+ * @param d
+ * The definition of the managed object to be created.
+ * @param exceptions
+ * A collection in which to place any
+ * {@link DefaultBehaviorException}s that occurred whilst
+ * attempting to determine the managed object's default values.
+ * @return Returns a new child managed object bound to the specified set
+ * relation.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ */
+ <C extends ConfigurationClient, S extends Configuration, CC extends C> ManagedObject<CC> createChild(
+ SetRelationDefinition<C, S> r, ManagedObjectDefinition<CC, ? extends S> d,
+ Collection<DefaultBehaviorException> exceptions) throws IllegalArgumentException;
+ /**
+ * Retrieves an instantiable child managed object.
+ *
+ * @param <C>
+ * The requested type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The instantiable relation definition.
+ * @param name
+ * The name of the child managed object.
+ * @return Returns the instantiable child managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws DefinitionDecodingException
+ * If the managed object was found but its type could not be
+ * determined.
+ * @throws ManagedObjectDecodingException
+ * If the managed object was found but one or more of its
+ * properties could not be decoded.
+ * @throws ManagedObjectNotFoundException
+ * If the requested managed object could not be found on the
+ * server.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
+ InstantiableRelationDefinition<C, S> r, String name) throws IllegalArgumentException,
+ DefinitionDecodingException, ManagedObjectDecodingException, ManagedObjectNotFoundException,
+ ConcurrentModificationException, ErrorResultException;
+ /**
+ * Retrieves an optional child managed object.
+ *
+ * @param <C>
+ * The requested type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The optional relation definition.
+ * @return Returns the optional child managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws DefinitionDecodingException
+ * If the managed object was found but its type could not be
+ * determined.
+ * @throws ManagedObjectDecodingException
+ * If the managed object was found but one or more of its
+ * properties could not be decoded.
+ * @throws ManagedObjectNotFoundException
+ * If the requested managed object could not be found on the
+ * server.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
+ OptionalRelationDefinition<C, S> r) throws IllegalArgumentException, DefinitionDecodingException,
+ ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
+ ErrorResultException;
- /**
- * Creates a new child managed object bound to the specified
- * optional relation. The new managed object will initially not
- * contain any property values (including mandatory properties).
- * Once the managed object has been configured it can be added to
- * the server using the {@link #commit()} method.
- *
- * @param <C>
- * The expected type of the child managed object
- * configuration client.
- * @param <S>
- * The expected type of the child managed object
- * server configuration.
- * @param <CC>
- * The actual type of the added managed object
- * configuration client.
- * @param r
- * The optional relation definition.
- * @param d
- * The definition of the managed object to be created.
- * @param exceptions
- * A collection in which to place any
- * {@link DefaultBehaviorException}s that occurred whilst
- * attempting to determine the managed object's default
- * values.
- * @return Returns a new child managed object bound to the specified
- * optional relation.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- */
- <C extends ConfigurationClient, S extends Configuration, CC extends C>
- ManagedObject<CC> createChild(OptionalRelationDefinition<C, S> r,
- ManagedObjectDefinition<CC, ? extends S> d,
- Collection<DefaultBehaviorException> exceptions)
- throws IllegalArgumentException;
+ /**
+ * Retrieves a singleton child managed object.
+ *
+ * @param <C>
+ * The requested type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The singleton relation definition.
+ * @return Returns the singleton child managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws DefinitionDecodingException
+ * If the managed object was found but its type could not be
+ * determined.
+ * @throws ManagedObjectDecodingException
+ * If the managed object was found but one or more of its
+ * properties could not be decoded.
+ * @throws ManagedObjectNotFoundException
+ * If the requested managed object could not be found on the
+ * server.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
+ SingletonRelationDefinition<C, S> r) throws IllegalArgumentException, DefinitionDecodingException,
+ ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
+ ErrorResultException;
+ /**
+ * Retrieves a set child managed object.
+ *
+ * @param <C>
+ * The requested type of the child managed object configuration
+ * client.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The set relation definition.
+ * @param name
+ * The name of the child managed object.
+ * @return Returns the set child managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws DefinitionDecodingException
+ * If the managed object was found but its type could not be
+ * determined.
+ * @throws ManagedObjectDecodingException
+ * If the managed object was found but one or more of its
+ * properties could not be decoded.
+ * @throws ManagedObjectNotFoundException
+ * If the requested managed object could not be found on the
+ * server.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
+ SetRelationDefinition<C, S> r, String name) throws IllegalArgumentException, DefinitionDecodingException,
+ ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
+ ErrorResultException;
+ /**
+ * Creates a client configuration view of this managed object. Modifications
+ * made to this managed object will be reflected in the client configuration
+ * view and vice versa.
+ *
+ * @return Returns a client configuration view of this managed object.
+ */
+ T getConfiguration();
- /**
- * Creates a new child managed object bound to the specified
- * set relation. The new managed object will initially not
- * contain any property values (including mandatory properties).
- * Once the managed object has been configured it can be added to
- * the server using the {@link #commit()} method.
- *
- * @param <C>
- * The expected type of the child managed object
- * configuration client.
- * @param <S>
- * The expected type of the child managed object
- * server configuration.
- * @param <CC>
- * The actual type of the added managed object
- * configuration client.
- * @param r
- * The set relation definition.
- * @param d
- * The definition of the managed object to be created.
- * @param exceptions
- * A collection in which to place any
- * {@link DefaultBehaviorException}s that occurred whilst
- * attempting to determine the managed object's default
- * values.
- * @return Returns a new child managed object bound to the specified
- * set relation.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- */
- <C extends ConfigurationClient, S extends Configuration, CC extends C>
- ManagedObject<CC> createChild(SetRelationDefinition<C, S> r,
- ManagedObjectDefinition<CC, ? extends S> d,
- Collection<DefaultBehaviorException> exceptions)
- throws IllegalArgumentException;
+ /**
+ * Gets the definition associated with this managed object.
+ *
+ * @return Returns the definition associated with this managed object.
+ */
+ ManagedObjectDefinition<T, ? extends Configuration> getManagedObjectDefinition();
+ /**
+ * Gets the path of this managed object.
+ *
+ * @return Returns the path of this managed object.
+ */
+ ManagedObjectPath<T, ? extends Configuration> getManagedObjectPath();
+ /**
+ * Gets a mutable copy of the set of default values for the specified
+ * property.
+ *
+ * @param <PD>
+ * The type of the property to be retrieved.
+ * @param pd
+ * The property to be retrieved.
+ * @return Returns the property's default values, or an empty set if there
+ * are no default values defined.
+ * @throws IllegalArgumentException
+ * If the property definition is not associated with this
+ * managed object's definition.
+ */
+ <PD> SortedSet<PD> getPropertyDefaultValues(PropertyDefinition<PD> pd) throws IllegalArgumentException;
- /**
- * Retrieves an instantiable child managed object.
- *
- * @param <C>
- * The requested type of the child managed object
- * configuration client.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The instantiable relation definition.
- * @param name
- * The name of the child managed object.
- * @return Returns the instantiable child managed object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws DefinitionDecodingException
- * If the managed object was found but its type could not
- * be determined.
- * @throws ManagedObjectDecodingException
- * If the managed object was found but one or more of its
- * properties could not be decoded.
- * @throws ManagedObjectNotFoundException
- * If the requested managed object could not be found on
- * the server.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- ManagedObject<? extends C> getChild(InstantiableRelationDefinition<C, S> r,
- String name) throws IllegalArgumentException, DefinitionDecodingException,
- ManagedObjectDecodingException, ManagedObjectNotFoundException,
- ConcurrentModificationException, AuthorizationException,
- CommunicationException;
+ /**
+ * Gets the effective value of the specified property.
+ * <p>
+ * See the class description for more information about how the effective
+ * property value is derived.
+ *
+ * @param <PD>
+ * The type of the property to be retrieved.
+ * @param pd
+ * The property to be retrieved.
+ * @return Returns the property's effective value, or <code>null</code> if
+ * there is no effective value defined.
+ * @throws IllegalArgumentException
+ * If the property definition is not associated with this
+ * managed object's definition.
+ */
+ <PD> PD getPropertyValue(PropertyDefinition<PD> pd) throws IllegalArgumentException;
+ /**
+ * Gets a mutable copy of the set of effective values for the specified
+ * property.
+ * <p>
+ * See the class description for more information about how the effective
+ * property values are derived.
+ *
+ * @param <PD>
+ * The type of the property to be retrieved.
+ * @param pd
+ * The property to be retrieved.
+ * @return Returns the property's effective values, or an empty set if there
+ * are no effective values defined.
+ * @throws IllegalArgumentException
+ * If the property definition is not associated with this
+ * managed object's definition.
+ */
+ <PD> SortedSet<PD> getPropertyValues(PropertyDefinition<PD> pd) throws IllegalArgumentException;
+ /**
+ * Determines whether or not the specified property is set. If the property
+ * is unset, then any default behavior associated with the property applies.
+ *
+ * @param pd
+ * The property definition.
+ * @return Returns <code>true</code> if the property has been set, or
+ * <code>false</code> if it is unset and any default behavior
+ * associated with the property applies.
+ * @throws IllegalArgumentException
+ * If the property definition is not associated with this
+ * managed object's definition.
+ */
+ boolean isPropertyPresent(PropertyDefinition<?> pd) throws IllegalArgumentException;
- /**
- * Retrieves an optional child managed object.
- *
- * @param <C>
- * The requested type of the child managed object
- * configuration client.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The optional relation definition.
- * @return Returns the optional child managed object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws DefinitionDecodingException
- * If the managed object was found but its type could not
- * be determined.
- * @throws ManagedObjectDecodingException
- * If the managed object was found but one or more of its
- * properties could not be decoded.
- * @throws ManagedObjectNotFoundException
- * If the requested managed object could not be found on
- * the server.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- ManagedObject<? extends C> getChild(OptionalRelationDefinition<C, S> r)
- throws IllegalArgumentException, DefinitionDecodingException,
- ManagedObjectDecodingException, ManagedObjectNotFoundException,
- ConcurrentModificationException, AuthorizationException,
- CommunicationException;
+ /**
+ * Determines whether or not the optional managed object associated with the
+ * specified optional relations exists.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The optional relation definition.
+ * @return Returns <code>true</code> if the optional managed object exists,
+ * <code>false</code> otherwise.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If there is any other error.
+ */
+ <C extends ConfigurationClient, S extends Configuration> boolean hasChild(OptionalRelationDefinition<C, S> r)
+ throws IllegalArgumentException, ConcurrentModificationException, ErrorResultException;
+ /**
+ * Lists the child managed objects associated with the specified
+ * instantiable relation.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The instantiable relation definition.
+ * @return Returns the names of the child managed objects.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
+ InstantiableRelationDefinition<C, S> r) throws IllegalArgumentException, ConcurrentModificationException,
+ ErrorResultException;
+ /**
+ * Lists the child managed objects associated with the specified
+ * instantiable relation which are a sub-type of the specified managed
+ * object definition.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The instantiable relation definition.
+ * @param d
+ * The managed object definition.
+ * @return Returns the names of the child managed objects which are a
+ * sub-type of the specified managed object definition.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
+ InstantiableRelationDefinition<C, S> r, AbstractManagedObjectDefinition<? extends C, ? extends S> d)
+ throws IllegalArgumentException, ConcurrentModificationException, ErrorResultException;
- /**
- * Retrieves a singleton child managed object.
- *
- * @param <C>
- * The requested type of the child managed object
- * configuration client.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The singleton relation definition.
- * @return Returns the singleton child managed object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws DefinitionDecodingException
- * If the managed object was found but its type could not
- * be determined.
- * @throws ManagedObjectDecodingException
- * If the managed object was found but one or more of its
- * properties could not be decoded.
- * @throws ManagedObjectNotFoundException
- * If the requested managed object could not be found on
- * the server.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- ManagedObject<? extends C> getChild(SingletonRelationDefinition<C, S> r)
- throws IllegalArgumentException, DefinitionDecodingException,
- ManagedObjectDecodingException, ManagedObjectNotFoundException,
- ConcurrentModificationException, AuthorizationException,
- CommunicationException;
-
-
-
- /**
- * Retrieves a set child managed object.
- *
- * @param <C>
- * The requested type of the child managed object
- * configuration client.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The set relation definition.
- * @param name
- * The name of the child managed object.
- * @return Returns the set child managed object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws DefinitionDecodingException
- * If the managed object was found but its type could not
- * be determined.
- * @throws ManagedObjectDecodingException
- * If the managed object was found but one or more of its
- * properties could not be decoded.
- * @throws ManagedObjectNotFoundException
- * If the requested managed object could not be found on
- * the server.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- ManagedObject<? extends C> getChild(SetRelationDefinition<C, S> r,
- String name) throws IllegalArgumentException, DefinitionDecodingException,
- ManagedObjectDecodingException, ManagedObjectNotFoundException,
- ConcurrentModificationException, AuthorizationException,
- CommunicationException;
-
-
-
- /**
- * Creates a client configuration view of this managed object.
- * Modifications made to this managed object will be reflected in
- * the client configuration view and vice versa.
- *
- * @return Returns a client configuration view of this managed
- * object.
- */
- T getConfiguration();
-
-
-
- /**
- * Gets the definition associated with this managed object.
- *
- * @return Returns the definition associated with this managed
- * object.
- */
- ManagedObjectDefinition<T, ? extends Configuration>
- getManagedObjectDefinition();
-
-
-
- /**
- * Gets the path of this managed object.
- *
- * @return Returns the path of this managed object.
- */
- ManagedObjectPath<T, ? extends Configuration> getManagedObjectPath();
-
-
-
- /**
- * Gets a mutable copy of the set of default values for the
- * specified property.
- *
- * @param <PD>
- * The type of the property to be retrieved.
- * @param pd
- * The property to be retrieved.
- * @return Returns the property's default values, or an empty set if
- * there are no default values defined.
- * @throws IllegalArgumentException
- * If the property definition is not associated with this
- * managed object's definition.
- */
- <PD> SortedSet<PD> getPropertyDefaultValues(PropertyDefinition<PD> pd)
- throws IllegalArgumentException;
-
-
-
- /**
- * Gets the effective value of the specified property.
- * <p>
- * See the class description for more information about how the
- * effective property value is derived.
- *
- * @param <PD>
- * The type of the property to be retrieved.
- * @param pd
- * The property to be retrieved.
- * @return Returns the property's effective value, or
- * <code>null</code> if there is no effective value
- * defined.
- * @throws IllegalArgumentException
- * If the property definition is not associated with this
- * managed object's definition.
- */
- <PD> PD getPropertyValue(PropertyDefinition<PD> pd)
- throws IllegalArgumentException;
-
-
-
- /**
- * Gets a mutable copy of the set of effective values for the
- * specified property.
- * <p>
- * See the class description for more information about how the
- * effective property values are derived.
- *
- * @param <PD>
- * The type of the property to be retrieved.
- * @param pd
- * The property to be retrieved.
- * @return Returns the property's effective values, or an empty set
- * if there are no effective values defined.
- * @throws IllegalArgumentException
- * If the property definition is not associated with this
- * managed object's definition.
- */
- <PD> SortedSet<PD> getPropertyValues(PropertyDefinition<PD> pd)
- throws IllegalArgumentException;
-
-
-
- /**
- * Determines whether or not the specified property is set. If the
- * property is unset, then any default behavior associated with the
- * property applies.
- *
- * @param pd
- * The property definition.
- * @return Returns <code>true</code> if the property has been set,
- * or <code>false</code> if it is unset and any default
- * behavior associated with the property applies.
- * @throws IllegalArgumentException
- * If the property definition is not associated with this
- * managed object's definition.
- */
- boolean isPropertyPresent(PropertyDefinition<?> pd)
- throws IllegalArgumentException;
-
-
-
- /**
- * Determines whether or not the optional managed object associated
- * with the specified optional relations exists.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The optional relation definition.
- * @return Returns <code>true</code> if the optional managed
- * object exists, <code>false</code> otherwise.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to make the determination because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- boolean hasChild(OptionalRelationDefinition<C, S> r)
- throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Lists the child managed objects associated with the specified
- * instantiable relation.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The instantiable relation definition.
- * @return Returns the names of the child managed objects.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- String[] listChildren(InstantiableRelationDefinition<C, S> r)
- throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Lists the child managed objects associated with the specified
- * instantiable relation which are a sub-type of the specified
- * managed object definition.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The instantiable relation definition.
- * @param d
- * The managed object definition.
- * @return Returns the names of the child managed objects which are
- * a sub-type of the specified managed object definition.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- String[] listChildren(InstantiableRelationDefinition<C, S> r,
- AbstractManagedObjectDefinition<? extends C, ? extends S> d)
- throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Lists the child managed objects associated with the specified set
- * relation.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The set relation definition.
- * @return Returns the names of the child managed objects which for
- * set relations are the definition names of each managed
- * object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- String[] listChildren(SetRelationDefinition<C, S> r)
- throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Lists the child managed objects associated with the specified set
- * relation which are a sub-type of the specified managed object
- * definition.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The set relation definition.
- * @param d
- * The managed object definition.
- * @return Returns the names of the child managed objects which for
- * set relations are the definition names of each managed
- * object.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- String[] listChildren(SetRelationDefinition<C, S> r,
- AbstractManagedObjectDefinition<? extends C, ? extends S> d)
- throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Removes the named instantiable child managed object.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The instantiable relation definition.
- * @param name
- * The name of the child managed object to be removed.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ManagedObjectNotFoundException
- * If the managed object could not be removed because it
- * could not found on the server.
- * @throws OperationRejectedException
- * If the managed object cannot be removed due to some
- * client-side or server-side constraint which cannot be
- * satisfied (for example, if it is referenced by another
- * managed object).
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- void removeChild(InstantiableRelationDefinition<C, S> r, String name)
- throws IllegalArgumentException, ManagedObjectNotFoundException,
- OperationRejectedException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Removes an optional child managed object.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The optional relation definition.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ManagedObjectNotFoundException
- * If the managed object could not be removed because it
- * could not found on the server.
- * @throws OperationRejectedException
- * If the managed object cannot be removed due to some
- * client-side or server-side constraint which cannot be
- * satisfied (for example, if it is referenced by another
- * managed object).
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- void removeChild(OptionalRelationDefinition<C, S> r)
- throws IllegalArgumentException, ManagedObjectNotFoundException,
- OperationRejectedException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
-
-
-
- /**
- * Removes s set child managed object.
- *
- * @param <C>
- * The type of client managed object configuration that the
- * relation definition refers to.
- * @param <S>
- * The type of server managed object configuration that the
- * relation definition refers to.
- * @param r
- * The set relation definition.
- * @param name
- * The name of the child managed object to be removed.
- * @throws IllegalArgumentException
- * If the relation definition is not associated with this
- * managed object's definition.
- * @throws ManagedObjectNotFoundException
- * If the managed object could not be removed because it
- * could not found on the server.
- * @throws OperationRejectedException
- * If the managed object cannot be removed due to some
- * client-side or server-side constraint which cannot be
- * satisfied (for example, if it is referenced by another
- * managed object).
- * @throws ConcurrentModificationException
- * If this managed object has been removed from the server
- * by another client.
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects
- * because the client does not have the correct
- * privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an
- * underlying communication problem.
- */
- <C extends ConfigurationClient, S extends Configuration>
- void removeChild(SetRelationDefinition<C, S> r, String name)
- throws IllegalArgumentException, ManagedObjectNotFoundException,
- OperationRejectedException, ConcurrentModificationException,
- AuthorizationException, CommunicationException;
+ /**
+ * Lists the child managed objects associated with the specified set
+ * relation.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The set relation definition.
+ * @return Returns the names of the child managed objects which for set
+ * relations are the definition names of each managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> String[] listChildren(SetRelationDefinition<C, S> r)
+ throws IllegalArgumentException, ConcurrentModificationException, ErrorResultException;
+ /**
+ * Lists the child managed objects associated with the specified set
+ * relation which are a sub-type of the specified managed object definition.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The set relation definition.
+ * @param d
+ * The managed object definition.
+ * @return Returns the names of the child managed objects which for set
+ * relations are the definition names of each managed object.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> String[] listChildren(SetRelationDefinition<C, S> r,
+ AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
+ ConcurrentModificationException, ErrorResultException;
+ /**
+ * Removes the named instantiable child managed object.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The instantiable relation definition.
+ * @param name
+ * The name of the child managed object to be removed.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ManagedObjectNotFoundException
+ * If the managed object could not be removed because it could
+ * not found on the server.
+ * @throws OperationRejectedException
+ * If the managed object cannot be removed due to some
+ * client-side or server-side constraint which cannot be
+ * satisfied (for example, if it is referenced by another
+ * managed object).
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> void removeChild(InstantiableRelationDefinition<C, S> r,
+ String name) throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
+ ConcurrentModificationException, ErrorResultException;
- /**
- * Sets a new pending value for the specified property.
- * <p>
- * See the class description for more information regarding pending
- * values.
- *
- * @param <PD>
- * The type of the property to be modified.
- * @param pd
- * The property to be modified.
- * @param value
- * The new pending value for the property, or
- * <code>null</code> if the property should be reset to
- * its default behavior.
- * @throws IllegalPropertyValueException
- * If the new pending value is deemed to be invalid
- * according to the property definition.
- * @throws PropertyIsReadOnlyException
- * If this is not a new managed object and the property is
- * read-only or for monitoring purposes.
- * @throws PropertyIsMandatoryException
- * If an attempt was made to remove a mandatory property.
- * @throws IllegalArgumentException
- * If the specified property definition is not associated
- * with this managed object.
- */
- <PD> void setPropertyValue(PropertyDefinition<PD> pd, PD value)
- throws IllegalPropertyValueException, PropertyIsReadOnlyException,
- PropertyIsMandatoryException, IllegalArgumentException;
+ /**
+ * Removes an optional child managed object.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The optional relation definition.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ManagedObjectNotFoundException
+ * If the managed object could not be removed because it could
+ * not found on the server.
+ * @throws OperationRejectedException
+ * If the managed object cannot be removed due to some
+ * client-side or server-side constraint which cannot be
+ * satisfied (for example, if it is referenced by another
+ * managed object).
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> void removeChild(OptionalRelationDefinition<C, S> r)
+ throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
+ ConcurrentModificationException, ErrorResultException;
+ /**
+ * Removes s set child managed object.
+ *
+ * @param <C>
+ * The type of client managed object configuration that the
+ * relation definition refers to.
+ * @param <S>
+ * The type of server managed object configuration that the
+ * relation definition refers to.
+ * @param r
+ * The set relation definition.
+ * @param name
+ * The name of the child managed object to be removed.
+ * @throws IllegalArgumentException
+ * If the relation definition is not associated with this
+ * managed object's definition.
+ * @throws ManagedObjectNotFoundException
+ * If the managed object could not be removed because it could
+ * not found on the server.
+ * @throws OperationRejectedException
+ * If the managed object cannot be removed due to some
+ * client-side or server-side constraint which cannot be
+ * satisfied (for example, if it is referenced by another
+ * managed object).
+ * @throws ConcurrentModificationException
+ * If this managed object has been removed from the server by
+ * another client.
+ * @throws ErrorResultException
+ * If any other error occurs.
+ */
+ <C extends ConfigurationClient, S extends Configuration> void removeChild(SetRelationDefinition<C, S> r, String name)
+ throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
+ ConcurrentModificationException, ErrorResultException;
+ /**
+ * Sets a new pending value for the specified property.
+ * <p>
+ * See the class description for more information regarding pending values.
+ *
+ * @param <PD>
+ * The type of the property to be modified.
+ * @param pd
+ * The property to be modified.
+ * @param value
+ * The new pending value for the property, or <code>null</code>
+ * if the property should be reset to its default behavior.
+ * @throws IllegalPropertyValueException
+ * If the new pending value is deemed to be invalid according to
+ * the property definition.
+ * @throws PropertyIsReadOnlyException
+ * If this is not a new managed object and the property is
+ * read-only or for monitoring purposes.
+ * @throws PropertyIsMandatoryException
+ * If an attempt was made to remove a mandatory property.
+ * @throws IllegalArgumentException
+ * If the specified property definition is not associated with
+ * this managed object.
+ */
+ <PD> void setPropertyValue(PropertyDefinition<PD> pd, PD value) throws IllegalPropertyValueException,
+ PropertyIsReadOnlyException, PropertyIsMandatoryException, IllegalArgumentException;
- /**
- * Sets a new pending values for the specified property.
- * <p>
- * See the class description for more information regarding pending
- * values.
- *
- * @param <PD>
- * The type of the property to be modified.
- * @param pd
- * The property to be modified.
- * @param values
- * A non-<code>null</code> set of new pending values for
- * the property (an empty set indicates that the property
- * should be reset to its default behavior). The set will
- * not be referenced by this managed object.
- * @throws IllegalPropertyValueException
- * If a new pending value is deemed to be invalid
- * according to the property definition.
- * @throws PropertyIsSingleValuedException
- * If an attempt was made to add multiple pending values
- * to a single-valued property.
- * @throws PropertyIsReadOnlyException
- * If this is not a new managed object and the property is
- * read-only or for monitoring purposes.
- * @throws PropertyIsMandatoryException
- * If an attempt was made to remove a mandatory property.
- * @throws IllegalArgumentException
- * If the specified property definition is not associated
- * with this managed object.
- */
- <PD> void setPropertyValues(PropertyDefinition<PD> pd, Collection<PD> values)
- throws IllegalPropertyValueException, PropertyIsSingleValuedException,
- PropertyIsReadOnlyException, PropertyIsMandatoryException,
- IllegalArgumentException;
+ /**
+ * Sets a new pending values for the specified property.
+ * <p>
+ * See the class description for more information regarding pending values.
+ *
+ * @param <PD>
+ * The type of the property to be modified.
+ * @param pd
+ * The property to be modified.
+ * @param values
+ * A non-<code>null</code> set of new pending values for the
+ * property (an empty set indicates that the property should be
+ * reset to its default behavior). The set will not be referenced
+ * by this managed object.
+ * @throws IllegalPropertyValueException
+ * If a new pending value is deemed to be invalid according to
+ * the property definition.
+ * @throws PropertyIsSingleValuedException
+ * If an attempt was made to add multiple pending values to a
+ * single-valued property.
+ * @throws PropertyIsReadOnlyException
+ * If this is not a new managed object and the property is
+ * read-only or for monitoring purposes.
+ * @throws PropertyIsMandatoryException
+ * If an attempt was made to remove a mandatory property.
+ * @throws IllegalArgumentException
+ * If the specified property definition is not associated with
+ * this managed object.
+ */
+ <PD> void setPropertyValues(PropertyDefinition<PD> pd, Collection<PD> values) throws IllegalPropertyValueException,
+ PropertyIsSingleValuedException, PropertyIsReadOnlyException, PropertyIsMandatoryException,
+ IllegalArgumentException;
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ManagementContext.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ManagementContext.java
index b3517d9..8bb4505 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ManagementContext.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ManagementContext.java
@@ -31,6 +31,7 @@
import java.util.SortedSet;
import org.forgerock.opendj.admin.client.RootCfgClient;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.Configuration;
import org.opends.server.admin.ConfigurationClient;
@@ -84,17 +85,13 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd, String name)
throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
return getDriver().deleteManagedObject(parent, rd, name);
}
@@ -124,16 +121,12 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, OptionalRelationDefinition<C, S> rd) throws IllegalArgumentException,
- ManagedObjectNotFoundException, OperationRejectedException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException {
return getDriver().deleteManagedObject(parent, rd);
}
@@ -164,17 +157,13 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, SetRelationDefinition<C, S> rd, String name)
throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
return getDriver().deleteManagedObject(parent, rd, name);
}
@@ -199,17 +188,13 @@
* @throws ManagedObjectNotFoundException
* If the requested managed object could not be found on the
* server.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
@SuppressWarnings("unchecked")
public final <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getManagedObject(
ManagedObjectPath<C, S> path) throws DefinitionDecodingException, ManagedObjectDecodingException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
// Be careful to handle the root configuration.
if (path.isEmpty()) {
return (ManagedObject<C>) getRootConfigurationManagedObject();
@@ -241,16 +226,12 @@
* @throws ManagedObjectNotFoundException
* If the requested managed object could not be found on the
* server.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <PD> PD getPropertyValue(ManagedObjectPath<?, ?> path, PropertyDefinition<PD> pd)
- throws IllegalArgumentException, DefinitionDecodingException, AuthorizationException,
- ManagedObjectNotFoundException, CommunicationException, PropertyException {
+ throws IllegalArgumentException, DefinitionDecodingException, ErrorResultException,
+ ManagedObjectNotFoundException, PropertyException {
Set<PD> values = getPropertyValues(path, pd);
if (values.isEmpty()) {
return null;
@@ -282,16 +263,12 @@
* @throws ManagedObjectNotFoundException
* If the requested managed object could not be found on the
* server.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <PD> SortedSet<PD> getPropertyValues(ManagedObjectPath<?, ?> path, PropertyDefinition<PD> pd)
- throws IllegalArgumentException, DefinitionDecodingException, AuthorizationException,
- ManagedObjectNotFoundException, CommunicationException, PropertyException {
+ throws IllegalArgumentException, DefinitionDecodingException, ErrorResultException,
+ ManagedObjectNotFoundException, PropertyException {
return getDriver().getPropertyValues(path, pd);
}
@@ -336,16 +313,12 @@
* managed object's definition.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
return listManagedObjects(parent, rd, rd.getChildDefinition());
}
@@ -372,17 +345,13 @@
* managed object's definition.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd,
AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
return getDriver().listManagedObjects(parent, rd, d);
}
@@ -405,16 +374,12 @@
* managed object's definition.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, SetRelationDefinition<C, S> rd) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
return getDriver().listManagedObjects(parent, rd, rd.getChildDefinition());
}
@@ -427,15 +392,11 @@
* <code>false</code> otherwise.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to make the determination because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final boolean managedObjectExists(ManagedObjectPath<?, ?> path) throws ManagedObjectNotFoundException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
return getDriver().managedObjectExists(path);
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/JNDIDirContextAdaptor.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/JNDIDirContextAdaptor.java
deleted file mode 100644
index df7834c..0000000
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/JNDIDirContextAdaptor.java
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License"). You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE
- * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at
- * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
- * add the following below this CDDL HEADER, with the fields enclosed
- * by brackets "[]" replaced with your own identifying information:
- * Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- *
- *
- * Copyright 2008-2010 Sun Microsystems, Inc.
- * Portions Copyright 2013 ForgeRock AS
- */
-package org.opends.server.admin.client.ldap;
-
-import java.util.Collection;
-import java.util.Hashtable;
-import java.util.LinkedList;
-import java.util.List;
-
-import javax.naming.Context;
-import javax.naming.NameNotFoundException;
-import javax.naming.NamingEnumeration;
-import javax.naming.NamingException;
-import javax.naming.directory.Attribute;
-import javax.naming.directory.Attributes;
-import javax.naming.directory.DirContext;
-import javax.naming.directory.ModificationItem;
-import javax.naming.directory.SearchControls;
-import javax.naming.directory.SearchResult;
-import javax.naming.ldap.InitialLdapContext;
-import javax.naming.ldap.LdapName;
-import javax.naming.ldap.Rdn;
-
-import org.opends.server.admin.client.AuthenticationException;
-import org.opends.server.admin.client.AuthenticationNotSupportedException;
-import org.opends.server.admin.client.CommunicationException;
-
-/**
- * An LDAP connection adaptor which maps LDAP requests onto an underlying JNDI
- * connection context.
- */
-public final class JNDIDirContextAdaptor extends LDAPConnection {
-
- /**
- * Adapts the provided JNDI <code>DirContext</code>.
- *
- * @param dirContext
- * The JNDI connection.
- * @return Returns a new JNDI connection adaptor.
- */
- public static JNDIDirContextAdaptor adapt(DirContext dirContext) {
- return new JNDIDirContextAdaptor(dirContext);
- }
-
- /**
- * Creates a new JNDI connection adaptor by performing a simple bind
- * operation to the specified LDAP server.
- *
- * @param host
- * The host.
- * @param port
- * The port.
- * @param name
- * The LDAP bind DN.
- * @param password
- * The LDAP bind password.
- * @return Returns a new JNDI connection adaptor.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
- * @throws AuthenticationNotSupportedException
- * If the server does not support simple authentication.
- * @throws AuthenticationException
- * If authentication failed for some reason, usually due to
- * invalid credentials.
- */
- public static JNDIDirContextAdaptor simpleBind(String host, int port, String name, String password)
- throws CommunicationException, AuthenticationNotSupportedException, AuthenticationException {
- Hashtable<String, Object> env = new Hashtable<String, Object>();
- env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
- String hostname = ConnectionUtils.getHostNameForLdapUrl(host);
- env.put(Context.PROVIDER_URL, "ldap://" + hostname + ":" + port);
- env.put(Context.SECURITY_PRINCIPAL, name);
- env.put(Context.SECURITY_CREDENTIALS, password);
-
- DirContext ctx;
- try {
- ctx = new InitialLdapContext(env, null);
- } catch (javax.naming.CommunicationException e) {
- throw new CommunicationException(e);
- } catch (javax.naming.AuthenticationException e) {
- throw new AuthenticationException(e);
- } catch (javax.naming.AuthenticationNotSupportedException e) {
- throw new AuthenticationNotSupportedException(e);
- } catch (NamingException e) {
- // Assume some kind of communication problem.
- throw new CommunicationException(e);
- }
-
- return new JNDIDirContextAdaptor(ctx);
- }
-
- /**
- * Creates a new JNDI connection adaptor by performing a simple bind
- * operation to the specified LDAP server.
- *
- * @param host
- * The host.
- * @param port
- * The port.
- * @param name
- * The LDAP bind DN.
- * @param password
- * The LDAP bind password.
- * @return Returns a new JNDI connection adaptor.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
- * @throws AuthenticationNotSupportedException
- * If the server does not support simple authentication.
- * @throws AuthenticationException
- * If authentication failed for some reason, usually due to
- * invalid credentials.
- */
- public static JNDIDirContextAdaptor simpleSSLBind(String host, int port, String name, String password)
- throws CommunicationException, AuthenticationNotSupportedException, AuthenticationException {
- Hashtable<String, Object> env = new Hashtable<String, Object>();
- env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
- String hostname = ConnectionUtils.getHostNameForLdapUrl(host);
- env.put(Context.PROVIDER_URL, "ldaps://" + hostname + ":" + port);
- env.put(Context.SECURITY_PRINCIPAL, name);
- env.put(Context.SECURITY_CREDENTIALS, password);
- env.put(Context.SECURITY_AUTHENTICATION, "simple");
- // Specify SSL
- env.put(Context.SECURITY_PROTOCOL, "ssl");
- env.put("java.naming.ldap.factory.socket", org.opends.admin.ads.util.TrustedSocketFactory.class.getName());
- TrustedSocketFactory.setCurrentThreadTrustManager(new BlindTrustManager(), null);
- DirContext ctx;
- try {
- ctx = new InitialLdapContext(env, null);
- } catch (javax.naming.CommunicationException e) {
- throw new CommunicationException(e);
- } catch (javax.naming.AuthenticationException e) {
- throw new AuthenticationException(e);
- } catch (javax.naming.AuthenticationNotSupportedException e) {
- throw new AuthenticationNotSupportedException(e);
- } catch (NamingException e) {
- // Assume some kind of communication problem.
- throw new CommunicationException(e);
- }
-
- return new JNDIDirContextAdaptor(ctx);
- }
-
- // The JNDI connection context.
- private final DirContext dirContext;
-
- // Create a new JNDI connection adaptor using the provider JNDI
- // DirContext.
- private JNDIDirContextAdaptor(DirContext dirContext) {
- this.dirContext = dirContext;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void createEntry(LdapName dn, Attributes attributes) throws NamingException {
- dirContext.createSubcontext(dn, attributes).close();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void deleteSubtree(LdapName dn) throws NamingException {
- // Delete the children first.
- for (LdapName child : listEntries(dn, null)) {
- deleteSubtree(child);
- }
-
- // Delete the named entry.
- dirContext.destroySubcontext(dn);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean entryExists(LdapName dn) throws NamingException {
- boolean entryExists = false;
- String filter = "(objectClass=*)";
- SearchControls controls = new SearchControls();
- controls.setSearchScope(SearchControls.OBJECT_SCOPE);
- controls.setReturningAttributes(new String[] { SchemaConstants.NO_ATTRIBUTES });
- try {
- NamingEnumeration<SearchResult> results = dirContext.search(dn, filter, controls);
- try {
- while (results.hasMore()) {
- // To avoid having a systematic abandon in the server.
- results.next();
- entryExists = true;
- }
- } finally {
- results.close();
- }
- } catch (NameNotFoundException e) {
- // Fall through - entry not found.
- }
- return entryExists;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Collection<LdapName> listEntries(LdapName dn, String filter) throws NamingException {
- if (filter == null) {
- filter = "(objectClass=*)";
- }
-
- SearchControls controls = new SearchControls();
- controls.setSearchScope(SearchControls.ONELEVEL_SCOPE);
-
- List<LdapName> children = new LinkedList<LdapName>();
- NamingEnumeration<SearchResult> results = dirContext.search(dn, filter, controls);
- try {
- while (results.hasMore()) {
- SearchResult sr = results.next();
- LdapName child = new LdapName(dn.getRdns());
- child.add(new Rdn(sr.getName()));
- children.add(child);
- }
- } finally {
- results.close();
- }
-
- return children;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void modifyEntry(LdapName dn, Attributes mods) throws NamingException {
- ModificationItem[] modList = new ModificationItem[mods.size()];
- NamingEnumeration<? extends Attribute> ne = mods.getAll();
- for (int i = 0; ne.hasMore(); i++) {
- ModificationItem modItem = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, ne.next());
- modList[i] = modItem;
- }
- dirContext.modifyAttributes(dn, modList);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Attributes readEntry(LdapName dn, Collection<String> attrIds) throws NamingException {
- String[] attrIdList = attrIds.toArray(new String[attrIds.size()]);
- return dirContext.getAttributes(dn, attrIdList);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void unbind() {
- try {
- dirContext.close();
- } catch (NamingException e) {
- // nothing to do
- }
- }
-}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPConnection.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPConnection.java
index 943d82e..9853b84 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPConnection.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPConnection.java
@@ -26,124 +26,101 @@
*/
package org.opends.server.admin.client.ldap;
-
import java.util.Collection;
-import javax.naming.NamingException;
-import javax.naming.directory.Attributes;
-import javax.naming.ldap.LdapName;
-
-
+import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.Entry;
+import org.forgerock.opendj.ldap.ErrorResultException;
+import org.forgerock.opendj.ldap.requests.ModifyRequest;
+import org.forgerock.opendj.ldap.responses.SearchResultEntry;
/**
- * An LDAP connection adaptor interface which is used to perform LDAP
- * client operations.
+ * An LDAP connection adaptor interface which is used to perform LDAP client
+ * operations.
* <p>
- * This interface is provided in order to make it easier to keep track
- * of which JNDI DirContext methods we require and also to facilitate
- * implementation of mock JNDI contexts for unit-testing.
+ * This interface is provided in order to make it easier to keep track of which
+ * JNDI DirContext methods we require and also to facilitate implementation of
+ * mock JNDI contexts for unit-testing.
*/
public abstract class LDAPConnection {
- /**
- * Create a new LDAP connection.
- */
- protected LDAPConnection() {
- // No implementation required.
- }
+ /**
+ * Create a new LDAP connection.
+ */
+ protected LDAPConnection() {
+ // No implementation required.
+ }
+ /**
+ * Creates a new entry.
+ *
+ * @param entry
+ * The entry to create.
+ * @throws ErrorResultException
+ * If an error occurred whilst creating the entry.
+ */
+ public abstract void createEntry(Entry entry) throws ErrorResultException;
+ /**
+ * Deletes the named subtree.
+ *
+ * @param dn
+ * The name of the subtree to be deleted.
+ * @throws ErrorResultException
+ * If an error occurred whilst deleting the subtree.
+ */
+ public abstract void deleteSubtree(DN dn) throws ErrorResultException;
- /**
- * Creates a new entry with the specified set of attributes.
- *
- * @param dn
- * The name of the entry to be created.
- * @param attributes
- * The set of attributes.
- * @throws NamingException
- * If an error occurred whilst creating the entry.
- */
- public abstract void createEntry(LdapName dn, Attributes attributes)
- throws NamingException;
+ /**
+ * Determines whether or not the named entry exists.
+ *
+ * @param dn
+ * The name of the entry.
+ * @return Returns <code>true</code> if the entry exists.
+ * @throws ErrorResultException
+ * If an error occurred whilst making the determination.
+ */
+ public abstract boolean entryExists(DN dn) throws ErrorResultException;
+ /**
+ * Lists the children of the named entry.
+ *
+ * @param dn
+ * The name of the entry to list.
+ * @param filter
+ * An LDAP filter string, or <code>null</code> indicating the
+ * default filter of <code>(objectclass=*)</code>.
+ * @return Returns the names of the children.
+ * @throws ErrorResultException
+ * If an error occurred whilst listing the children.
+ */
+ public abstract Collection<DN> listEntries(DN dn, String filter) throws ErrorResultException;
+ /**
+ * Modifies an entry according to the provided modify request.
+ *
+ * @param request
+ * The modification request to perform.
+ * @throws ErrorResultException
+ * If an error occurred whilst applying the modifications.
+ */
+ public abstract void modifyEntry(ModifyRequest request) throws ErrorResultException;
- /**
- * Deletes the named subtree.
- *
- * @param dn
- * The name of the subtree to be deleted.
- * @throws NamingException
- * If an error occurred whilst deleting the subtree.
- */
- public abstract void deleteSubtree(LdapName dn) throws NamingException;
+ /**
+ * Reads the attributes of the named entry.
+ *
+ * @param dn
+ * The name of the entry to be read.
+ * @param attrIds
+ * The list of attributes to be retrievd.
+ * @return Returns the attributes of the requested entry.
+ * @throws ErrorResultException
+ * If an error occurred whilst reading the entry.
+ */
+ public abstract SearchResultEntry readEntry(DN dn, Collection<String> attrIds) throws ErrorResultException;
-
-
- /**
- * Determines whether or not the named entry exists.
- *
- * @param dn
- * The name of the entry.
- * @return Returns <code>true</code> if the entry exists.
- * @throws NamingException
- * If an error occurred whilst making the determination.
- */
- public abstract boolean entryExists(LdapName dn) throws NamingException;
-
-
-
- /**
- * Lists the children of the named entry.
- *
- * @param dn
- * The name of the entry to list.
- * @param filter
- * An LDAP filter string, or <code>null</code> indicating
- * the default filter of <code>(objectclass=*)</code>.
- * @return Returns the names of the children.
- * @throws NamingException
- * If an error occurred whilst listing the children.
- */
- public abstract Collection<LdapName> listEntries(LdapName dn, String filter)
- throws NamingException;
-
-
-
- /**
- * Modifies the attributes of the named entry.
- *
- * @param dn
- * The name of the entry to be modified.
- * @param mods
- * The list of attributes which need replacing.
- * @throws NamingException
- * If an error occurred whilst applying the modifications.
- */
- public abstract void modifyEntry(LdapName dn, Attributes mods)
- throws NamingException;
-
-
-
- /**
- * Reads the attributes of the named entry.
- *
- * @param dn
- * The name of the entry to be read.
- * @param attrIds
- * The list of attributes to be retrievd.
- * @return Returns the attributes of the requested entry.
- * @throws NamingException
- * If an error occurred whilst reading the entry.
- */
- public abstract Attributes readEntry(LdapName dn, Collection<String> attrIds)
- throws NamingException;
-
-
-
- /**
- * Closes the LDAP connection.
- */
- public abstract void unbind();
+ /**
+ * Closes the LDAP connection.
+ */
+ public abstract void unbind();
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPDriver.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPDriver.java
index 48d5ca7..a1e5a5c 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPDriver.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPDriver.java
@@ -37,18 +37,15 @@
import java.util.SortedSet;
import java.util.TreeSet;
-import javax.naming.NameNotFoundException;
-import javax.naming.NamingEnumeration;
-import javax.naming.NamingException;
-import javax.naming.NoPermissionException;
-import javax.naming.OperationNotSupportedException;
-import javax.naming.directory.Attribute;
-import javax.naming.directory.Attributes;
-import javax.naming.ldap.LdapName;
-
import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.admin.client.RootCfgClient;
import org.forgerock.opendj.admin.meta.RootCfgDefn;
+import org.forgerock.opendj.ldap.Attribute;
+import org.forgerock.opendj.ldap.ByteString;
+import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.ErrorResultException;
+import org.forgerock.opendj.ldap.ResultCode;
+import org.forgerock.opendj.ldap.responses.SearchResultEntry;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.AggregationPropertyDefinition;
import org.opends.server.admin.Configuration;
@@ -73,8 +70,6 @@
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.UnknownPropertyDefinitionException;
import org.opends.server.admin.DefinitionDecodingException.Reason;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagedObjectDecodingException;
import org.opends.server.admin.client.OperationRejectedException;
@@ -184,14 +179,14 @@
@Override
public <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getManagedObject(
ManagedObjectPath<C, S> path) throws DefinitionDecodingException, ManagedObjectDecodingException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
if (!managedObjectExists(path)) {
throw new ManagedObjectNotFoundException();
}
try {
// Read the entry associated with the managed object.
- LdapName dn = LDAPNameBuilder.create(path, profile);
+ DN dn = LDAPNameBuilder.create(path, profile);
AbstractManagedObjectDefinition<C, S> d = path.getManagedObjectDefinition();
ManagedObjectDefinition<? extends C, ? extends S> mod = getEntryDefinition(d, dn);
@@ -201,14 +196,14 @@
attrIds.add(attrId);
}
- Attributes attributes = connection.readEntry(dn, attrIds);
+ SearchResultEntry searchResultEntry = connection.readEntry(dn, attrIds);
// Build the managed object's properties.
List<PropertyException> exceptions = new LinkedList<PropertyException>();
PropertySet newProperties = new PropertySet();
for (PropertyDefinition<?> pd : mod.getAllPropertyDefinitions()) {
String attrID = profile.getAttributeName(mod, pd);
- Attribute attribute = attributes.get(attrID);
+ Attribute attribute = searchResultEntry.getAttribute(attrID);
try {
decodeProperty(newProperties, path, pd, attribute);
} catch (PropertyException e) {
@@ -224,12 +219,11 @@
} else {
throw new ManagedObjectDecodingException(mo, exceptions);
}
- } catch (NameNotFoundException e) {
- throw new ManagedObjectNotFoundException();
- } catch (NoPermissionException e) {
- throw new AuthorizationException(e);
- } catch (NamingException e) {
- throw new CommunicationException(e);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.NO_SUCH_OBJECT) {
+ throw new ManagedObjectNotFoundException();
+ }
+ throw e;
}
}
@@ -239,15 +233,14 @@
@SuppressWarnings("unchecked")
@Override
public <C extends ConfigurationClient, S extends Configuration, PD> SortedSet<PD> getPropertyValues(
- ManagedObjectPath<C, S> path, PropertyDefinition<PD> pd) throws IllegalArgumentException,
- DefinitionDecodingException, AuthorizationException, ManagedObjectNotFoundException,
- CommunicationException, PropertyException {
+ ManagedObjectPath<C, S> path, PropertyDefinition<PD> propertyDef) throws IllegalArgumentException,
+ DefinitionDecodingException, ManagedObjectNotFoundException, ErrorResultException, PropertyException {
// Check that the requested property is from the definition
// associated with the path.
AbstractManagedObjectDefinition<C, S> d = path.getManagedObjectDefinition();
- PropertyDefinition<?> tmp = d.getPropertyDefinition(pd.getName());
- if (tmp != pd) {
- throw new IllegalArgumentException("The property " + pd.getName() + " is not associated with a "
+ PropertyDefinition<?> tmp = d.getPropertyDefinition(propertyDef.getName());
+ if (tmp != propertyDef) {
+ throw new IllegalArgumentException("The property " + propertyDef.getName() + " is not associated with a "
+ d.getName());
}
@@ -257,53 +250,47 @@
try {
// Read the entry associated with the managed object.
- LdapName dn = LDAPNameBuilder.create(path, profile);
- ManagedObjectDefinition<? extends C, ? extends S> mod;
- mod = getEntryDefinition(d, dn);
+ DN dn = LDAPNameBuilder.create(path, profile);
+ ManagedObjectDefinition<? extends C, ? extends S> objectDef = getEntryDefinition(d, dn);
// Make sure we use the correct property definition, the
// provided one might have been overridden in the resolved
// definition.
- pd = (PropertyDefinition<PD>) mod.getPropertyDefinition(pd.getName());
+ propertyDef = (PropertyDefinition<PD>) objectDef.getPropertyDefinition(propertyDef.getName());
- String attrID = profile.getAttributeName(mod, pd);
- Attributes attributes = connection.readEntry(dn, Collections.singleton(attrID));
- Attribute attribute = attributes.get(attrID);
+ String attrID = profile.getAttributeName(objectDef, propertyDef);
+ SearchResultEntry resultEntry = connection.readEntry(dn, Collections.singleton(attrID));
+ Attribute attribute = resultEntry.getAttribute(attrID);
// Decode the values.
- SortedSet<PD> values = new TreeSet<PD>(pd);
+ SortedSet<PD> values = new TreeSet<PD>(propertyDef);
if (attribute != null) {
- NamingEnumeration<?> ldapValues = attribute.getAll();
- while (ldapValues.hasMore()) {
- Object obj = ldapValues.next();
- if (obj != null) {
- PD value = ValueDecoder.decode(pd, obj);
- values.add(value);
- }
+ for (ByteString byteValue : attribute) {
+ PD value = ValueDecoder.decode(propertyDef, byteValue);
+ values.add(value);
}
}
// Sanity check the returned values.
- if (values.size() > 1 && !pd.hasOption(PropertyOption.MULTI_VALUED)) {
- throw new PropertyIsSingleValuedException(pd);
+ if (values.size() > 1 && !propertyDef.hasOption(PropertyOption.MULTI_VALUED)) {
+ throw new PropertyIsSingleValuedException(propertyDef);
}
- if (values.isEmpty() && pd.hasOption(PropertyOption.MANDATORY)) {
- throw new PropertyIsMandatoryException(pd);
+ if (values.isEmpty() && propertyDef.hasOption(PropertyOption.MANDATORY)) {
+ throw new PropertyIsMandatoryException(propertyDef);
}
if (values.isEmpty()) {
// Use the property's default values.
- values.addAll(findDefaultValues(path.asSubType(mod), pd, false));
+ values.addAll(findDefaultValues(path.asSubType(objectDef), propertyDef, false));
}
return values;
- } catch (NameNotFoundException e) {
- throw new ManagedObjectNotFoundException();
- } catch (NoPermissionException e) {
- throw new AuthorizationException(e);
- } catch (NamingException e) {
- throw new CommunicationException(e);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.NO_SUCH_OBJECT) {
+ throw new ManagedObjectNotFoundException();
+ }
+ throw e;
}
}
@@ -323,7 +310,7 @@
public <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd,
AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
validateRelationDefinition(parent, rd);
if (!managedObjectExists(parent)) {
@@ -331,7 +318,7 @@
}
// Get the search base DN.
- LdapName dn = LDAPNameBuilder.create(parent, rd, profile);
+ DN dn = LDAPNameBuilder.create(parent, rd, profile);
// Retrieve only those entries which are sub-types of the
// specified definition.
@@ -343,17 +330,18 @@
List<String> children = new ArrayList<String>();
try {
- for (LdapName child : connection.listEntries(dn, filter)) {
- children.add(child.getRdn(child.size() - 1).getValue().toString());
+ for (DN child : connection.listEntries(dn, filter)) {
+ children.add(child.rdn().getFirstAVA().getAttributeValue().toString());
}
- } catch (NameNotFoundException e) {
- // Ignore this - it means that the base entry does not exist
- // (which it might not if this managed object has just been
- // created.
- } catch (NamingException e) {
- adaptNamingException(e);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.NO_SUCH_OBJECT) {
+ // Ignore this
+ // It means that the base entry does not exist
+ // It might not if this managed object has just been created.
+ } else {
+ throw e;
+ }
}
-
return children.toArray(new String[children.size()]);
}
@@ -364,7 +352,7 @@
public <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, SetRelationDefinition<C, S> rd,
AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, ErrorResultException {
validateRelationDefinition(parent, rd);
if (!managedObjectExists(parent)) {
@@ -372,7 +360,7 @@
}
// Get the search base DN.
- LdapName dn = LDAPNameBuilder.create(parent, rd, profile);
+ DN dn = LDAPNameBuilder.create(parent, rd, profile);
// Retrieve only those entries which are sub-types of the
// specified definition.
@@ -384,15 +372,17 @@
List<String> children = new ArrayList<String>();
try {
- for (LdapName child : connection.listEntries(dn, filter)) {
- children.add(child.getRdn(child.size() - 1).getValue().toString());
+ for (DN child : connection.listEntries(dn, filter)) {
+ children.add(child.rdn().getFirstAVA().getAttributeValue().toString());
}
- } catch (NameNotFoundException e) {
- // Ignore this - it means that the base entry does not exist
- // (which it might not if this managed object has just been
- // created.
- } catch (NamingException e) {
- adaptNamingException(e);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.NO_SUCH_OBJECT) {
+ // Ignore this
+ // It means that the base entry does not exist
+ // It might not if this managed object has just been created.
+ } else {
+ throw e;
+ }
}
return children.toArray(new String[children.size()]);
@@ -403,13 +393,13 @@
*/
@Override
public boolean managedObjectExists(ManagedObjectPath<?, ?> path) throws ManagedObjectNotFoundException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
if (path.isEmpty()) {
return true;
}
ManagedObjectPath<?, ?> parent = path.parent();
- LdapName dn = LDAPNameBuilder.create(parent, profile);
+ DN dn = LDAPNameBuilder.create(parent, profile);
if (!entryExists(dn)) {
throw new ManagedObjectNotFoundException();
}
@@ -423,23 +413,18 @@
*/
@Override
protected <C extends ConfigurationClient, S extends Configuration> void deleteManagedObject(
- ManagedObjectPath<C, S> path) throws OperationRejectedException, AuthorizationException,
- CommunicationException {
+ ManagedObjectPath<C, S> path) throws OperationRejectedException, ErrorResultException {
// Delete the entry and any subordinate entries.
- LdapName dn = LDAPNameBuilder.create(path, profile);
+ DN dn = LDAPNameBuilder.create(path, profile);
try {
connection.deleteSubtree(dn);
- } catch (OperationNotSupportedException e) {
- // Unwilling to perform.
- AbstractManagedObjectDefinition<?, ?> d = path.getManagedObjectDefinition();
- if (e.getMessage() == null) {
- throw new OperationRejectedException(OperationType.DELETE, d.getUserFriendlyName());
- } else {
+ } catch(ErrorResultException e) {
+ if (e.getResult().getResultCode()==ResultCode.UNWILLING_TO_PERFORM) {
+ AbstractManagedObjectDefinition<?, ?> d = path.getManagedObjectDefinition();
LocalizableMessage m = LocalizableMessage.raw("%s", e.getMessage());
throw new OperationRejectedException(OperationType.DELETE, d.getUserFriendlyName(), m);
}
- } catch (NamingException e) {
- adaptNamingException(e);
+ throw e;
}
}
@@ -452,50 +437,16 @@
}
/**
- * Adapts a naming exception to an appropriate admin client exception.
- *
- * @param ne
- * The naming exception.
- * @throws CommunicationException
- * If the naming exception mapped to a communication exception.
- * @throws AuthorizationException
- * If the naming exception mapped to an authorization exception.
- */
- void adaptNamingException(NamingException ne) throws CommunicationException, AuthorizationException {
- try {
- throw ne;
- } catch (javax.naming.CommunicationException e) {
- throw new CommunicationException(e);
- } catch (javax.naming.ServiceUnavailableException e) {
- throw new CommunicationException(e);
- } catch (javax.naming.NoPermissionException e) {
- throw new AuthorizationException(e);
- } catch (NamingException e) {
- // Just treat it as a communication problem.
- throw new CommunicationException(e);
- }
- }
-
- /**
* Determines whether the named LDAP entry exists.
*
* @param dn
* The LDAP entry name.
* @return Returns <code>true</code> if the named LDAP entry exists.
- * @throws AuthorizationException
- * If the server refuses to make the determination because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * if a problem occurs.
*/
- boolean entryExists(LdapName dn) throws CommunicationException, AuthorizationException {
- try {
- return connection.entryExists(dn);
- } catch (NamingException e) {
- adaptNamingException(e);
- }
- return false;
+ boolean entryExists(DN dn) throws ErrorResultException {
+ return connection.entryExists(dn);
}
/**
@@ -531,26 +482,22 @@
}
// Create a property using the provided string values.
- private <PD> void decodeProperty(PropertySet newProperties, ManagedObjectPath<?, ?> p, PropertyDefinition<PD> pd,
- Attribute attribute) throws PropertyException, NamingException {
+ private <PD> void decodeProperty(PropertySet newProperties, ManagedObjectPath<?, ?> path,
+ PropertyDefinition<PD> propertyDef, Attribute attribute) throws PropertyException {
PropertyException exception = null;
// Get the property's active values.
- SortedSet<PD> activeValues = new TreeSet<PD>(pd);
+ SortedSet<PD> activeValues = new TreeSet<PD>(propertyDef);
if (attribute != null) {
- NamingEnumeration<?> ldapValues = attribute.getAll();
- while (ldapValues.hasMore()) {
- Object obj = ldapValues.next();
- if (obj != null) {
- PD value = ValueDecoder.decode(pd, obj);
- activeValues.add(value);
- }
+ for (ByteString byteValue : attribute) {
+ PD value = ValueDecoder.decode(propertyDef, byteValue);
+ activeValues.add(value);
}
}
- if (activeValues.size() > 1 && !pd.hasOption(PropertyOption.MULTI_VALUED)) {
+ if (activeValues.size() > 1 && !propertyDef.hasOption(PropertyOption.MULTI_VALUED)) {
// This exception takes precedence over previous exceptions.
- exception = new PropertyIsSingleValuedException(pd);
+ exception = new PropertyIsSingleValuedException(propertyDef);
PD value = activeValues.first();
activeValues.clear();
activeValues.add(value);
@@ -559,19 +506,19 @@
// Get the property's default values.
Collection<PD> defaultValues;
try {
- defaultValues = findDefaultValues(p, pd, false);
+ defaultValues = findDefaultValues(path, propertyDef, false);
} catch (DefaultBehaviorException e) {
defaultValues = Collections.emptySet();
exception = e;
}
- newProperties.addProperty(pd, defaultValues, activeValues);
+ newProperties.addProperty(propertyDef, defaultValues, activeValues);
- if (activeValues.isEmpty() && defaultValues.isEmpty() && pd.hasOption(PropertyOption.MANDATORY)) {
+ if (activeValues.isEmpty() && defaultValues.isEmpty() && propertyDef.hasOption(PropertyOption.MANDATORY)) {
// The active values maybe empty because of a previous
// exception.
if (exception == null) {
- exception = new PropertyIsMandatoryException(pd);
+ exception = new PropertyIsMandatoryException(propertyDef);
}
}
@@ -583,22 +530,18 @@
// Determine the type of managed object associated with the named
// entry.
private <C extends ConfigurationClient, S extends Configuration> ManagedObjectDefinition<? extends C, ? extends S> getEntryDefinition(
- AbstractManagedObjectDefinition<C, S> d, LdapName dn) throws NamingException, DefinitionDecodingException {
- Attributes attributes = connection.readEntry(dn, Collections.singleton("objectclass"));
- Attribute oc = attributes.get("objectclass");
+ AbstractManagedObjectDefinition<C, S> d, DN dn) throws ErrorResultException, DefinitionDecodingException {
+ SearchResultEntry searchResultEntry = connection.readEntry(dn, Collections.singleton("objectclass"));
+ Attribute objectClassAttr = searchResultEntry.getAttribute("objectclass");
- if (oc == null) {
+ if (objectClassAttr == null) {
// No object classes.
throw new DefinitionDecodingException(d, Reason.NO_TYPE_INFORMATION);
}
final Set<String> objectClasses = new HashSet<String>();
- NamingEnumeration<?> values = oc.getAll();
- while (values.hasMore()) {
- Object value = values.next();
- if (value != null) {
- objectClasses.add(value.toString().toLowerCase().trim());
- }
+ for (ByteString byteValue : objectClassAttr) {
+ objectClasses.add(byteValue.toString().toLowerCase().trim());
}
if (objectClasses.isEmpty()) {
@@ -608,12 +551,10 @@
// Resolve the appropriate sub-type based on the object classes.
DefinitionResolver resolver = new DefinitionResolver() {
-
public boolean matches(AbstractManagedObjectDefinition<?, ?> d) {
String objectClass = profile.getObjectClass(d);
return objectClasses.contains(objectClass);
}
-
};
return d.resolveManagedObjectDefinition(resolver);
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPManagedObject.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPManagedObject.java
index be57134..243b260 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPManagedObject.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPManagedObject.java
@@ -27,20 +27,21 @@
package org.opends.server.admin.client.ldap;
-
-
-import javax.naming.NameAlreadyBoundException;
-import javax.naming.NamingException;
-import javax.naming.NoPermissionException;
-import javax.naming.OperationNotSupportedException;
-import javax.naming.directory.Attribute;
-import javax.naming.directory.Attributes;
-import javax.naming.directory.BasicAttribute;
-import javax.naming.directory.BasicAttributes;
-import javax.naming.ldap.LdapName;
-import javax.naming.ldap.Rdn;
+import java.util.List;
import org.forgerock.i18n.LocalizableMessage;
+import org.forgerock.opendj.ldap.Attribute;
+import org.forgerock.opendj.ldap.ByteString;
+import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.Entry;
+import org.forgerock.opendj.ldap.ErrorResultException;
+import org.forgerock.opendj.ldap.LinkedAttribute;
+import org.forgerock.opendj.ldap.LinkedHashMapEntry;
+import org.forgerock.opendj.ldap.ModificationType;
+import org.forgerock.opendj.ldap.RDN;
+import org.forgerock.opendj.ldap.ResultCode;
+import org.forgerock.opendj.ldap.requests.ModifyRequest;
+import org.forgerock.opendj.ldap.requests.Requests;
import org.opends.server.admin.AggregationPropertyDefinition;
import org.opends.server.admin.Configuration;
import org.opends.server.admin.ConfigurationClient;
@@ -56,8 +57,6 @@
import org.opends.server.admin.RelationDefinition;
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.UnknownPropertyDefinitionException;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ConcurrentModificationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.OperationRejectedException;
@@ -67,320 +66,268 @@
import org.opends.server.admin.client.spi.Property;
import org.opends.server.admin.client.spi.PropertySet;
-
-
/**
* A managed object bound to an LDAP connection.
*
* @param <T>
- * The type of client configuration represented by the client
- * managed object.
+ * The type of client configuration represented by the client managed
+ * object.
*/
-final class LDAPManagedObject<T extends ConfigurationClient> extends
- AbstractManagedObject<T> {
+final class LDAPManagedObject<T extends ConfigurationClient> extends AbstractManagedObject<T> {
- /**
- * A visitor which is used to encode property LDAP values.
- */
- private static final class ValueEncoder extends
- PropertyValueVisitor<Object, Void> {
+ /**
+ * A visitor which is used to encode property LDAP values.
+ */
+ private static final class ValueEncoder extends PropertyValueVisitor<Object, Void> {
- // Prevent instantiation.
- private ValueEncoder() {
- // No implementation required.
+ // Prevent instantiation.
+ private ValueEncoder() {
+ // No implementation required.
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public <C extends ConfigurationClient, S extends Configuration> Object visitAggregation(
+ AggregationPropertyDefinition<C, S> pd, String v, Void p) {
+ // Aggregations values are stored as full DNs in LDAP, but
+ // just their common name is exposed in the admin framework.
+ Reference<C, S> reference = Reference.parseName(pd.getParentPath(), pd.getRelationDefinition(), v);
+ return reference.toDN().toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public <PD> Object visitUnknown(PropertyDefinition<PD> pd, PD v, Void p)
+ throws UnknownPropertyDefinitionException {
+ return pd.encodeValue(v);
+ }
}
+ // The LDAP management driver associated with this managed object.
+ private final LDAPDriver driver;
+ /**
+ * Creates a new LDAP managed object instance.
+ *
+ * @param driver
+ * The underlying LDAP management driver.
+ * @param d
+ * The managed object's definition.
+ * @param path
+ * The managed object's path.
+ * @param properties
+ * The managed object's properties.
+ * @param existsOnServer
+ * Indicates whether or not the managed object already exists.
+ * @param namingPropertyDefinition
+ * The managed object's naming property definition if there is
+ * one.
+ */
+ LDAPManagedObject(LDAPDriver driver, ManagedObjectDefinition<T, ? extends Configuration> d,
+ ManagedObjectPath<T, ? extends Configuration> path, PropertySet properties, boolean existsOnServer,
+ PropertyDefinition<?> namingPropertyDefinition) {
+ super(d, path, properties, existsOnServer, namingPropertyDefinition);
+ this.driver = driver;
+ }
/**
* {@inheritDoc}
*/
@Override
- public <C extends ConfigurationClient, S extends Configuration>
- Object visitAggregation(
- AggregationPropertyDefinition<C, S> pd, String v, Void p) {
- // Aggregations values are stored as full DNs in LDAP, but
- // just their common name is exposed in the admin framework.
- Reference<C, S> reference = Reference.parseName(pd.getParentPath(), pd
- .getRelationDefinition(), v);
- return reference.toDN().toString();
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public <PD> Object visitUnknown(PropertyDefinition<PD> pd, PD v, Void p)
- throws UnknownPropertyDefinitionException {
- return pd.encodeValue(v);
- }
- }
-
-
-
- // The LDAP management driver associated with this managed object.
- private final LDAPDriver driver;
-
-
-
- /**
- * Creates a new LDAP managed object instance.
- *
- * @param driver
- * The underlying LDAP management driver.
- * @param d
- * The managed object's definition.
- * @param path
- * The managed object's path.
- * @param properties
- * The managed object's properties.
- * @param existsOnServer
- * Indicates whether or not the managed object already
- * exists.
- * @param namingPropertyDefinition
- * The managed object's naming property definition if there
- * is one.
- */
- LDAPManagedObject(LDAPDriver driver,
- ManagedObjectDefinition<T, ? extends Configuration> d,
- ManagedObjectPath<T, ? extends Configuration> path,
- PropertySet properties, boolean existsOnServer,
- PropertyDefinition<?> namingPropertyDefinition) {
- super(d, path, properties, existsOnServer, namingPropertyDefinition);
- this.driver = driver;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected void addNewManagedObject() throws AuthorizationException,
- CommunicationException, OperationRejectedException,
- ConcurrentModificationException, ManagedObjectAlreadyExistsException {
- // First make sure that the parent managed object still exists.
- ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
- ManagedObjectPath<?, ?> path = getManagedObjectPath();
- ManagedObjectPath<?, ?> parent = path.parent();
-
- try {
- if (!driver.managedObjectExists(parent)) {
- throw new ConcurrentModificationException();
- }
- } catch (ManagedObjectNotFoundException e) {
- throw new ConcurrentModificationException();
- }
-
- // We may need to create the parent "relation" entry if this is a
- // child of an instantiable or set relation.
- RelationDefinition<?, ?> r = path.getRelationDefinition();
- if (r instanceof InstantiableRelationDefinition
- || r instanceof SetRelationDefinition) {
-
- // TODO: this implementation does not handle relations which
- // comprise of more than one RDN arc (this will probably never
- // be required anyway).
- LdapName dn;
- if (r instanceof InstantiableRelationDefinition) {
- dn = LDAPNameBuilder.create(parent,
- (InstantiableRelationDefinition) r, driver.getLDAPProfile());
- } else {
- dn = LDAPNameBuilder.create(parent,
- (SetRelationDefinition) r, driver.getLDAPProfile());
- }
-
- if (!driver.entryExists(dn)) {
- // We need to create the entry.
- Attributes attributes = new BasicAttributes();
-
- // Create the branch's object class attribute.
- Attribute oc = new BasicAttribute("objectClass");
- for (String objectClass : driver.getLDAPProfile()
- .getRelationObjectClasses(r)) {
- oc.add(objectClass);
- }
- attributes.put(oc);
-
- // Create the branch's naming attribute.
- Rdn rdn = dn.getRdn(dn.size() - 1);
- attributes.put(rdn.getType(), rdn.getValue().toString());
-
- // Create the entry.
- try {
- driver.getLDAPConnection().createEntry(dn, attributes);
- } catch (OperationNotSupportedException e) {
- // Unwilling to perform.
- if (e.getMessage() == null) {
- throw new OperationRejectedException(OperationType.CREATE, d
- .getUserFriendlyName());
- } else {
- LocalizableMessage m = LocalizableMessage.raw("%s", e.getMessage());
- throw new OperationRejectedException(OperationType.CREATE, d
- .getUserFriendlyName(), m);
- }
- } catch (NamingException e) {
- driver.adaptNamingException(e);
- }
- }
- }
-
- // Now add the entry representing this new managed object.
- LdapName dn = LDAPNameBuilder.create(path, driver.getLDAPProfile());
- Attributes attributes = new BasicAttributes(true);
-
- // Create the object class attribute.
- Attribute oc = new BasicAttribute("objectclass");
- ManagedObjectDefinition<?, ?> definition = getManagedObjectDefinition();
- for (String objectClass : driver.getLDAPProfile().getObjectClasses(
- definition)) {
- oc.add(objectClass);
- }
- attributes.put(oc);
-
- // Create the naming attribute if there is not naming property.
- PropertyDefinition<?> npd = getNamingPropertyDefinition();
- if (npd == null) {
- Rdn rdn = dn.getRdn(dn.size() - 1);
- attributes.put(rdn.getType(), rdn.getValue().toString());
- }
-
- // Create the remaining attributes.
- for (PropertyDefinition<?> pd : definition.getAllPropertyDefinitions()) {
- String attrID = driver.getLDAPProfile().getAttributeName(definition, pd);
- Attribute attribute = new BasicAttribute(attrID);
- encodeProperty(attribute, pd);
- if (attribute.size() != 0) {
- attributes.put(attribute);
- }
- }
-
- try {
- // Create the entry.
- driver.getLDAPConnection().createEntry(dn, attributes);
- } catch (NameAlreadyBoundException e) {
- throw new ManagedObjectAlreadyExistsException();
- } catch (OperationNotSupportedException e) {
- // Unwilling to perform.
- if (e.getMessage() == null) {
- throw new OperationRejectedException(OperationType.CREATE, d
- .getUserFriendlyName());
- } else {
- LocalizableMessage m = LocalizableMessage.raw("%s", e.getMessage());
- throw new OperationRejectedException(OperationType.CREATE, d
- .getUserFriendlyName(), m);
- }
- } catch (NamingException e) {
- driver.adaptNamingException(e);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected Driver getDriver() {
- return driver;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected void modifyExistingManagedObject()
- throws ConcurrentModificationException, OperationRejectedException,
- AuthorizationException, CommunicationException {
- // Build the list of modified attributes.
- Attributes mods = new BasicAttributes();
- ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
- for (PropertyDefinition<?> pd : d.getAllPropertyDefinitions()) {
- Property<?> p = getProperty(pd);
- if (p.isModified()) {
- String attrID = driver.getLDAPProfile().getAttributeName(d, pd);
- Attribute attribute = new BasicAttribute(attrID);
- encodeProperty(attribute, pd);
- mods.put(attribute);
- }
- }
-
- // Perform the LDAP modification if something has changed.
- if (mods.size() > 0) {
- try {
+ protected void addNewManagedObject() throws ErrorResultException, OperationRejectedException,
+ ConcurrentModificationException, ManagedObjectAlreadyExistsException {
+ // First make sure that the parent managed object still exists.
+ ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
ManagedObjectPath<?, ?> path = getManagedObjectPath();
- LdapName dn = LDAPNameBuilder.create(path, driver.getLDAPProfile());
- driver.getLDAPConnection().modifyEntry(dn, mods);
- } catch (NoPermissionException e) {
- throw new AuthorizationException(e);
- } catch (OperationNotSupportedException e) {
- // Unwilling to perform.
- if (e.getMessage() == null) {
- throw new OperationRejectedException(OperationType.MODIFY, d
- .getUserFriendlyName());
- } else {
- LocalizableMessage m = LocalizableMessage.raw("%s", e.getMessage());
- throw new OperationRejectedException(OperationType.MODIFY, d
- .getUserFriendlyName(), m);
+ ManagedObjectPath<?, ?> parent = path.parent();
+
+ try {
+ if (!driver.managedObjectExists(parent)) {
+ throw new ConcurrentModificationException();
+ }
+ } catch (ManagedObjectNotFoundException e) {
+ throw new ConcurrentModificationException();
}
- } catch (NamingException e) {
- // Just treat it as a communication problem.
- throw new CommunicationException(e);
- }
+
+ // We may need to create the parent "relation" entry if this is a
+ // child of an instantiable or set relation.
+ RelationDefinition<?, ?> r = path.getRelationDefinition();
+ if (r instanceof InstantiableRelationDefinition || r instanceof SetRelationDefinition) {
+
+ // TODO: this implementation does not handle relations which
+ // comprise of more than one RDN arc (this will probably never
+ // be required anyway).
+ DN dn;
+ if (r instanceof InstantiableRelationDefinition) {
+ dn = LDAPNameBuilder.create(parent, (InstantiableRelationDefinition) r, driver.getLDAPProfile());
+ } else {
+ dn = LDAPNameBuilder.create(parent, (SetRelationDefinition) r, driver.getLDAPProfile());
+ }
+
+ if (!driver.entryExists(dn)) {
+ Entry entry = new LinkedHashMapEntry(dn);
+
+ // Create the branch's object class attribute.
+ List<String> objectClasses = driver.getLDAPProfile().getRelationObjectClasses(r);
+ addObjectClassesToEntry(objectClasses, entry);
+
+ // Create the branch's naming attribute.
+ RDN rdn = dn.parent(dn.size() - 1).rdn();
+ entry.addAttribute(rdn.getFirstAVA().toAttribute());
+
+ // Create the entry.
+ try {
+ driver.getLDAPConnection().createEntry(entry);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.UNWILLING_TO_PERFORM) {
+ LocalizableMessage m = LocalizableMessage.raw("%s", e.getLocalizedMessage());
+ throw new OperationRejectedException(OperationType.CREATE, d.getUserFriendlyName(), m);
+ } else {
+ throw e;
+ }
+ }
+ }
+ }
+
+ // Now add the entry representing this new managed object.
+ DN dn = LDAPNameBuilder.create(path, driver.getLDAPProfile());
+ Entry entry = new LinkedHashMapEntry(dn);
+
+ // Create the object class attribute.
+ ManagedObjectDefinition<?, ?> definition = getManagedObjectDefinition();
+ List<String> objectClasses = driver.getLDAPProfile().getObjectClasses(definition);
+ addObjectClassesToEntry(objectClasses, entry);
+
+ // Create the naming attribute if there is not naming property.
+ PropertyDefinition<?> namingPropertyDef = getNamingPropertyDefinition();
+ if (namingPropertyDef == null) {
+ RDN rdn = dn.parent(dn.size() - 1).rdn();
+ entry.addAttribute(rdn.getFirstAVA().toAttribute());
+ }
+
+ // Create the remaining attributes.
+ for (PropertyDefinition<?> propertyDef : definition.getAllPropertyDefinitions()) {
+ String attrID = driver.getLDAPProfile().getAttributeName(definition, propertyDef);
+ Attribute attribute = new LinkedAttribute(attrID);
+ encodeProperty(attribute, propertyDef);
+ if (attribute.size() != 0) {
+ entry.addAttribute(attribute);
+ }
+ }
+
+ try {
+ // Create the entry.
+ driver.getLDAPConnection().createEntry(entry);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.ENTRY_ALREADY_EXISTS) {
+ throw new ManagedObjectAlreadyExistsException();
+ } else if (e.getResult().getResultCode() == ResultCode.UNWILLING_TO_PERFORM) {
+ LocalizableMessage m = LocalizableMessage.raw("%s", e.getLocalizedMessage());
+ throw new OperationRejectedException(OperationType.CREATE, d.getUserFriendlyName(), m);
+ } else {
+ throw e;
+ }
+ }
}
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- protected <M extends ConfigurationClient> ManagedObject<M> newInstance(
- ManagedObjectDefinition<M, ?> d, ManagedObjectPath<M, ?> path,
- PropertySet properties, boolean existsOnServer,
- PropertyDefinition<?> namingPropertyDefinition) {
- return new LDAPManagedObject<M>(driver, d, path, properties,
- existsOnServer, namingPropertyDefinition);
- }
-
-
-
- // Encode a property into LDAP string values.
- private <PD> void encodeProperty(Attribute attribute,
- PropertyDefinition<PD> pd) {
- PropertyValueVisitor<Object, Void> visitor = new ValueEncoder();
- Property<PD> p = getProperty(pd);
- if (pd.hasOption(PropertyOption.MANDATORY)) {
- // For mandatory properties we fall-back to the default values
- // if defined which can sometimes be the case e.g when a
- // mandatory property is overridden.
- for (PD value : p.getEffectiveValues()) {
- attribute.add(pd.accept(visitor, value, null));
- }
- } else {
- for (PD value : p.getPendingValues()) {
- attribute.add(pd.accept(visitor, value, null));
- }
+ private void addObjectClassesToEntry(List<String> objectClasses, Entry entry) {
+ for (String objectClass : objectClasses) {
+ Attribute attr = new LinkedAttribute("objectClass");
+ attr.add(ByteString.valueOf(objectClass));
+ entry.addAttribute(attr);
+ }
}
- }
- /**
- * {@inheritDoc}
- */
- public boolean isModified() {
- ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
- for (PropertyDefinition<?> pd : d.getAllPropertyDefinitions()) {
- Property<?> p = getProperty(pd);
- if (p.isModified()) {
- return true;
- }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected Driver getDriver() {
+ return driver;
}
- return false;
- }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void modifyExistingManagedObject() throws ConcurrentModificationException, OperationRejectedException,
+ ErrorResultException {
+ // Build the modify request
+ ManagedObjectPath<?, ?> path = getManagedObjectPath();
+ DN dn = LDAPNameBuilder.create(path, driver.getLDAPProfile());
+ ModifyRequest request = Requests.newModifyRequest(dn);
+ ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
+ for (PropertyDefinition<?> pd : d.getAllPropertyDefinitions()) {
+ Property<?> p = getProperty(pd);
+ if (p.isModified()) {
+ String attrID = driver.getLDAPProfile().getAttributeName(d, pd);
+ Attribute attribute = new LinkedAttribute(attrID);
+ encodeProperty(attribute, pd);
+ request.addModification(ModificationType.REPLACE, attrID,
+ attribute.toArray(new Object[attribute.size()]));
+ }
+ }
+
+ // Perform the LDAP modification if something has changed.
+ if (!request.getModifications().isEmpty()) {
+ try {
+ driver.getLDAPConnection().modifyEntry(request);
+ } catch (ErrorResultException e) {
+ if (e.getResult().getResultCode() == ResultCode.UNWILLING_TO_PERFORM) {
+ LocalizableMessage m = LocalizableMessage.raw("%s", e.getLocalizedMessage());
+ throw new OperationRejectedException(OperationType.CREATE, d.getUserFriendlyName(), m);
+ } else {
+ throw e;
+ }
+ }
+
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected <M extends ConfigurationClient> ManagedObject<M> newInstance(ManagedObjectDefinition<M, ?> d,
+ ManagedObjectPath<M, ?> path, PropertySet properties, boolean existsOnServer,
+ PropertyDefinition<?> namingPropertyDefinition) {
+ return new LDAPManagedObject<M>(driver, d, path, properties, existsOnServer, namingPropertyDefinition);
+ }
+
+ // Encode a property into LDAP string values.
+ private <PD> void encodeProperty(Attribute attribute, PropertyDefinition<PD> propertyDef) {
+ PropertyValueVisitor<Object, Void> visitor = new ValueEncoder();
+ Property<PD> property = getProperty(propertyDef);
+ if (propertyDef.hasOption(PropertyOption.MANDATORY)) {
+ // For mandatory properties we fall-back to the default values
+ // if defined which can sometimes be the case e.g when a
+ // mandatory property is overridden.
+ for (PD value : property.getEffectiveValues()) {
+ attribute.add(propertyDef.accept(visitor, value, null));
+ }
+ } else {
+ for (PD value : property.getPendingValues()) {
+ attribute.add(propertyDef.accept(visitor, value, null));
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean isModified() {
+ ManagedObjectDefinition<?, ?> d = getManagedObjectDefinition();
+ for (PropertyDefinition<?> pd : d.getAllPropertyDefinitions()) {
+ Property<?> p = getProperty(pd);
+ if (p.isModified()) {
+ return true;
+ }
+ }
+ return false;
+ }
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPNameBuilder.java b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPNameBuilder.java
index 0bbc756..6602373 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPNameBuilder.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/ldap/LDAPNameBuilder.java
@@ -27,14 +27,11 @@
package org.opends.server.admin.client.ldap;
-
-
+import java.util.Collections;
import java.util.LinkedList;
-import javax.naming.InvalidNameException;
-import javax.naming.ldap.LdapName;
-import javax.naming.ldap.Rdn;
-
+import org.forgerock.opendj.ldap.DN;
+import org.forgerock.opendj.ldap.RDN;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.Configuration;
import org.opends.server.admin.ConfigurationClient;
@@ -47,200 +44,161 @@
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.SingletonRelationDefinition;
-
-
/**
- * A strategy for creating <code>LdapName</code>s from managed object paths.
+ * A strategy for creating <code>DN</code>s from managed object paths.
*/
final class LDAPNameBuilder implements ManagedObjectPathSerializer {
- /**
- * Creates a new LDAP name representing the specified managed object
- * path.
- *
- * @param path
- * The managed object path.
- * @param profile
- * The LDAP profile which should be used to construct LDAP
- * names.
- * @return Returns a new LDAP name representing the specified
- * managed object path.
- */
- public static LdapName create(ManagedObjectPath<?, ?> path,
- LDAPProfile profile) {
- LDAPNameBuilder builder = new LDAPNameBuilder(profile);
- path.serialize(builder);
- return builder.getInstance();
- }
-
-
-
- /**
- * Creates a new LDAP name representing the specified managed object
- * path and instantiable relation.
- *
- * @param path
- * The managed object path.
- * @param relation
- * The child instantiable relation.
- * @param profile
- * The LDAP profile which should be used to construct LDAP
- * names.
- * @return Returns a new LDAP name representing the specified
- * managed object path and instantiable relation.
- */
- public static LdapName create(ManagedObjectPath<?, ?> path,
- InstantiableRelationDefinition<?, ?> relation, LDAPProfile profile) {
- LDAPNameBuilder builder = new LDAPNameBuilder(profile);
- path.serialize(builder);
- builder.appendManagedObjectPathElement(relation);
- return builder.getInstance();
- }
-
-
-
- /**
- * Creates a new LDAP name representing the specified managed object
- * path and set relation.
- *
- * @param path
- * The managed object path.
- * @param relation
- * The child set relation.
- * @param profile
- * The LDAP profile which should be used to construct LDAP
- * names.
- * @return Returns a new LDAP name representing the specified
- * managed object path and set relation.
- */
- public static LdapName create(ManagedObjectPath<?, ?> path,
- SetRelationDefinition<?, ?> relation, LDAPProfile profile) {
- LDAPNameBuilder builder = new LDAPNameBuilder(profile);
- path.serialize(builder);
- builder.appendManagedObjectPathElement(relation);
- return builder.getInstance();
- }
-
- // The list of RDNs in big-endian order.
- private final LinkedList<Rdn> rdns;
-
- // The LDAP profile.
- private final LDAPProfile profile;
-
-
-
- /**
- * Create a new JNDI LDAP name builder.
- *
- * @param profile
- * The LDAP profile which should be used to construct LDAP
- * names.
- */
- public LDAPNameBuilder(LDAPProfile profile) {
- this.rdns = new LinkedList<Rdn>();
- this.profile = profile;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- public <C extends ConfigurationClient, S extends Configuration>
- void appendManagedObjectPathElement(
- InstantiableRelationDefinition<? super C, ? super S> r,
- AbstractManagedObjectDefinition<C, S> d, String name) {
- // Add the RDN sequence representing the relation.
- appendManagedObjectPathElement(r);
-
- // Now add the single RDN representing the named instance.
- String type = profile.getRelationChildRDNType(r);
- try {
- Rdn rdn = new Rdn(type, name.trim());
- rdns.add(rdn);
- } catch (InvalidNameException e1) {
- // Should not happen.
- throw new RuntimeException(e1);
+ /**
+ * Creates a new DN representing the specified managed object path.
+ *
+ * @param path
+ * The managed object path.
+ * @param profile
+ * The LDAP profile which should be used to construct LDAP names.
+ * @return Returns a new DN representing the specified managed object path.
+ */
+ public static DN create(ManagedObjectPath<?, ?> path, LDAPProfile profile) {
+ LDAPNameBuilder builder = new LDAPNameBuilder(profile);
+ path.serialize(builder);
+ return builder.getInstance();
}
- }
-
-
- /**
- * Appends the RDN sequence representing the provided relation.
- *
- * @param r
- * The relation definition.
- */
- public void appendManagedObjectPathElement(RelationDefinition<?, ?> r) {
- // Add the RDN sequence representing the relation.
- try {
- LdapName tmp = new LdapName(profile.getRelationRDNSequence(r));
- rdns.addAll(tmp.getRdns());
- } catch (InvalidNameException e1) {
- // Should not happen.
- throw new RuntimeException(e1);
+ /**
+ * Creates a new DN representing the specified managed object path and
+ * instantiable relation.
+ *
+ * @param path
+ * The managed object path.
+ * @param relation
+ * The child instantiable relation.
+ * @param profile
+ * The LDAP profile which should be used to construct LDAP names.
+ * @return Returns a new DN representing the specified managed object path
+ * and instantiable relation.
+ */
+ public static DN create(ManagedObjectPath<?, ?> path, InstantiableRelationDefinition<?, ?> relation,
+ LDAPProfile profile) {
+ LDAPNameBuilder builder = new LDAPNameBuilder(profile);
+ path.serialize(builder);
+ builder.appendManagedObjectPathElement(relation);
+ return builder.getInstance();
}
- }
-
-
- /**
- * {@inheritDoc}
- */
- public <C extends ConfigurationClient, S extends Configuration>
- void appendManagedObjectPathElement(
- OptionalRelationDefinition<? super C, ? super S> r,
- AbstractManagedObjectDefinition<C, S> d) {
- // Add the RDN sequence representing the relation.
- appendManagedObjectPathElement(r);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- public <C extends ConfigurationClient, S extends Configuration>
- void appendManagedObjectPathElement(
- SingletonRelationDefinition<? super C, ? super S> r,
- AbstractManagedObjectDefinition<C, S> d) {
- // Add the RDN sequence representing the relation.
- appendManagedObjectPathElement(r);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- public <C extends ConfigurationClient, S extends Configuration>
- void appendManagedObjectPathElement(
- SetRelationDefinition<? super C, ? super S> r,
- AbstractManagedObjectDefinition<C, S> d) {
- // Add the RDN sequence representing the relation.
- appendManagedObjectPathElement(r);
-
- // Now add the single RDN representing the named instance.
- String type = profile.getRelationChildRDNType(r);
- try {
- Rdn rdn = new Rdn(type, d.getName());
- rdns.add(rdn);
- } catch (InvalidNameException e1) {
- // Should not happen.
- throw new RuntimeException(e1);
+ /**
+ * Creates a new DN representing the specified managed object path and set
+ * relation.
+ *
+ * @param path
+ * The managed object path.
+ * @param relation
+ * The child set relation.
+ * @param profile
+ * The LDAP profile which should be used to construct LDAP names.
+ * @return Returns a new DN representing the specified managed object path
+ * and set relation.
+ */
+ public static DN create(ManagedObjectPath<?, ?> path, SetRelationDefinition<?, ?> relation, LDAPProfile profile) {
+ LDAPNameBuilder builder = new LDAPNameBuilder(profile);
+ path.serialize(builder);
+ builder.appendManagedObjectPathElement(relation);
+ return builder.getInstance();
}
- }
+ // The list of RDNs in big-endian order.
+ private final LinkedList<RDN> rdns;
+ // The LDAP profile.
+ private final LDAPProfile profile;
- /**
- * Create a new JNDI LDAP name using the current state of this LDAP name
- * builder.
- *
- * @return Returns the new JNDI LDAP name instance.
- */
- public LdapName getInstance() {
- return new LdapName(rdns);
- }
+ /**
+ * Create a new DN builder.
+ *
+ * @param profile
+ * The LDAP profile which should be used to construct DNs.
+ */
+ public LDAPNameBuilder(LDAPProfile profile) {
+ this.rdns = new LinkedList<RDN>();
+ this.profile = profile;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public <C extends ConfigurationClient, S extends Configuration> void appendManagedObjectPathElement(
+ InstantiableRelationDefinition<? super C, ? super S> r, AbstractManagedObjectDefinition<C, S> d, String name) {
+ // Add the RDN sequence representing the relation.
+ appendManagedObjectPathElement(r);
+
+ // Now add the single RDN representing the named instance.
+ String type = profile.getRelationChildRDNType(r);
+ RDN rdn = new RDN(type, name.trim());
+ rdns.add(rdn);
+
+ }
+
+ /**
+ * Appends the RDN sequence representing the provided relation.
+ *
+ * @param r
+ * The relation definition.
+ */
+ public void appendManagedObjectPathElement(RelationDefinition<?, ?> r) {
+ // Add the RDN sequence representing the relation.
+ DN dn = DN.valueOf(profile.getRelationRDNSequence(r));
+ for (RDN rdn : dn) {
+ rdns.add(rdn);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public <C extends ConfigurationClient, S extends Configuration> void appendManagedObjectPathElement(
+ OptionalRelationDefinition<? super C, ? super S> r, AbstractManagedObjectDefinition<C, S> d) {
+ // Add the RDN sequence representing the relation.
+ appendManagedObjectPathElement(r);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public <C extends ConfigurationClient, S extends Configuration> void appendManagedObjectPathElement(
+ SingletonRelationDefinition<? super C, ? super S> r, AbstractManagedObjectDefinition<C, S> d) {
+ // Add the RDN sequence representing the relation.
+ appendManagedObjectPathElement(r);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public <C extends ConfigurationClient, S extends Configuration> void appendManagedObjectPathElement(
+ SetRelationDefinition<? super C, ? super S> r, AbstractManagedObjectDefinition<C, S> d) {
+ // Add the RDN sequence representing the relation.
+ appendManagedObjectPathElement(r);
+
+ // Now add the single RDN representing the named instance.
+ String type = profile.getRelationChildRDNType(r);
+ RDN rdn = new RDN(type, d.getName());
+ rdns.add(rdn);
+ }
+
+ /**
+ * Create a new DN using the current state of this builder.
+ *
+ * @return Returns the new DN instance.
+ */
+ public DN getInstance() {
+ if (rdns.isEmpty()) {
+ return DN.rootDN();
+ }
+ else {
+ Collections.reverse(rdns);
+ DN dn = DN.valueOf(rdns.removeFirst().toString());
+ for (RDN rdn : rdns) {
+ dn = dn.child(rdn);
+ }
+ return dn;
+ }
+ }
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/spi/AbstractManagedObject.java b/opendj-admin/src/main/java/org/opends/server/admin/client/spi/AbstractManagedObject.java
index f5b268e..ca68c86 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/spi/AbstractManagedObject.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/spi/AbstractManagedObject.java
@@ -35,6 +35,7 @@
import java.util.TreeSet;
import org.forgerock.i18n.LocalizableMessage;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.Configuration;
import org.opends.server.admin.ConfigurationClient;
@@ -60,9 +61,7 @@
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.SingletonRelationDefinition;
import org.opends.server.admin.DefinitionDecodingException.Reason;
-import org.opends.server.admin.client.AuthorizationException;
import org.opends.server.admin.client.ClientConstraintHandler;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ConcurrentModificationException;
import org.opends.server.admin.client.IllegalManagedObjectNameException;
import org.opends.server.admin.client.ManagedObject;
@@ -88,8 +87,6 @@
private final class DefaultManagedObjectFactory implements RelationDefinitionVisitor<Void, Void> {
// Possible exceptions.
- private AuthorizationException ae = null;
-
private ManagedObjectAlreadyExistsException moaee = null;
private MissingMandatoryPropertiesException mmpe = null;
@@ -98,7 +95,7 @@
private OperationRejectedException ore = null;
- private CommunicationException ce = null;
+ private ErrorResultException ere = null;
/**
* {@inheritDoc}
@@ -167,8 +164,6 @@
try {
child.commit();
- } catch (AuthorizationException e) {
- ae = e;
} catch (ManagedObjectAlreadyExistsException e) {
moaee = e;
} catch (MissingMandatoryPropertiesException e) {
@@ -177,8 +172,8 @@
cme = e;
} catch (OperationRejectedException e) {
ore = e;
- } catch (CommunicationException e) {
- ce = e;
+ } catch (ErrorResultException e) {
+ ere = e;
}
}
@@ -189,15 +184,13 @@
* @param rd
* The relation definition.
*/
- private void createDefaultManagedObjects(RelationDefinition<?, ?> rd) throws AuthorizationException,
- CommunicationException, ConcurrentModificationException, MissingMandatoryPropertiesException,
+ private void createDefaultManagedObjects(RelationDefinition<?, ?> rd) throws ErrorResultException,
+ ConcurrentModificationException, MissingMandatoryPropertiesException,
ManagedObjectAlreadyExistsException, OperationRejectedException {
rd.accept(this, null);
- if (ae != null) {
- throw ae;
- } else if (ce != null) {
- throw ce;
+ if (ere != null) {
+ throw ere;
} else if (cme != null) {
throw cme;
} else if (mmpe != null) {
@@ -264,7 +257,7 @@
* {@inheritDoc}
*/
public final void commit() throws ManagedObjectAlreadyExistsException, MissingMandatoryPropertiesException,
- ConcurrentModificationException, OperationRejectedException, AuthorizationException, CommunicationException {
+ ConcurrentModificationException, OperationRejectedException, ErrorResultException {
// First make sure all mandatory properties are defined.
List<PropertyIsMandatoryException> exceptions = new LinkedList<PropertyIsMandatoryException>();
@@ -389,7 +382,7 @@
public final <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
InstantiableRelationDefinition<C, S> r, String name) throws IllegalArgumentException,
DefinitionDecodingException, ManagedObjectDecodingException, ManagedObjectNotFoundException,
- ConcurrentModificationException, AuthorizationException, CommunicationException {
+ ConcurrentModificationException, ErrorResultException {
validateRelationDefinition(r);
ensureThisManagedObjectExists();
Driver ctx = getDriver();
@@ -402,7 +395,7 @@
public final <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
OptionalRelationDefinition<C, S> r) throws IllegalArgumentException, DefinitionDecodingException,
ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
ensureThisManagedObjectExists();
Driver ctx = getDriver();
@@ -415,7 +408,7 @@
public final <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
SingletonRelationDefinition<C, S> r) throws IllegalArgumentException, DefinitionDecodingException,
ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
ensureThisManagedObjectExists();
Driver ctx = getDriver();
@@ -428,7 +421,7 @@
public final <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getChild(
SetRelationDefinition<C, S> r, String name) throws IllegalArgumentException, DefinitionDecodingException,
ManagedObjectDecodingException, ManagedObjectNotFoundException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
ensureThisManagedObjectExists();
Driver ctx = getDriver();
@@ -499,7 +492,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean hasChild(
OptionalRelationDefinition<C, S> r) throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
try {
@@ -521,7 +514,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
InstantiableRelationDefinition<C, S> r) throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
return listChildren(r, r.getChildDefinition());
}
@@ -530,8 +523,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
InstantiableRelationDefinition<C, S> r, AbstractManagedObjectDefinition<? extends C, ? extends S> d)
- throws IllegalArgumentException, ConcurrentModificationException, AuthorizationException,
- CommunicationException {
+ throws IllegalArgumentException, ConcurrentModificationException, ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
try {
@@ -546,7 +538,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
SetRelationDefinition<C, S> r) throws IllegalArgumentException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
return listChildren(r, r.getChildDefinition());
}
@@ -555,8 +547,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> String[] listChildren(
SetRelationDefinition<C, S> r, AbstractManagedObjectDefinition<? extends C, ? extends S> d)
- throws IllegalArgumentException, ConcurrentModificationException, AuthorizationException,
- CommunicationException {
+ throws IllegalArgumentException, ConcurrentModificationException, ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
try {
@@ -572,7 +563,7 @@
public final <C extends ConfigurationClient, S extends Configuration> void removeChild(
InstantiableRelationDefinition<C, S> r, String name) throws IllegalArgumentException,
ManagedObjectNotFoundException, OperationRejectedException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
boolean found;
@@ -593,7 +584,7 @@
*/
public final <C extends ConfigurationClient, S extends Configuration> void removeChild(
OptionalRelationDefinition<C, S> r) throws IllegalArgumentException, ManagedObjectNotFoundException,
- OperationRejectedException, ConcurrentModificationException, AuthorizationException, CommunicationException {
+ OperationRejectedException, ConcurrentModificationException, ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
boolean found;
@@ -615,7 +606,7 @@
public final <C extends ConfigurationClient, S extends Configuration> void removeChild(
SetRelationDefinition<C, S> r, String name) throws IllegalArgumentException,
ManagedObjectNotFoundException, OperationRejectedException, ConcurrentModificationException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(r);
Driver ctx = getDriver();
boolean found;
@@ -702,14 +693,10 @@
* @throws OperationRejectedException
* If the managed object cannot be added due to some client-side
* or server-side constraint which cannot be satisfied.
- * @throws AuthorizationException
- * If the server refuses to add this managed object because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
- protected abstract void addNewManagedObject() throws AuthorizationException, CommunicationException,
+ protected abstract void addNewManagedObject() throws ErrorResultException,
OperationRejectedException, ConcurrentModificationException, ManagedObjectAlreadyExistsException;
/**
@@ -765,7 +752,7 @@
* communication problem.
*/
protected abstract void modifyExistingManagedObject() throws ConcurrentModificationException,
- OperationRejectedException, AuthorizationException, CommunicationException;
+ OperationRejectedException, ErrorResultException;
/**
* Creates a new managed object.
@@ -833,8 +820,7 @@
}
// Makes sure that this managed object exists.
- private void ensureThisManagedObjectExists() throws ConcurrentModificationException, CommunicationException,
- AuthorizationException {
+ private void ensureThisManagedObjectExists() throws ConcurrentModificationException, ErrorResultException {
if (!path.isEmpty()) {
Driver ctx = getDriver();
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/client/spi/Driver.java b/opendj-admin/src/main/java/org/opends/server/admin/client/spi/Driver.java
index f88c255..054d361 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/client/spi/Driver.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/client/spi/Driver.java
@@ -36,6 +36,7 @@
import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.opendj.admin.client.RootCfgClient;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbsoluteInheritedDefaultBehaviorProvider;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.AliasDefaultBehaviorProvider;
@@ -61,9 +62,7 @@
import org.opends.server.admin.SetRelationDefinition;
import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
import org.opends.server.admin.DefinitionDecodingException.Reason;
-import org.opends.server.admin.client.AuthorizationException;
import org.opends.server.admin.client.ClientConstraintHandler;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagedObjectDecodingException;
import org.opends.server.admin.client.ManagementContext;
@@ -242,12 +241,10 @@
throw new DefaultBehaviorException(pd1, e);
} catch (PropertyNotFoundException e) {
throw new DefaultBehaviorException(pd1, e);
- } catch (AuthorizationException e) {
+ } catch (ErrorResultException e) {
throw new DefaultBehaviorException(pd1, e);
} catch (ManagedObjectNotFoundException e) {
throw new DefaultBehaviorException(pd1, e);
- } catch (CommunicationException e) {
- throw new DefaultBehaviorException(pd1, e);
} catch (PropertyException e) {
throw new DefaultBehaviorException(pd1, e);
}
@@ -296,17 +293,13 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd, String name)
throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(parent, rd);
ManagedObjectPath<?, ?> child = parent.child(rd, name);
return doDeleteManagedObject(child);
@@ -338,16 +331,12 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, OptionalRelationDefinition<C, S> rd) throws IllegalArgumentException,
- ManagedObjectNotFoundException, OperationRejectedException, AuthorizationException, CommunicationException {
+ ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException {
validateRelationDefinition(parent, rd);
ManagedObjectPath<?, ?> child = parent.child(rd);
return doDeleteManagedObject(child);
@@ -381,17 +370,13 @@
* client-side or server-side constraint which cannot be
* satisfied (for example, if it is referenced by another
* managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public final <C extends ConfigurationClient, S extends Configuration> boolean deleteManagedObject(
ManagedObjectPath<?, ?> parent, SetRelationDefinition<C, S> rd, String name)
throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
validateRelationDefinition(parent, rd);
ManagedObjectPath<?, ?> child = parent.child(rd, name);
return doDeleteManagedObject(child);
@@ -419,16 +404,12 @@
* @throws ManagedObjectNotFoundException
* If the requested managed object could not be found on the
* server.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public abstract <C extends ConfigurationClient, S extends Configuration> ManagedObject<? extends C> getManagedObject(
ManagedObjectPath<C, S> path) throws DefinitionDecodingException, ManagedObjectDecodingException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException;
+ ManagedObjectNotFoundException, ErrorResultException;
/**
* Gets the effective values of a property in the named managed object.
@@ -467,17 +448,12 @@
* @throws ManagedObjectNotFoundException
* If the requested managed object could not be found on the
* server.
- * @throws AuthorizationException
- * If the server refuses to retrieve the managed object because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public abstract <C extends ConfigurationClient, S extends Configuration, PD> SortedSet<PD> getPropertyValues(
ManagedObjectPath<C, S> path, PropertyDefinition<PD> pd) throws IllegalArgumentException,
- DefinitionDecodingException, AuthorizationException, ManagedObjectNotFoundException,
- CommunicationException, PropertyException;
+ DefinitionDecodingException, ManagedObjectNotFoundException, ErrorResultException, PropertyException;
/**
* Gets the root configuration managed object associated with this
@@ -511,17 +487,13 @@
* managed object's definition.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public abstract <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, InstantiableRelationDefinition<C, S> rd,
AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException;
+ ManagedObjectNotFoundException, ErrorResultException;
/**
* Lists the child managed objects of the named parent managed object which
@@ -546,17 +518,13 @@
* managed object's definition.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to list the managed objects because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public abstract <C extends ConfigurationClient, S extends Configuration> String[] listManagedObjects(
ManagedObjectPath<?, ?> parent, SetRelationDefinition<C, S> rd,
AbstractManagedObjectDefinition<? extends C, ? extends S> d) throws IllegalArgumentException,
- ManagedObjectNotFoundException, AuthorizationException, CommunicationException;
+ ManagedObjectNotFoundException, ErrorResultException;
/**
* Determines whether or not the named managed object exists.
@@ -570,15 +538,11 @@
* <code>false</code> otherwise.
* @throws ManagedObjectNotFoundException
* If the parent managed object could not be found.
- * @throws AuthorizationException
- * If the server refuses to make the determination because the
- * client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
public abstract boolean managedObjectExists(ManagedObjectPath<?, ?> path) throws ManagedObjectNotFoundException,
- AuthorizationException, CommunicationException;
+ ErrorResultException;
/**
* Deletes the named managed object.
@@ -598,16 +562,11 @@
* If the managed object cannot be removed due to some
* server-side constraint which cannot be satisfied (for
* example, if it is referenced by another managed object).
- * @throws AuthorizationException
- * If the server refuses to remove the managed objects because
- * the client does not have the correct privileges.
- * @throws CommunicationException
- * If the client cannot contact the server due to an underlying
- * communication problem.
+ * @throws ErrorResultException
+ * If any other error occurs.
*/
protected abstract <C extends ConfigurationClient, S extends Configuration> void deleteManagedObject(
- ManagedObjectPath<C, S> path) throws OperationRejectedException, AuthorizationException,
- CommunicationException;
+ ManagedObjectPath<C, S> path) throws OperationRejectedException, ErrorResultException;
/**
* Gets the default values for the specified property.
@@ -665,7 +624,7 @@
// constraints are satisfied.
private <C extends ConfigurationClient, S extends Configuration> boolean doDeleteManagedObject(
ManagedObjectPath<C, S> path) throws ManagedObjectNotFoundException, OperationRejectedException,
- AuthorizationException, CommunicationException {
+ ErrorResultException {
// First make sure that the parent exists.
if (!managedObjectExists(path.parent())) {
throw new ManagedObjectNotFoundException();
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/ANDCondition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/ANDCondition.java
index a3cb9a9..86b82e5 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/ANDCondition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/ANDCondition.java
@@ -29,9 +29,8 @@
import java.util.Arrays;
import java.util.List;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
@@ -62,8 +61,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
for (Condition condition : conditions) {
if (!condition.evaluate(context, managedObject)) {
return false;
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/Condition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/Condition.java
index 78d9254..30c3c6e 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/Condition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/Condition.java
@@ -26,69 +26,51 @@
*/
package org.opends.server.admin.condition;
-
-
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
import org.opends.server.config.ConfigException;
-
-
/**
* An interface for evaluating conditions.
*/
public interface Condition {
- /**
- * Initializes this condition.
- *
- * @param d
- * The abstract managed object definition associated with
- * this condition.
- * @throws Exception
- * If this condition could not be initialized.
- */
- void initialize(AbstractManagedObjectDefinition<?, ?> d) throws Exception;
+ /**
+ * Initializes this condition.
+ *
+ * @param d
+ * The abstract managed object definition associated with this
+ * condition.
+ * @throws Exception
+ * If this condition could not be initialized.
+ */
+ void initialize(AbstractManagedObjectDefinition<?, ?> d) throws Exception;
+ /**
+ * Evaluates this condition against the provided client managed object.
+ *
+ * @param context
+ * The client management context.
+ * @param managedObject
+ * The client managed object.
+ * @return Returns <code>true</code> if this condition is satisfied.
+ * @throws ErrorResultException
+ * If the condition could not be evaluated.
+ */
+ boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException;
-
- /**
- * Evaluates this condition against the provided client managed
- * object.
- *
- * @param context
- * The client management context.
- * @param managedObject
- * The client managed object.
- * @return Returns <code>true</code> if this condition is
- * satisfied.
- * @throws AuthorizationException
- * If the condition could not be evaluated due to an
- * authorization problem.
- * @throws CommunicationException
- * If the condition could not be evaluated due to an
- * communication problem.
- */
- boolean evaluate(ManagementContext context, ManagedObject<?> managedObject)
- throws AuthorizationException, CommunicationException;
-
-
-
- /**
- * Evaluates this condition against the provided server managed
- * object.
- *
- * @param managedObject
- * The server managed object.
- * @return Returns <code>true</code> if this condition is
- * satisfied.
- * @throws ConfigException
- * If the condition could not be evaluated due to an
- * unexpected configuration exception.
- */
- boolean evaluate(ServerManagedObject<?> managedObject) throws ConfigException;
+ /**
+ * Evaluates this condition against the provided server managed object.
+ *
+ * @param managedObject
+ * The server managed object.
+ * @return Returns <code>true</code> if this condition is satisfied.
+ * @throws ConfigException
+ * If the condition could not be evaluated due to an unexpected
+ * configuration exception.
+ */
+ boolean evaluate(ServerManagedObject<?> managedObject) throws ConfigException;
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/Conditions.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/Conditions.java
index 4f057ab..d39de3e 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/Conditions.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/Conditions.java
@@ -26,212 +26,167 @@
*/
package org.opends.server.admin.condition;
-
-
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
import org.opends.server.config.ConfigException;
-
-
/**
- * This class consists exclusively of static methods that operate on
- * or return conditions.
+ * This class consists exclusively of static methods that operate on or return
+ * conditions.
*/
public final class Conditions {
- /**
- * A condition which always evaluates to <code>false</code>.
- */
- public static final Condition FALSE = new Condition() {
+ /**
+ * A condition which always evaluates to <code>false</code>.
+ */
+ public static final Condition FALSE = new Condition() {
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean evaluate(ServerManagedObject<?> managedObject) throws ConfigException {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void initialize(AbstractManagedObjectDefinition<?, ?> d) throws Exception {
+ // No implementation required.
+ }
+
+ };
/**
- * {@inheritDoc}
+ * A condition which always evaluates to <code>true</code>.
*/
- public boolean evaluate(ManagementContext context,
- ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
- return false;
- }
+ public static final Condition TRUE = new Condition() {
+ /**
+ * {@inheritDoc}
+ */
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
+ return true;
+ }
+ /**
+ * {@inheritDoc}
+ */
+ public boolean evaluate(ServerManagedObject<?> managedObject) throws ConfigException {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void initialize(AbstractManagedObjectDefinition<?, ?> d) throws Exception {
+ // No implementation required.
+ }
+
+ };
/**
- * {@inheritDoc}
+ * Creates a condition which evaluates to <code>true</code> if and only if
+ * all of its sub-conditions are <code>true</code>.
+ *
+ * @param conditions
+ * The sub-conditions which be combined using a logical AND.
+ * @return Returns a condition which evaluates to <code>true</code> if and
+ * only if all of its sub-conditions are <code>true</code>.
*/
- public boolean evaluate(ServerManagedObject<?> managedObject)
- throws ConfigException {
- return false;
+ public static Condition and(Condition... conditions) {
+ return new ANDCondition(conditions);
}
-
-
/**
- * {@inheritDoc}
+ * Creates a condition which evaluates to <code>true</code> if and only if a
+ * property contains a particular value.
+ *
+ * @param propertyName
+ * The property name.
+ * @param propertyStringValue
+ * The string representation of the required property value.
+ * @return Returns a condition which evaluates to <code>true</code> if and
+ * only if a property contains a particular value.
*/
- public void initialize(AbstractManagedObjectDefinition<?, ?> d)
- throws Exception {
- // No implementation required.
+ public static Condition contains(String propertyName, String propertyStringValue) {
+ return new ContainsCondition(propertyName, propertyStringValue);
}
- };
-
- /**
- * A condition which always evaluates to <code>true</code>.
- */
- public static final Condition TRUE = new Condition() {
-
/**
- * {@inheritDoc}
+ * Creates a condition which evaluates to <code>false</code> if and only if
+ * the first sub-condition evaluates to <code>true</code> and the second
+ * sub-condition evaluates to <code>false</code>. This can be used to
+ * represent if-then relationships.
+ *
+ * @param premise
+ * The sub-condition which, when <code>true</code> implies that
+ * the implication sub-condition must also be <code>true</code>.
+ * @param implication
+ * The sub-condition which, must be <code>true</code> when the
+ * premise is <code>true</code>.
+ * @return Returns a condition which evaluates to <code>false</code> if and
+ * only if the first sub-condition evaluates to <code>true</code>
+ * and the second sub-condition evaluates to <code>false</code>.
*/
- public boolean evaluate(ManagementContext context,
- ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
- return true;
+ public static Condition implies(Condition premise, Condition implication) {
+ return or(not(premise), implication);
}
-
-
/**
- * {@inheritDoc}
+ * Creates a condition which evaluates to <code>true</code> if and only if a
+ * particular property has any values specified.
+ *
+ * @param propertyName
+ * The property name.
+ * @return Returns a condition which evaluates to <code>true</code> if and
+ * only if a particular property has any values specified.
*/
- public boolean evaluate(ServerManagedObject<?> managedObject)
- throws ConfigException {
- return true;
+ public static Condition isPresent(String propertyName) {
+ return new IsPresentCondition(propertyName);
}
-
-
/**
- * {@inheritDoc}
+ * Creates a condition which evaluates to <code>true</code> if the
+ * sub-condition is <code>false</code>, or <code>false</code> if the
+ * sub-condition is <code>true</code>.
+ *
+ * @param condition
+ * The sub-condition which will be inverted.
+ * @return Returns a condition which evaluates to <code>true</code> if the
+ * sub-condition is <code>false</code>, or <code>false</code> if the
+ * sub-condition is <code>true</code>.
*/
- public void initialize(AbstractManagedObjectDefinition<?, ?> d)
- throws Exception {
- // No implementation required.
+ public static Condition not(Condition condition) {
+ return new NOTCondition(condition);
}
- };
+ /**
+ * Creates a condition which evaluates to <code>false</code> if and only if
+ * all of its sub-conditions are <code>false</code>.
+ *
+ * @param conditions
+ * The sub-conditions which be combined using a logical OR.
+ * @return Returns a condition which evaluates to <code>false</code> if and
+ * only if all of its sub-conditions are <code>false</code>.
+ */
+ public static Condition or(Condition... conditions) {
+ return new ORCondition(conditions);
+ }
-
-
- /**
- * Creates a condition which evaluates to <code>true</code> if and
- * only if all of its sub-conditions are <code>true</code>.
- *
- * @param conditions
- * The sub-conditions which be combined using a logical
- * AND.
- * @return Returns a condition which evaluates to <code>true</code>
- * if and only if all of its sub-conditions are
- * <code>true</code>.
- */
- public static Condition and(Condition... conditions) {
- return new ANDCondition(conditions);
- }
-
-
-
- /**
- * Creates a condition which evaluates to <code>true</code> if and
- * only if a property contains a particular value.
- *
- * @param propertyName
- * The property name.
- * @param propertyStringValue
- * The string representation of the required property
- * value.
- * @return Returns a condition which evaluates to <code>true</code>
- * if and only if a property contains a particular value.
- */
- public static Condition contains(String propertyName,
- String propertyStringValue) {
- return new ContainsCondition(propertyName, propertyStringValue);
- }
-
-
-
- /**
- * Creates a condition which evaluates to <code>false</code> if
- * and only if the first sub-condition evaluates to
- * <code>true</code> and the second sub-condition evaluates to
- * <code>false</code>. This can be used to represent if-then
- * relationships.
- *
- * @param premise
- * The sub-condition which, when <code>true</code>
- * implies that the implication sub-condition must also be
- * <code>true</code>.
- * @param implication
- * The sub-condition which, must be <code>true</code>
- * when the premise is <code>true</code>.
- * @return Returns a condition which evaluates to <code>false</code>
- * if and only if the first sub-condition evaluates to
- * <code>true</code> and the second sub-condition
- * evaluates to <code>false</code>.
- */
- public static Condition implies(Condition premise, Condition implication) {
- return or(not(premise), implication);
- }
-
-
-
- /**
- * Creates a condition which evaluates to <code>true</code> if and
- * only if a particular property has any values specified.
- *
- * @param propertyName
- * The property name.
- * @return Returns a condition which evaluates to <code>true</code>
- * if and only if a particular property has any values
- * specified.
- */
- public static Condition isPresent(String propertyName) {
- return new IsPresentCondition(propertyName);
- }
-
-
-
- /**
- * Creates a condition which evaluates to <code>true</code> if the
- * sub-condition is <code>false</code>, or <code>false</code>
- * if the sub-condition is <code>true</code>.
- *
- * @param condition
- * The sub-condition which will be inverted.
- * @return Returns a condition which evaluates to <code>true</code>
- * if the sub-condition is <code>false</code>, or
- * <code>false</code> if the sub-condition is
- * <code>true</code>.
- */
- public static Condition not(Condition condition) {
- return new NOTCondition(condition);
- }
-
-
-
- /**
- * Creates a condition which evaluates to <code>false</code> if
- * and only if all of its sub-conditions are <code>false</code>.
- *
- * @param conditions
- * The sub-conditions which be combined using a logical OR.
- * @return Returns a condition which evaluates to <code>false</code>
- * if and only if all of its sub-conditions are
- * <code>false</code>.
- */
- public static Condition or(Condition... conditions) {
- return new ORCondition(conditions);
- }
-
-
-
- // Prevent instantiation.
- private Conditions() {
- // No implementation required.
- }
+ // Prevent instantiation.
+ private Conditions() {
+ // No implementation required.
+ }
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/ContainsCondition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/ContainsCondition.java
index 16a3958..1918c2c 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/ContainsCondition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/ContainsCondition.java
@@ -28,11 +28,10 @@
import java.util.SortedSet;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.IllegalPropertyValueStringException;
import org.opends.server.admin.PropertyDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
@@ -69,8 +68,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject)
- throws AuthorizationException, CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
SortedSet<T> values = managedObject.getPropertyValues(pd);
return values.contains(value);
}
@@ -123,8 +121,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
return impl.evaluate(context, managedObject);
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/IsPresentCondition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/IsPresentCondition.java
index 55b04d7..9bdaffd 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/IsPresentCondition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/IsPresentCondition.java
@@ -28,10 +28,9 @@
import java.util.SortedSet;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
import org.opends.server.admin.PropertyDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
@@ -65,8 +64,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
SortedSet<?> values = managedObject.getPropertyValues(pd);
return !values.isEmpty();
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/NOTCondition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/NOTCondition.java
index e54bc1f..b094d31 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/NOTCondition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/NOTCondition.java
@@ -26,9 +26,8 @@
*/
package org.opends.server.admin.condition;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
@@ -60,8 +59,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
return !condition.evaluate(context, managedObject);
}
diff --git a/opendj-admin/src/main/java/org/opends/server/admin/condition/ORCondition.java b/opendj-admin/src/main/java/org/opends/server/admin/condition/ORCondition.java
index db1632e..8f26479 100644
--- a/opendj-admin/src/main/java/org/opends/server/admin/condition/ORCondition.java
+++ b/opendj-admin/src/main/java/org/opends/server/admin/condition/ORCondition.java
@@ -29,9 +29,8 @@
import java.util.Arrays;
import java.util.List;
+import org.forgerock.opendj.ldap.ErrorResultException;
import org.opends.server.admin.AbstractManagedObjectDefinition;
-import org.opends.server.admin.client.AuthorizationException;
-import org.opends.server.admin.client.CommunicationException;
import org.opends.server.admin.client.ManagedObject;
import org.opends.server.admin.client.ManagementContext;
import org.opends.server.admin.server.ServerManagedObject;
@@ -62,8 +61,7 @@
/**
* {@inheritDoc}
*/
- public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws AuthorizationException,
- CommunicationException {
+ public boolean evaluate(ManagementContext context, ManagedObject<?> managedObject) throws ErrorResultException {
for (Condition condition : conditions) {
if (condition.evaluate(context, managedObject)) {
return true;
diff --git a/opendj-admin/src/main/resources/stylesheets/clientMO.xsl b/opendj-admin/src/main/resources/stylesheets/clientMO.xsl
index bc2b893..92a441d 100644
--- a/opendj-admin/src/main/resources/stylesheets/clientMO.xsl
+++ b/opendj-admin/src/main/resources/stylesheets/clientMO.xsl
@@ -112,16 +112,14 @@
' If the ', $ufn, ' could not be found on the server.
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to retrieve the ', $ufn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' ', $java-class-name, 'CfgClient get', $java-relation-name, '()
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException;
')" />
+ ' ErrorResultException;
')" />
</xsl:when>
<xsl:when test="adm:one-to-zero-or-one">
<xsl:call-template name="add-java-comment2">
@@ -132,15 +130,13 @@
'@return Returns <true> if the ', $ufn,' exists.
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to make the determination because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' boolean has',
$java-relation-name, '() throws ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException;
')" />
+ ' ErrorResultException;
')" />
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
@@ -159,16 +155,14 @@
' If the ', $ufn, ' is not present.
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to retrieve the ', $ufn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' ', $java-class-name, 'CfgClient get', $java-relation-name, '()
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException;
')" />
+ ' ErrorResultException;
')" />
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
@@ -211,16 +205,13 @@
' If the server refuses to remove the ', $ufn, ' due to some server-side constraint which cannot be satisfied (for example, if it is referenced by another managed object).
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to remove the ', $ufn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' void remove', $java-relation-name, '()
',
' throws ManagedObjectNotFoundException, OperationRejectedException,
',
- ' ConcurrentModificationException, AuthorizationException,
',
- ' CommunicationException;
')" />
+ ' ConcurrentModificationException, ErrorResultException;
')" />
</xsl:when>
<xsl:when test="adm:one-to-many">
<xsl:variable name="plural-name"
@@ -243,15 +234,13 @@
'@return Returns an array containing the names of the ', $ufpn,'.
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to list the ', $ufpn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' String[] list',
$java-relation-plural-name, '() throws ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException;
')" />
+ ' ErrorResultException;
')" />
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
@@ -272,16 +261,14 @@
' If the named ', $ufn, ' was not found on the server.
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to retrieve the named ', $ufn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' ', $java-class-name, 'CfgClient get', $java-relation-name, '(String name)
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException;
')" />
+ ' ErrorResultException;
')" />
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
<xsl:text>
</xsl:text>
@@ -360,16 +347,13 @@
' If the server refuses to remove the ', $ufn, ' due to some server-side constraint which cannot be satisfied (for example, if it is referenced by another managed object).
',
'@throws ConcurrentModificationException
',
' If this ', $this-ufn, ' has been removed from the server by another client.
',
- '@throws AuthorizationException
',
- ' If the server refuses to remove the ', $ufn, ' because the client does not have the correct privileges.
',
- '@throws CommunicationException
',
- ' If the client cannot contact the server due to an underlying communication problem.')" />
+ '@throws ErrorResultException
',
+ ' If any other error occurs.')" />
</xsl:call-template>
<xsl:value-of
select="concat(' void remove', $java-relation-name, '(String name)
',
' throws ManagedObjectNotFoundException, OperationRejectedException,
',
- ' ConcurrentModificationException, AuthorizationException,
',
- ' CommunicationException;
')" />
+ ' ConcurrentModificationException, ErrorResultException;
')" />
</xsl:when>
<xsl:otherwise>
<xsl:message terminate="yes">
@@ -425,10 +409,7 @@
org.opends.server.admin.client.ConcurrentModificationException
</import>
<import>
- org.opends.server.admin.client.AuthorizationException
- </import>
- <import>
- org.opends.server.admin.client.CommunicationException
+ org.forgerock.opendj.ldap.ErrorResultException
</import>
</xsl:if>
<xsl:for-each
diff --git a/opendj-admin/src/main/resources/stylesheets/metaMO.xsl b/opendj-admin/src/main/resources/stylesheets/metaMO.xsl
index d77b70e..343f0b5 100644
--- a/opendj-admin/src/main/resources/stylesheets/metaMO.xsl
+++ b/opendj-admin/src/main/resources/stylesheets/metaMO.xsl
@@ -466,8 +466,7 @@
' */
',
' public void commit() throws ManagedObjectAlreadyExistsException,
',
' MissingMandatoryPropertiesException, ConcurrentModificationException,
',
- ' OperationRejectedException, AuthorizationException,
',
- ' CommunicationException {
',
+ ' OperationRejectedException, ErrorResultException {
',
' impl.commit();
',
' }
')" />
<xsl:text>
</xsl:text>
@@ -1193,7 +1192,7 @@
' public ', $java-class-name, 'CfgClient get', $java-relation-name, '()
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException {
',
+ ' ErrorResultException {
',
' return impl.getChild(INSTANCE.get', $java-relation-name,'RelationDefinition()).getConfiguration();
',
' }
')" />
</xsl:when>
@@ -1203,7 +1202,7 @@
' * {@inheritDoc}
',
' */
',
' public boolean has', $java-relation-name, '() throws ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException {
',
+ ' ErrorResultException {
',
' return impl.hasChild(INSTANCE.get', $java-relation-name,'RelationDefinition());
',
' }
')" />
<xsl:text>
</xsl:text>
@@ -1216,7 +1215,7 @@
' public ', $java-class-name, 'CfgClient get', $java-relation-name, '()
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException {
',
+ ' ErrorResultException {
',
' return impl.getChild(INSTANCE.get', $java-relation-name,'RelationDefinition()).getConfiguration();
',
' }
')" />
<xsl:text>
</xsl:text>
@@ -1239,7 +1238,7 @@
' */
',
' public void remove', $java-relation-name, '()
',
' throws ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' OperationRejectedException, AuthorizationException, CommunicationException {
',
+ ' OperationRejectedException, ErrorResultException {
',
' impl.removeChild(INSTANCE.get', $java-relation-name,'RelationDefinition());
',
' }
')" />
</xsl:when>
@@ -1256,7 +1255,7 @@
' * {@inheritDoc}
',
' */
',
' public String[] list', $java-relation-plural-name, '() throws ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException {
',
+ ' ErrorResultException {
',
' return impl.listChildren(INSTANCE.get', $java-relation-plural-name,'RelationDefinition());
',
' }
')" />
<xsl:text>
</xsl:text>
@@ -1269,7 +1268,7 @@
' public ', $java-class-name, 'CfgClient get', $java-relation-name, '(String name)
',
' throws DefinitionDecodingException, ManagedObjectDecodingException,
',
' ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' AuthorizationException, CommunicationException {
',
+ ' ErrorResultException {
',
' return impl.getChild(INSTANCE.get', $java-relation-plural-name,'RelationDefinition(), name).getConfiguration();
',
' }
')" />
<xsl:text>
</xsl:text>
@@ -1307,7 +1306,7 @@
' */
',
' public void remove', $java-relation-name, '(String name)
',
' throws ManagedObjectNotFoundException, ConcurrentModificationException,
',
- ' OperationRejectedException, AuthorizationException, CommunicationException {
',
+ ' OperationRejectedException, ErrorResultException {
',
' impl.removeChild(INSTANCE.get', $java-relation-plural-name,'RelationDefinition(), name);
',
' }
')" />
</xsl:when>
@@ -1925,10 +1924,7 @@
org.opends.server.admin.ManagedObjectAlreadyExistsException
</import>
<import>
- org.opends.server.admin.client.AuthorizationException
- </import>
- <import>
- org.opends.server.admin.client.CommunicationException
+ org.forgerock.opendj.ldap.ErrorResultException
</import>
<import>
org.opends.server.admin.client.ConcurrentModificationException
--
Gitblit v1.10.0