/*
|
* 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
|
*
|
*
|
* Portions Copyright 2007 Sun Microsystems, Inc.
|
*/
|
|
package org.opends.server.admin.client.ldap;
|
|
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.HashSet;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.SortedSet;
|
|
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.BasicAttribute;
|
import javax.naming.directory.BasicAttributes;
|
import javax.naming.directory.DirContext;
|
import javax.naming.directory.SearchControls;
|
import javax.naming.directory.SearchResult;
|
import javax.naming.ldap.LdapName;
|
import javax.naming.ldap.Rdn;
|
|
import org.opends.server.admin.AbstractManagedObjectDefinition;
|
import org.opends.server.admin.ConfigurationClient;
|
import org.opends.server.admin.DefinitionDecodingException;
|
import org.opends.server.admin.DefinitionResolver;
|
import org.opends.server.admin.IllegalPropertyValueException;
|
import org.opends.server.admin.InheritedDefaultValueProvider;
|
import org.opends.server.admin.InstantiableRelationDefinition;
|
import org.opends.server.admin.LDAPProfile;
|
import org.opends.server.admin.ManagedObjectDefinition;
|
import org.opends.server.admin.ManagedObjectPath;
|
import org.opends.server.admin.OperationsException;
|
import org.opends.server.admin.OptionalRelationDefinition;
|
import org.opends.server.admin.PropertyDefinition;
|
import org.opends.server.admin.PropertyException;
|
import org.opends.server.admin.PropertyIsMandatoryException;
|
import org.opends.server.admin.PropertyIsReadOnlyException;
|
import org.opends.server.admin.PropertyIsSingleValuedException;
|
import org.opends.server.admin.PropertyNotFoundException;
|
import org.opends.server.admin.PropertyProvider;
|
import org.opends.server.admin.RelationDefinition;
|
import org.opends.server.admin.SingletonRelationDefinition;
|
import org.opends.server.admin.StringPropertyProvider;
|
import org.opends.server.admin.DefinitionDecodingException.Reason;
|
import org.opends.server.admin.client.ManagedObject;
|
import org.opends.server.admin.client.ManagedObjectDecodingException;
|
import org.opends.server.admin.client.Property;
|
import org.opends.server.admin.client.PropertySet;
|
import org.opends.server.admin.std.client.RootCfgClient;
|
import org.opends.server.admin.std.meta.RootCfgDefn;
|
|
|
|
/**
|
* A managed object bound to an LDAP connection.
|
*
|
* @param <C>
|
* The type of client configuration represented by the client
|
* managed object.
|
*/
|
final class LDAPManagedObject<C extends ConfigurationClient>
|
implements ManagedObject<C> {
|
|
/**
|
* Internal inherited default value provider implementation.
|
*/
|
private static class MyInheritedDefaultValueProvider implements
|
InheritedDefaultValueProvider {
|
|
// The base path.
|
private final ManagedObjectPath path;
|
|
// The LDAP connection context.
|
private final DirContext dirContext;
|
|
|
|
/**
|
* Create a new inherited default value provider.
|
*
|
* @param dirContext
|
* The LDAP connection context.
|
* @param path
|
* The base path.
|
*/
|
public MyInheritedDefaultValueProvider(DirContext dirContext,
|
ManagedObjectPath path) {
|
this.dirContext = dirContext;
|
this.path = path;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public Collection<?> getDefaultPropertyValues(
|
ManagedObjectPath path, String propertyName)
|
throws OperationsException, PropertyNotFoundException {
|
ManagedObject<?> mo = readEntry(dirContext, path, path
|
.getManagedObjectDefinition());
|
ManagedObjectDefinition<?, ?> mod = mo
|
.getManagedObjectDefinition();
|
|
try {
|
PropertyDefinition<?> dpd = mod
|
.getPropertyDefinition(propertyName);
|
return mo.getPropertyValues(dpd);
|
} catch (IllegalArgumentException e) {
|
throw new PropertyNotFoundException(propertyName);
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ManagedObjectPath getManagedObjectPath() {
|
return path;
|
}
|
}
|
|
|
|
/**
|
* Construct a root LDAP managed object associated with the provided
|
* LDAP context.
|
*
|
* @param dirContext
|
* The LDAP directory context.
|
* @return Returns a root LDAP managed object associated with the
|
* provided LDAP context.
|
*/
|
static ManagedObject<RootCfgClient> getRootManagedObject(
|
DirContext dirContext) {
|
List<PropertyException> exceptions = new LinkedList<PropertyException>();
|
InheritedDefaultValueProvider i = new MyInheritedDefaultValueProvider(
|
dirContext, ManagedObjectPath.emptyPath());
|
PropertySet properties = PropertySet.create(RootCfgDefn
|
.getInstance(), PropertyProvider.DEFAULT_PROVIDER, i,
|
exceptions);
|
|
// Should never get any exceptions.
|
if (!exceptions.isEmpty()) {
|
throw new RuntimeException(
|
"Got exceptions when creating root managed object");
|
}
|
|
return new LDAPManagedObject<RootCfgClient>(dirContext,
|
RootCfgDefn.getInstance(), ManagedObjectPath.emptyPath(),
|
properties);
|
}
|
|
|
|
// Create a new child LDAP managed object.
|
private static <M extends ConfigurationClient>
|
ManagedObject<M> createLDAPManagedObject(
|
DirContext dirContext, ManagedObjectDefinition<M, ?> d,
|
ManagedObjectPath p, PropertySet properties) {
|
return new LDAPManagedObject<M>(dirContext, d, p, properties);
|
}
|
|
|
|
// Get an array containing the list of LDAP attributes names
|
// associated with a
|
// managed object definition.
|
private static String[] getAttributeNames(
|
ManagedObjectDefinition<?, ?> d) {
|
ArrayList<String> attrIds = new ArrayList<String>();
|
|
for (PropertyDefinition<?> pd : d.getPropertyDefinitions()) {
|
String attrId = LDAPProfile.getInstance().getAttributeName(d,
|
pd);
|
attrIds.add(attrId);
|
}
|
|
return attrIds.toArray(new String[attrIds.size()]);
|
}
|
|
|
|
// Determine the type of managed object associated with the named
|
// entry.
|
private static <M extends ConfigurationClient>
|
ManagedObjectDefinition<? extends M, ?> getEntryDefinition(
|
DirContext dirContext, AbstractManagedObjectDefinition<M, ?> d,
|
LdapName dn) throws OperationsException {
|
try {
|
String[] attrIds = new String[] { "objectclass" };
|
Attributes attributes = dirContext.getAttributes(dn, attrIds);
|
Attribute oc = attributes.get("objectclass");
|
|
if (oc == null) {
|
// No object classes.
|
throw new DefinitionDecodingException(
|
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());
|
}
|
}
|
|
if (objectClasses.isEmpty()) {
|
// No object classes.
|
throw new DefinitionDecodingException(
|
Reason.NO_TYPE_INFORMATION);
|
}
|
|
// Resolve the appropriate sub-type based on the object classes.
|
DefinitionResolver resolver = new DefinitionResolver() {
|
|
public boolean matches(AbstractManagedObjectDefinition<?, ?> d) {
|
String objectClass = LDAPProfile.getInstance()
|
.getObjectClass(d);
|
return objectClasses.contains(objectClass);
|
}
|
|
};
|
|
return d.resolveManagedObjectDefinition(resolver);
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
}
|
|
|
|
// Read the entry identified by the path and which is a sub-type of
|
// the
|
// specified definition.
|
private static <M extends ConfigurationClient>
|
ManagedObject<? extends M> readEntry(
|
DirContext dirContext, ManagedObjectPath p,
|
AbstractManagedObjectDefinition<M, ?> d)
|
throws OperationsException {
|
LdapName dn = LDAPNameBuilder.create(p);
|
final ManagedObjectDefinition<? extends M, ?> mod = getEntryDefinition(
|
dirContext, d, dn);
|
String[] attrIds = getAttributeNames(mod);
|
|
final Attributes attributes;
|
try {
|
attributes = dirContext.getAttributes(dn, attrIds);
|
} catch (NamingException e) {
|
OperationsExceptionFactory factory = new OperationsExceptionFactory();
|
throw factory.createException(e);
|
}
|
|
// Create a provider which uses LDAP string representations.
|
|
// TODO: the exception handling is a bit of a hack here.
|
final List<OperationsException> oelist =
|
new LinkedList<OperationsException>();
|
StringPropertyProvider provider = new StringPropertyProvider() {
|
|
public Collection<String> getPropertyValues(
|
PropertyDefinition<?> d) throws IllegalArgumentException {
|
String attrID = LDAPProfile.getInstance().getAttributeName(
|
mod, d);
|
Attribute attribute = attributes.get(attrID);
|
List<String> values = new LinkedList<String>();
|
|
if (attribute != null && attribute.size() != 0) {
|
try {
|
NamingEnumeration<?> ldapValues = attribute.getAll();
|
while (ldapValues.hasMore()) {
|
Object obj = ldapValues.next();
|
if (obj != null) {
|
values.add(obj.toString());
|
}
|
}
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
oelist.add(oef.createException(e));
|
}
|
}
|
|
return values;
|
}
|
|
};
|
|
// There can only be at most one operations exception.
|
if (!oelist.isEmpty()) {
|
throw oelist.get(0);
|
}
|
|
// Now decode the properties using the provider.
|
List<PropertyException> exceptions = new LinkedList<PropertyException>();
|
InheritedDefaultValueProvider i = new MyInheritedDefaultValueProvider(
|
dirContext, p);
|
PropertySet properties = PropertySet.create(mod, provider, i,
|
exceptions);
|
ManagedObject<? extends M> mo = createLDAPManagedObject(
|
dirContext, mod, p, properties);
|
|
// If there were no decoding problems then return the object,
|
// otherwise
|
// throw an operations exception.
|
if (exceptions.isEmpty()) {
|
return mo;
|
} else {
|
throw new ManagedObjectDecodingException(mo, exceptions);
|
}
|
}
|
|
// The JNDI context used for the ldap connection.
|
private final DirContext dirContext;
|
|
// The path associated with this managed object.
|
private final ManagedObjectPath path;
|
|
// LDAP profile associated with this connection.
|
private final LDAPProfile profile;
|
|
// The managed object definition associated with this managed
|
// object.
|
private final ManagedObjectDefinition<C, ?> definition;
|
|
// The managed object's properties.
|
private final PropertySet properties;
|
|
|
|
// Create an new LDAP managed object with the provided JNDI context.
|
private LDAPManagedObject(DirContext dirContext,
|
ManagedObjectDefinition<C, ?> d, ManagedObjectPath path,
|
PropertySet properties) {
|
this.definition = d;
|
this.dirContext = dirContext;
|
this.path = path;
|
this.profile = LDAPProfile.getInstance();
|
this.properties = properties;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void commit() throws OperationsException {
|
ManagedObjectDefinition<C, ?> d = getManagedObjectDefinition();
|
LDAPChangeBuilder builder = new LDAPChangeBuilder(dirContext,
|
path, d);
|
for (PropertyDefinition<?> pd : d.getPropertyDefinitions()) {
|
// FIXME: should throw an error when there are missing mandatory
|
// properties.
|
Property<?> p = properties.getProperty(pd);
|
if (p.isModified()) {
|
builder.addChange(p);
|
}
|
}
|
builder.commit();
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient, N extends M>
|
ManagedObject<N> createChild(
|
InstantiableRelationDefinition<M, ?> r,
|
ManagedObjectDefinition<N, ?> d, String name, PropertyProvider p)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(r);
|
|
ManagedObjectPath childPath = path.child(r, name);
|
|
// First make sure all the properties are valid.
|
List<PropertyException> exceptions = new LinkedList<PropertyException>();
|
InheritedDefaultValueProvider i = new MyInheritedDefaultValueProvider(
|
dirContext, childPath);
|
PropertySet properties = PropertySet.create(d, p, i, exceptions);
|
if (!exceptions.isEmpty()) {
|
ManagedObject<N> mo = new LDAPManagedObject<N>(dirContext, d,
|
childPath, properties);
|
throw new ManagedObjectDecodingException(mo, exceptions);
|
}
|
|
try {
|
// TODO: this implementation does not handle relations which
|
// comprise of more than one RDN arc (this will probably never
|
// be required anyway).
|
LdapName dn = LDAPNameBuilder.create(path, r);
|
|
if (!entryExists(dn)) {
|
// Need to create the child managed object's parent entry i.e.
|
// the entry representing the relation itself.
|
Attributes attributes = new BasicAttributes();
|
|
// Create the branch's object class attribute.
|
Attribute oc = new BasicAttribute("objectClass");
|
for (String objectClass : profile
|
.getInstantiableRelationObjectClasses(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.
|
dirContext.createSubcontext(dn, attributes);
|
}
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
|
return createManagedObject(childPath, d, properties);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient, N extends M>
|
ManagedObject<N> createChild(
|
OptionalRelationDefinition<M, ?> r,
|
ManagedObjectDefinition<N, ?> d, PropertyProvider p)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(r);
|
|
ManagedObjectPath childPath = path.child(r);
|
|
// First make sure all the properties are valid.
|
List<PropertyException> exceptions = new LinkedList<PropertyException>();
|
InheritedDefaultValueProvider i = new MyInheritedDefaultValueProvider(
|
dirContext, childPath);
|
PropertySet properties = PropertySet.create(d, p, i, exceptions);
|
if (!exceptions.isEmpty()) {
|
ManagedObject<N> mo = new LDAPManagedObject<N>(dirContext, d,
|
childPath, properties);
|
throw new ManagedObjectDecodingException(mo, exceptions);
|
}
|
|
return createManagedObject(childPath, d, properties);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient> ManagedObject<? extends M> getChild(
|
InstantiableRelationDefinition<M, ?> d, String name)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
return readEntry(dirContext, path.child(d, name), d
|
.getChildDefinition());
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient> ManagedObject<? extends M> getChild(
|
OptionalRelationDefinition<M, ?> d)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
return readEntry(dirContext, path.child(d), d
|
.getChildDefinition());
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient> ManagedObject<? extends M> getChild(
|
SingletonRelationDefinition<M, ?> d)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
return readEntry(dirContext, path.child(d), d
|
.getChildDefinition());
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public C getConfiguration() {
|
return definition.createClientConfiguration(this);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ManagedObjectDefinition<C, ?> getManagedObjectDefinition() {
|
return definition;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ManagedObjectPath getManagedObjectPath() {
|
return path;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <T> T getPropertyValue(PropertyDefinition<T> d)
|
throws IllegalArgumentException {
|
return properties.getPropertyValue(d);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <T> SortedSet<T> getPropertyValues(PropertyDefinition<T> d)
|
throws IllegalArgumentException {
|
return properties.getPropertyValues(d);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean hasChild(OptionalRelationDefinition<?, ?> d)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
|
ManagedObjectPath p = path.child(d);
|
LdapName dn = LDAPNameBuilder.create(p);
|
try {
|
return entryExists(dn);
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public String[] listChildren(InstantiableRelationDefinition<?, ?> d)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
|
LdapName dn = LDAPNameBuilder.create(path, d);
|
|
String filter = profile.getFilter(d.getChildDefinition());
|
SearchControls controls = new SearchControls();
|
controls.setSearchScope(SearchControls.ONELEVEL_SCOPE);
|
|
try {
|
NamingEnumeration<SearchResult> results;
|
results = dirContext.search(dn, filter, controls);
|
|
String rtype = profile.getInstantiableRelationChildRDNType(d);
|
List<String> names = new ArrayList<String>();
|
while (results.hasMore()) {
|
SearchResult sr = results.next();
|
Attributes attributes = sr.getAttributes();
|
Attribute cn = attributes.get(rtype);
|
if (cn != null && cn.get() != null) {
|
names.add(cn.get().toString());
|
}
|
}
|
|
return names.toArray(new String[names.size()]);
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient> void removeChild(
|
InstantiableRelationDefinition<M, ?> d, String name)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
|
ManagedObjectPath p = path.child(d, name);
|
removeManagedObject(p);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <M extends ConfigurationClient> void removeChild(
|
OptionalRelationDefinition<M, ?> d)
|
throws IllegalArgumentException, OperationsException {
|
validateRelationDefinition(d);
|
|
ManagedObjectPath p = path.child(d);
|
removeManagedObject(p);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <T> void setPropertyValue(PropertyDefinition<T> d, T value)
|
throws IllegalPropertyValueException,
|
PropertyIsReadOnlyException, PropertyIsMandatoryException,
|
IllegalArgumentException {
|
properties.setPropertyValue(d, value);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public <T> void setPropertyValues(PropertyDefinition<T> d,
|
Collection<T> values) throws IllegalPropertyValueException,
|
PropertyIsSingleValuedException, PropertyIsReadOnlyException,
|
PropertyIsMandatoryException, IllegalArgumentException {
|
properties.setPropertyValues(d, values);
|
}
|
|
|
|
// Creates a new managed object. The parent LDAP entry is assumed to
|
// already exist.
|
private <N extends ConfigurationClient> ManagedObject<N> createManagedObject(
|
ManagedObjectPath path, ManagedObjectDefinition<N, ?> d,
|
PropertySet properties) throws OperationsException {
|
LdapName dn = LDAPNameBuilder.create(path);
|
Attributes attributes = new BasicAttributes();
|
|
// Create the child's object class attribute.
|
Attribute oc = new BasicAttribute("objectClass");
|
for (String objectClass : profile.getObjectClasses(d)) {
|
oc.add(objectClass);
|
}
|
attributes.put(oc);
|
|
// Create the child's naming attribute.
|
Rdn rdn = dn.getRdn(dn.size() - 1);
|
attributes.put(rdn.getType(), rdn.getValue().toString());
|
|
// Create the remaining attributes.
|
for (PropertyDefinition<?> pd : d.getPropertyDefinitions()) {
|
String attrID = profile.getAttributeName(d, pd);
|
Attribute attribute = new BasicAttribute(attrID);
|
encodeProperty(attribute, pd, properties);
|
if (attribute.size() != 0) {
|
attributes.put(attribute);
|
}
|
}
|
|
try {
|
// Create the entry.
|
dirContext.createSubcontext(dn, attributes);
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
|
return new LDAPManagedObject<N>(dirContext, d, path, properties);
|
}
|
|
|
|
// Recursively delete a subtree of entries.
|
private void destroySubtree(LdapName dn) throws NamingException {
|
// List the child entries.
|
String filter = "(objectClass=*)";
|
SearchControls controls = new SearchControls();
|
controls.setSearchScope(SearchControls.ONELEVEL_SCOPE);
|
|
NamingEnumeration<SearchResult> results;
|
results = dirContext.search(dn, filter, controls);
|
|
// Recursively delete child entries.
|
while (results.hasMore()) {
|
SearchResult sr = results.next();
|
LdapName child = new LdapName(dn.getRdns());
|
child.add(new Rdn(sr.getName()));
|
destroySubtree(child);
|
}
|
|
// Delete the specified entry.
|
dirContext.destroySubcontext(dn);
|
}
|
|
|
|
// Encode a property into LDAP string values.
|
private <T> void encodeProperty(Attribute attribute,
|
PropertyDefinition<T> pd, PropertySet properties) {
|
for (T value : properties.getPropertyValues(pd)) {
|
attribute.add(pd.encodeValue(value));
|
}
|
}
|
|
|
|
// Determine whether the named entry exists or not.
|
private boolean entryExists(LdapName dn) throws NamingException {
|
String filter = "(objectClass=*)";
|
SearchControls controls = new SearchControls();
|
controls.setSearchScope(SearchControls.OBJECT_SCOPE);
|
|
try {
|
NamingEnumeration<SearchResult> results = dirContext.search(dn,
|
filter, controls);
|
if (results.hasMore()) {
|
// TODO: should really verify that the relation entry has
|
// the correct object classes, etc. It definitely has the
|
// correct name, which is ok.
|
return true;
|
}
|
} catch (NameNotFoundException e) {
|
// Fall through - parent not found.
|
}
|
|
return false;
|
}
|
|
|
|
// Remove the named managed object.
|
private void removeManagedObject(ManagedObjectPath p)
|
throws OperationsException {
|
try {
|
LdapName dn = LDAPNameBuilder.create(p);
|
if (entryExists(dn)) {
|
// Delete the entry and any subordinate entries.
|
destroySubtree(dn);
|
}
|
} catch (NamingException e) {
|
OperationsExceptionFactory oef = new OperationsExceptionFactory();
|
throw oef.createException(e);
|
}
|
}
|
|
|
|
// Validate that a relation definition belongs to this managed
|
// object.
|
private void validateRelationDefinition(RelationDefinition<?, ?> rd)
|
throws IllegalArgumentException {
|
ManagedObjectDefinition d = getManagedObjectDefinition();
|
RelationDefinition tmp = d.getRelationDefinition(rd.getName());
|
if (tmp != rd) {
|
throw new IllegalArgumentException("The relation "
|
+ rd.getName() + " is not associated with a " + d.getName());
|
}
|
}
|
}
|
