/* * 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 legal-notices/CDDLv1_0.txt * or http://forgerock.org/license/CDDLv1.0.html. * 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 legal-notices/CDDLv1_0.txt. * 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-2009 Sun Microsystems, Inc. */ package org.opends.server.admin.client.spi; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.SortedSet; 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; import org.opends.server.admin.Configuration; import org.opends.server.admin.ConfigurationClient; import org.opends.server.admin.Constraint; import org.opends.server.admin.DefaultBehaviorException; import org.opends.server.admin.DefaultBehaviorProviderVisitor; import org.opends.server.admin.DefinedDefaultBehaviorProvider; import org.opends.server.admin.DefinitionDecodingException; import org.opends.server.admin.IllegalPropertyValueStringException; import org.opends.server.admin.InstantiableRelationDefinition; import org.opends.server.admin.ManagedObjectNotFoundException; import org.opends.server.admin.ManagedObjectPath; import org.opends.server.admin.OptionalRelationDefinition; import org.opends.server.admin.PropertyDefinition; import org.opends.server.admin.PropertyException; import org.opends.server.admin.PropertyIsSingleValuedException; import org.opends.server.admin.PropertyNotFoundException; import org.opends.server.admin.PropertyOption; import org.opends.server.admin.RelationDefinition; import org.opends.server.admin.RelativeInheritedDefaultBehaviorProvider; 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.ClientConstraintHandler; import org.opends.server.admin.client.ManagedObject; import org.opends.server.admin.client.ManagedObjectDecodingException; import org.opends.server.admin.client.ManagementContext; import org.opends.server.admin.client.OperationRejectedException; import org.opends.server.admin.client.OperationRejectedException.OperationType; /** * An abstract management connection context driver which should form the basis * of driver implementations. */ public abstract class Driver { /** * A default behavior visitor used for retrieving the default values of a * property. * * @param * The type of the property. */ private class DefaultValueFinder implements DefaultBehaviorProviderVisitor, Void> { // Any exception that occurred whilst retrieving inherited default // values. private DefaultBehaviorException exception = null; // The path of the managed object containing the first property. private final ManagedObjectPath firstPath; // Indicates whether the managed object has been created yet. private final boolean isCreate; // The path of the managed object containing the next property. private ManagedObjectPath nextPath = null; // The next property whose default values were required. private PropertyDefinition nextProperty = null; // Private constructor. private DefaultValueFinder(ManagedObjectPath p, boolean isCreate) { this.firstPath = p; this.isCreate = isCreate; } /** * {@inheritDoc} */ public Collection visitAbsoluteInherited(AbsoluteInheritedDefaultBehaviorProvider d, Void p) { try { return getInheritedProperty(d.getManagedObjectPath(), d.getManagedObjectDefinition(), d.getPropertyName()); } catch (DefaultBehaviorException e) { exception = e; return Collections.emptySet(); } } /** * {@inheritDoc} */ public Collection visitAlias(AliasDefaultBehaviorProvider d, Void p) { return Collections.emptySet(); } /** * {@inheritDoc} */ public Collection visitDefined(DefinedDefaultBehaviorProvider d, Void p) { Collection stringValues = d.getDefaultValues(); List values = new ArrayList(stringValues.size()); for (String stringValue : stringValues) { try { values.add(nextProperty.decodeValue(stringValue)); } catch (IllegalPropertyValueStringException e) { exception = new DefaultBehaviorException(nextProperty, e); break; } } return values; } /** * {@inheritDoc} */ public Collection visitRelativeInherited(RelativeInheritedDefaultBehaviorProvider d, Void p) { try { return getInheritedProperty(d.getManagedObjectPath(nextPath), d.getManagedObjectDefinition(), d.getPropertyName()); } catch (DefaultBehaviorException e) { exception = e; return Collections.emptySet(); } } /** * {@inheritDoc} */ public Collection visitUndefined(UndefinedDefaultBehaviorProvider d, Void p) { return Collections.emptySet(); } // Find the default values for the next path/property. private Collection find(ManagedObjectPath p, PropertyDefinition pd) throws DefaultBehaviorException { this.nextPath = p; this.nextProperty = pd; Collection values = nextProperty.getDefaultBehaviorProvider().accept(this, null); if (exception != null) { throw exception; } if (values.size() > 1 && !pd.hasOption(PropertyOption.MULTI_VALUED)) { throw new DefaultBehaviorException(pd, new PropertyIsSingleValuedException(pd)); } return values; } // Get an inherited property value. @SuppressWarnings("unchecked") private Collection getInheritedProperty(ManagedObjectPath target, AbstractManagedObjectDefinition d, String propertyName) throws DefaultBehaviorException { // First check that the requested type of managed object // corresponds to the path. AbstractManagedObjectDefinition supr = target.getManagedObjectDefinition(); if (!supr.isParentOf(d)) { throw new DefaultBehaviorException(nextProperty, new DefinitionDecodingException(supr, Reason.WRONG_TYPE_INFORMATION)); } // Save the current property in case of recursion. PropertyDefinition pd1 = nextProperty; try { // Determine the requested property definition. PropertyDefinition pd2; try { // FIXME: we use the definition taken from the default // behavior here when we should really use the exact // definition of the component being created. PropertyDefinition pdTmp = d.getPropertyDefinition(propertyName); pd2 = pd1.getClass().cast(pdTmp); } catch (IllegalArgumentException e) { throw new PropertyNotFoundException(propertyName); } catch (ClassCastException e) { // FIXME: would be nice to throw a better exception here. throw new PropertyNotFoundException(propertyName); } // If the path relates to the current managed object and the // managed object is in the process of being created it won't // exist, so we should just use the default values of the // referenced property. if (isCreate && firstPath.equals(target)) { // Recursively retrieve this property's default values. Collection tmp = find(target, pd2); Collection values = new ArrayList(tmp.size()); for (T value : tmp) { pd1.validateValue(value); values.add(value); } return values; } else { // FIXME: issue 2481 - this is broken if the referenced // property // inherits its defaults from the newly created managed // object. return getPropertyValues(target, pd2); } } catch (DefaultBehaviorException e) { // Wrap any errors due to recursion. throw new DefaultBehaviorException(pd1, e); } catch (DefinitionDecodingException e) { throw new DefaultBehaviorException(pd1, e); } catch (PropertyNotFoundException e) { throw new DefaultBehaviorException(pd1, e); } catch (ErrorResultException e) { throw new DefaultBehaviorException(pd1, e); } catch (ManagedObjectNotFoundException e) { throw new DefaultBehaviorException(pd1, e); } catch (PropertyException e) { throw new DefaultBehaviorException(pd1, e); } } }; /** * Creates a new abstract management context. */ protected Driver() { // No implementation required. } /** * Closes any context associated with this management context driver. */ public void close() { // do nothing by default } /** * Deletes the named instantiable child managed object from the named parent * managed object. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param parent * The path of the parent managed object. * @param rd * The instantiable relation definition. * @param name * The name of the child managed object to be removed. * @return Returns true if the named instantiable child managed * object was found, or false if it was not found. * @throws IllegalArgumentException * If the relation definition is not associated with the parent * managed object's definition. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @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 ErrorResultException * If any other error occurs. */ public final boolean deleteManagedObject( ManagedObjectPath parent, InstantiableRelationDefinition rd, String name) throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException { validateRelationDefinition(parent, rd); ManagedObjectPath child = parent.child(rd, name); return doDeleteManagedObject(child); } /** * Deletes the optional child managed object from the named parent managed * object. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param parent * The path of the parent managed object. * @param rd * The optional relation definition. * @return Returns true if the optional child managed object * was found, or false if it was not found. * @throws IllegalArgumentException * If the relation definition is not associated with the parent * managed object's definition. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @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 ErrorResultException * If any other error occurs. */ public final boolean deleteManagedObject( ManagedObjectPath parent, OptionalRelationDefinition rd) throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException { validateRelationDefinition(parent, rd); ManagedObjectPath child = parent.child(rd); return doDeleteManagedObject(child); } /** * Deletes the named instantiable child managed object from the named parent * managed object. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param parent * The path of the parent managed object. * @param rd * The instantiable relation definition. * @param name * The name of the child managed object to be removed. * @return Returns true if the named instantiable child managed * object was found, or false if it was not found. * @throws IllegalArgumentException * If the relation definition is not associated with the parent * managed object's definition. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @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 ErrorResultException * If any other error occurs. */ public final boolean deleteManagedObject( ManagedObjectPath parent, SetRelationDefinition rd, String name) throws IllegalArgumentException, ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException { validateRelationDefinition(parent, rd); ManagedObjectPath child = parent.child(rd, name); return doDeleteManagedObject(child); } /** * Gets the named managed object. The path is guaranteed to be non-empty, so * implementations do not need to worry about handling this special case. * * @param * The type of client managed object configuration that the path * definition refers to. * @param * The type of server managed object configuration that the path * definition refers to. * @param path * The non-empty path of the managed object. * @return Returns the named managed object. * @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 ErrorResultException * If any other error occurs. */ public abstract ManagedObject getManagedObject( ManagedObjectPath path) throws DefinitionDecodingException, ManagedObjectDecodingException, ManagedObjectNotFoundException, ErrorResultException; /** * Gets the effective values of a property in the named managed object. *

* Implementations MUST NOT not use * {@link #getManagedObject(ManagedObjectPath)} to read the referenced * managed object in its entirety. Specifically, implementations MUST only * attempt to resolve the default values for the requested property and its * dependencies (if it uses inherited defaults). This is to avoid infinite * recursion where a managed object contains a property which inherits * default values from another property in the same managed object. * * @param * The type of client managed object configuration that the path * definition refers to. * @param * The type of server managed object configuration that the path * definition refers to. * @param * The type of the property to be retrieved. * @param path * The path of the managed object containing the property. * @param pd * The property to be retrieved. * @return Returns the property's effective values, or an empty set if there * are no values defined. * @throws IllegalArgumentException * If the property definition is not associated with the * referenced managed object's definition. * @throws DefinitionDecodingException * If the managed object was found but its type could not be * determined. * @throws PropertyException * If the managed object was found but the requested property * could not be decoded. * @throws ManagedObjectNotFoundException * If the requested managed object could not be found on the * server. * @throws ErrorResultException * If any other error occurs. */ public abstract SortedSet getPropertyValues( ManagedObjectPath path, PropertyDefinition pd) throws IllegalArgumentException, DefinitionDecodingException, ManagedObjectNotFoundException, ErrorResultException, PropertyException; /** * Gets the root configuration managed object associated with this * management context driver. * * @return Returns the root configuration managed object associated with * this management context driver. */ public abstract ManagedObject getRootConfigurationManagedObject(); /** * Lists the child managed objects of the named parent managed object which * are a sub-type of the specified managed object definition. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param parent * The path of the parent managed object. * @param rd * 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 the parent * managed object's definition. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @throws ErrorResultException * If any other error occurs. */ public abstract String[] listManagedObjects( ManagedObjectPath parent, InstantiableRelationDefinition rd, AbstractManagedObjectDefinition d) throws IllegalArgumentException, ManagedObjectNotFoundException, ErrorResultException; /** * Lists the child managed objects of the named parent managed object which * are a sub-type of the specified managed object definition. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param parent * The path of the parent managed object. * @param rd * The set 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 the parent * managed object's definition. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @throws ErrorResultException * If any other error occurs. */ public abstract String[] listManagedObjects( ManagedObjectPath parent, SetRelationDefinition rd, AbstractManagedObjectDefinition d) throws IllegalArgumentException, ManagedObjectNotFoundException, ErrorResultException; /** * Determines whether or not the named managed object exists. *

* Implementations should always return true when the provided * path is empty. * * @param path * The path of the named managed object. * @return Returns true if the named managed object exists, * false otherwise. * @throws ManagedObjectNotFoundException * If the parent managed object could not be found. * @throws ErrorResultException * If any other error occurs. */ public abstract boolean managedObjectExists(ManagedObjectPath path) throws ManagedObjectNotFoundException, ErrorResultException; /** * Deletes the named managed object. *

* Implementations do not need check whether the named managed object * exists, nor do they need to enforce client constraints. * * @param * The type of client managed object configuration that the * relation definition refers to. * @param * The type of server managed object configuration that the * relation definition refers to. * @param path * The path of the managed object to be deleted. * @throws OperationRejectedException * 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 ErrorResultException * If any other error occurs. */ protected abstract void deleteManagedObject( ManagedObjectPath path) throws OperationRejectedException, ErrorResultException; /** * Gets the default values for the specified property. * * @param * The type of the property. * @param p * The managed object path of the current managed object. * @param pd * The property definition. * @param isCreate * Indicates whether the managed object has been created yet. * @return Returns the default values for the specified property. * @throws DefaultBehaviorException * If the default values could not be retrieved or decoded * properly. */ protected final Collection findDefaultValues(ManagedObjectPath p, PropertyDefinition pd, boolean isCreate) throws DefaultBehaviorException { DefaultValueFinder v = new DefaultValueFinder(p, isCreate); return v.find(p, pd); } /** * Gets the management context associated with this driver. * * @return Returns the management context associated with this driver. */ protected abstract ManagementContext getManagementContext(); /** * Validate that a relation definition belongs to the managed object * referenced by the provided path. * * @param path * The parent managed object path. * @param rd * The relation definition. * @throws IllegalArgumentException * If the relation definition does not belong to the managed * object definition. */ protected final void validateRelationDefinition(ManagedObjectPath path, RelationDefinition rd) throws IllegalArgumentException { AbstractManagedObjectDefinition d = path.getManagedObjectDefinition(); RelationDefinition tmp = d.getRelationDefinition(rd.getName()); if (tmp != rd) { throw new IllegalArgumentException("The relation " + rd.getName() + " is not associated with a " + d.getName()); } } // Remove a managed object, first ensuring that the parent exists, // then ensuring that the child exists, before ensuring that any // constraints are satisfied. private boolean doDeleteManagedObject( ManagedObjectPath path) throws ManagedObjectNotFoundException, OperationRejectedException, ErrorResultException { // First make sure that the parent exists. if (!managedObjectExists(path.parent())) { throw new ManagedObjectNotFoundException(); } // Make sure that the targeted managed object exists. if (!managedObjectExists(path)) { return false; } // The targeted managed object is guaranteed to exist, so enforce // any constraints. AbstractManagedObjectDefinition d = path.getManagedObjectDefinition(); List messages = new LinkedList(); boolean isAcceptable = true; for (Constraint constraint : d.getAllConstraints()) { for (ClientConstraintHandler handler : constraint.getClientConstraintHandlers()) { ManagementContext context = getManagementContext(); if (!handler.isDeleteAcceptable(context, path, messages)) { isAcceptable = false; } } if (!isAcceptable) { break; } } if (!isAcceptable) { throw new OperationRejectedException(OperationType.DELETE, d.getUserFriendlyName(), messages); } deleteManagedObject(path); return true; } }