| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| |
| package org.apache.directory.server.config; |
| |
| |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.ParameterizedType; |
| import java.lang.reflect.Type; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.naming.directory.SearchControls; |
| |
| import org.apache.directory.server.config.beans.AdsBaseBean; |
| import org.apache.directory.server.config.beans.ConfigBean; |
| import org.apache.directory.server.core.partition.impl.btree.BTreePartition; |
| import org.apache.directory.server.i18n.I18n; |
| import org.apache.directory.server.xdbm.ForwardIndexEntry; |
| import org.apache.directory.server.xdbm.IndexCursor; |
| import org.apache.directory.server.xdbm.search.SearchEngine; |
| import org.apache.directory.shared.ldap.model.constants.SchemaConstants; |
| import org.apache.directory.shared.ldap.model.entry.Entry; |
| import org.apache.directory.shared.ldap.model.entry.EntryAttribute; |
| import org.apache.directory.shared.ldap.model.entry.StringValue; |
| import org.apache.directory.shared.ldap.model.entry.Value; |
| import org.apache.directory.shared.ldap.model.exception.LdapException; |
| import org.apache.directory.shared.ldap.model.exception.LdapInvalidDnException; |
| import org.apache.directory.shared.ldap.model.filter.EqualityNode; |
| import org.apache.directory.shared.ldap.model.filter.SearchScope; |
| import org.apache.directory.shared.ldap.model.message.AliasDerefMode; |
| import org.apache.directory.shared.ldap.model.name.Dn; |
| import org.apache.directory.shared.ldap.model.name.Rdn; |
| import org.apache.directory.shared.ldap.model.schema.MutableAttributeTypeImpl; |
| import org.apache.directory.shared.ldap.model.schema.ObjectClass; |
| import org.apache.directory.shared.ldap.model.schema.SchemaManager; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| |
| /** |
| * A class used for reading the configuration present in a Partition |
| * and instantiate the necessary objects like DirectoryService, Interceptors etc. |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| public class ConfigPartitionReader |
| { |
| /** The logger for this class */ |
| private static final Logger LOG = LoggerFactory.getLogger( ConfigPartitionReader.class ); |
| |
| /** the partition which holds the configuration data */ |
| private BTreePartition<Long> configPartition; |
| |
| /** the search engine of the partition */ |
| private SearchEngine<Entry, Long> se; |
| |
| /** the schema manager set in the config partition */ |
| private SchemaManager schemaManager; |
| |
| /** The prefix for all the configuration ObjectClass names */ |
| private static final String ADS_PREFIX = "ads-"; |
| |
| /** The suffix for the bean */ |
| private static final String ADS_SUFFIX = "Bean"; |
| |
| /** Those two flags are used to tell the reader if an element of configuration is mandatory or not */ |
| private static final boolean MANDATORY = true; |
| private static final boolean OPTIONNAL = false; |
| |
| |
| /** |
| * |
| * Creates a new instance of ConfigPartitionReader. |
| * |
| * @param configPartition the non null config partition |
| */ |
| public ConfigPartitionReader( BTreePartition<Long> configPartition ) |
| { |
| if ( configPartition == null ) |
| { |
| throw new IllegalArgumentException( I18n.err( I18n.ERR_503 ) ); |
| } |
| |
| if ( !configPartition.isInitialized() ) |
| { |
| throw new IllegalStateException( I18n.err( I18n.ERR_504 ) ); |
| } |
| |
| this.configPartition = configPartition; |
| se = configPartition.getSearchEngine(); |
| this.schemaManager = configPartition.getSchemaManager(); |
| } |
| |
| |
| /** |
| * Fnd the upper objectclass in a hierarchy. All the inherited ObjectClasses |
| * will be removed. |
| */ |
| private ObjectClass findObjectClass( EntryAttribute objectClass ) throws Exception |
| { |
| Set<ObjectClass> candidates = new HashSet<ObjectClass>(); |
| |
| try |
| { |
| // Create the set of candidates |
| for ( Value<?> ocValue : objectClass ) |
| { |
| String ocName = ocValue.getString(); |
| String ocOid = schemaManager.getObjectClassRegistry().getOidByName( ocName ); |
| ObjectClass oc = ( ObjectClass ) schemaManager.getObjectClassRegistry().get( ocOid ); |
| |
| if ( oc.isStructural() ) |
| { |
| candidates.add( oc ); |
| } |
| } |
| } |
| catch ( Exception e ) |
| { |
| e.printStackTrace(); |
| throw e; |
| } |
| |
| // Now find the parent OC |
| for ( Value<?> ocValue : objectClass ) |
| { |
| String ocName = ocValue.getString(); |
| String ocOid = schemaManager.getObjectClassRegistry().getOidByName( ocName ); |
| ObjectClass oc = ( ObjectClass ) schemaManager.getObjectClassRegistry().get( ocOid ); |
| |
| for ( ObjectClass superior : oc.getSuperiors() ) |
| { |
| if ( oc.isStructural() ) |
| { |
| if ( candidates.contains( superior ) ) |
| { |
| candidates.remove( superior ); |
| } |
| } |
| } |
| } |
| |
| // The remaining OC in the candidates set is the one we are looking for |
| ObjectClass result = candidates.toArray( new ObjectClass[] |
| {} )[0]; |
| |
| LOG.debug( "The top level object class is {}", result.getName() ); |
| return result; |
| } |
| |
| |
| /** |
| * Create the base Bean from the ObjectClass name. |
| * The bean name is constructed using the OjectClass name, by |
| * removing the ADS prefix, upper casing the first letter and adding "Bean" at the end. |
| * |
| * For instance, ads-directoryService wil become DirectoryServiceBean |
| */ |
| private AdsBaseBean createBean( ObjectClass objectClass ) throws ConfigurationException |
| { |
| // The remaining OC in the candidates set is the one we are looking for |
| String objectClassName = objectClass.getName(); |
| |
| // Now, let's instanciate the associated bean. Get rid of the 'ads-' in front of the name, |
| // and uppercase the first letter. Finally add "Bean" at the end and add the package. |
| //String beanName = this.getClass().getPackage().getName() + "org.apache.directory.server.config.beans." + Character.toUpperCase( objectClassName.charAt( 4 ) ) + objectClassName.substring( 5 ) + "Bean"; |
| String beanName = this.getClass().getPackage().getName() + ".beans." + |
| Character.toUpperCase( objectClassName.charAt( ADS_PREFIX.length() ) ) + |
| objectClassName.substring( ADS_PREFIX.length() + 1 ) + ADS_SUFFIX; |
| |
| try |
| { |
| Class<?> clazz = Class.forName( beanName ); |
| Constructor<?> constructor = clazz.getConstructor(); |
| AdsBaseBean bean = ( AdsBaseBean ) constructor.newInstance(); |
| |
| LOG.debug( "Bean {} created for ObjectClass {}", beanName, objectClassName ); |
| |
| return bean; |
| } |
| catch ( ClassNotFoundException cnfe ) |
| { |
| String message = "Cannot find a Bean class for the ObjectClass name " + objectClassName; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( SecurityException se ) |
| { |
| String message = "Cannot access to the class " + beanName; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( NoSuchMethodException nsme ) |
| { |
| String message = "Cannot find a constructor for the class " + beanName; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( InvocationTargetException ite ) |
| { |
| String message = "Cannot invoke the class " + beanName + ", " + ite.getMessage(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( IllegalAccessException iae ) |
| { |
| String message = "Cannot access to the constructor for class " + beanName; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( InstantiationException ie ) |
| { |
| String message = "Cannot instanciate the class " + beanName + ", " + ie.getMessage(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| |
| |
| /** |
| * Retrieve the Field associated with an AttributeType name, if any. |
| */ |
| private static Field getField( Class<?> clazz, String attributeName, Class<?> originalClazz ) |
| throws ConfigurationException |
| { |
| // We will check all the fields, as the AT name is case insentitive |
| // when the field is case sensitive |
| Field[] fields = clazz.getDeclaredFields(); |
| |
| for ( Field field : fields ) |
| { |
| String fieldName = field.getName(); |
| |
| if ( fieldName.equalsIgnoreCase( attributeName ) ) |
| { |
| return field; |
| } |
| } |
| |
| // May be in the paren'ts class ? |
| if ( clazz.getSuperclass() != null ) |
| { |
| return getField( clazz.getSuperclass(), attributeName, originalClazz ); |
| } |
| |
| String message = "Cannot find a field named " + attributeName + " in class " + originalClazz.getName(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| |
| |
| /** |
| * Read the single entry value for an AttributeType, and feed the Bean field with this value |
| */ |
| private void readSingleValueField( AdsBaseBean bean, Field beanField, EntryAttribute fieldAttr, boolean mandatory ) |
| throws ConfigurationException |
| { |
| if ( fieldAttr == null ) |
| { |
| return; |
| } |
| |
| Value<?> value = fieldAttr.get(); |
| String valueStr = value.getString(); |
| Class<?> type = beanField.getType(); |
| |
| // Process the value accordingly to its type. |
| try |
| { |
| if ( type == String.class ) |
| { |
| beanField.set( bean, value.getString() ); |
| } |
| else if ( type == int.class ) |
| { |
| beanField.setInt( bean, Integer.parseInt( valueStr ) ); |
| } |
| else if ( type == long.class ) |
| { |
| beanField.setLong( bean, Long.parseLong( valueStr ) ); |
| } |
| else if ( type == boolean.class ) |
| { |
| beanField.setBoolean( bean, Boolean.parseBoolean( valueStr ) ); |
| } |
| else if ( type == Dn.class ) |
| { |
| try |
| { |
| Dn dn = new Dn( valueStr ); |
| beanField.set( bean, dn ); |
| } |
| catch ( LdapInvalidDnException lide ) |
| { |
| String message = "The Dn '" + valueStr + "' for attribute " + fieldAttr.getId() |
| + " is not a valid Dn"; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| String message = "Cannot store '" + valueStr + "' into attribute " + fieldAttr.getId(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( IllegalAccessException e ) |
| { |
| String message = "Cannot store '" + valueStr + "' into attribute " + fieldAttr.getId(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| |
| |
| /** |
| * Read the multiple entry value for an AttributeType, and feed the Bean field with this value |
| */ |
| private void readMultiValuedField( AdsBaseBean bean, Field beanField, EntryAttribute fieldAttr, boolean mandatory ) |
| throws ConfigurationException |
| { |
| if ( fieldAttr == null ) |
| { |
| return; |
| } |
| |
| Class<?> type = beanField.getType(); |
| |
| String fieldName = beanField.getName(); |
| String addMethodName = "add" + Character.toUpperCase( fieldName.charAt( 0 ) ) + fieldName.substring( 1 ); |
| |
| // loop on the values and inject them in the bean |
| for ( Value<?> value : fieldAttr ) |
| { |
| String valueStr = value.getString(); |
| |
| try |
| { |
| if ( type == String.class ) |
| { |
| beanField.set( bean, value.getString() ); |
| } |
| else if ( type == int.class ) |
| { |
| beanField.setInt( bean, Integer.parseInt( valueStr ) ); |
| } |
| else if ( type == long.class ) |
| { |
| beanField.setLong( bean, Long.parseLong( valueStr ) ); |
| } |
| else if ( type == boolean.class ) |
| { |
| beanField.setBoolean( bean, Boolean.parseBoolean( valueStr ) ); |
| } |
| else if ( type == Dn.class ) |
| { |
| try |
| { |
| Dn dn = new Dn( valueStr ); |
| beanField.set( bean, dn ); |
| } |
| catch ( LdapInvalidDnException lide ) |
| { |
| String message = "The Dn '" + valueStr + "' for attribute " + fieldAttr.getId() |
| + " is not a valid Dn"; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| else if ( type == Set.class ) |
| { |
| Type genericFieldType = beanField.getGenericType(); |
| Class<?> fieldArgClass = null; |
| |
| if ( genericFieldType instanceof ParameterizedType ) |
| { |
| ParameterizedType parameterizedType = ( ParameterizedType ) genericFieldType; |
| Type[] fieldArgTypes = parameterizedType.getActualTypeArguments(); |
| |
| for ( Type fieldArgType : fieldArgTypes ) |
| { |
| fieldArgClass = ( Class<?> ) fieldArgType; |
| } |
| } |
| |
| Method method = bean.getClass().getMethod( addMethodName, |
| Array.newInstance( fieldArgClass, 0 ).getClass() ); |
| |
| method.invoke( bean, new Object[] |
| { new String[] |
| { valueStr } } ); |
| } |
| else if ( type == List.class ) |
| { |
| Type genericFieldType = beanField.getGenericType(); |
| Class<?> fieldArgClass = null; |
| |
| if ( genericFieldType instanceof ParameterizedType ) |
| { |
| ParameterizedType parameterizedType = ( ParameterizedType ) genericFieldType; |
| Type[] fieldArgTypes = parameterizedType.getActualTypeArguments(); |
| |
| for ( Type fieldArgType : fieldArgTypes ) |
| { |
| fieldArgClass = ( Class<?> ) fieldArgType; |
| } |
| } |
| |
| Method method = bean.getClass().getMethod( addMethodName, |
| Array.newInstance( fieldArgClass, 0 ).getClass() ); |
| |
| method.invoke( bean, new Object[] |
| { new String[] |
| { valueStr } } ); |
| } |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| String message = "Cannot store '" + valueStr + "' into attribute " + fieldAttr.getId(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( IllegalAccessException e ) |
| { |
| String message = "Cannot store '" + valueStr + "' into attribute " + fieldAttr.getId(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( SecurityException se ) |
| { |
| String message = "Cannot access to the class " + bean.getClass().getName(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( NoSuchMethodException nsme ) |
| { |
| String message = "Cannot find a method " + addMethodName + " in the class " + bean.getClass().getName(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( InvocationTargetException ite ) |
| { |
| String message = "Cannot invoke the class " + bean.getClass().getName() + ", " + ite.getMessage(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| catch ( NegativeArraySizeException nase ) |
| { |
| // No way that can happen... |
| } |
| } |
| } |
| |
| |
| /** |
| * Read all the required fields (AttributeTypes) for a given Entry. |
| */ |
| private void readFields( AdsBaseBean bean, Entry entry, Set<MutableAttributeTypeImpl> attributeTypes, boolean mandatory ) |
| throws NoSuchFieldException, IllegalAccessException, Exception |
| { |
| for ( MutableAttributeTypeImpl attributeType : attributeTypes ) |
| { |
| String fieldName = attributeType.getName(); |
| String beanFieldName = fieldName; |
| |
| // Remove the "ads-" from the beginning of the field name |
| if ( fieldName.startsWith( ADS_PREFIX ) ) |
| { |
| beanFieldName = fieldName.substring( ADS_PREFIX.length() ); |
| } |
| |
| // Get the field |
| Field beanField = getField( bean.getClass(), beanFieldName, bean.getClass() ); |
| |
| // The field is private, we need to modify it to be able to access it. |
| beanField.setAccessible( true ); |
| |
| // Get the entry attribute for this field |
| EntryAttribute fieldAttr = entry.get( fieldName ); |
| |
| if ( ( fieldAttr == null ) && ( mandatory ) ) |
| { |
| String message = "Attribute " + fieldName + " is mandatory and is not present for the Entry " |
| + entry.getDn(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| |
| // Get the associated AttributeType |
| MutableAttributeTypeImpl beanAT = schemaManager.getAttributeType( fieldName ); |
| |
| // Check if this AT has the ads-compositeElement as a superior |
| MutableAttributeTypeImpl superior = beanAT.getSuperior(); |
| |
| if ( ( superior != null ) |
| && superior.getOid().equals( ConfigSchemaConstants.ADS_COMPOSITE_ELEMENT_AT.getOid() ) ) |
| { |
| // This is a composite element, we have to go one level down to read it. |
| // First, check if it's a SingleValued element |
| if ( beanAT.isSingleValued() ) |
| { |
| // Yes : get the first element |
| List<AdsBaseBean> beans = read( entry.getDn(), fieldName, SearchScope.ONELEVEL, mandatory ); |
| |
| // We may not have found an element, but if the attribute is mandatory, |
| // this is an error |
| if ( ( beans == null ) || ( beans.size() == 0 ) ) |
| { |
| if ( mandatory ) |
| { |
| // This is an error ! |
| String message = "The composite " + beanAT.getName() |
| + " is mandatory, and was not found under the " |
| + "configuration entry " + entry.getDn(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| else |
| { |
| // We must take the first element |
| AdsBaseBean readBean = beans.get( 0 ); |
| |
| if ( beans.size() > 1 ) |
| { |
| // Not allowed as the AT is singled-valued |
| String message = "We have more than one entry for " + beanAT.getName() + " under " |
| + entry.getDn(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| |
| beanField.set( bean, readBean ); |
| } |
| } |
| else |
| { |
| // No : we have to loop recursively on all the elements which are |
| // under the ou=<element-name> branch |
| Dn newBase = entry.getDn().add( "ou=" + beanFieldName ); |
| |
| // We have to remove the 's' at the end of the field name |
| String attributeName = fieldName.substring( 0, fieldName.length() - 1 ); |
| |
| // Sometime, the plural of a noun takes 'es' |
| if ( !schemaManager.getObjectClassRegistry().contains( attributeName ) ) |
| { |
| // Try by removing 'es' |
| attributeName = fieldName.substring( 0, fieldName.length() - 2 ); |
| |
| if ( !schemaManager.getObjectClassRegistry().contains( attributeName ) ) |
| { |
| String message = "Cannot find the ObjectClass named " + attributeName + " in the schema"; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| |
| // This is a multi-valued element, it can be a Set or a List |
| Collection<AdsBaseBean> beans = read( newBase, attributeName, SearchScope.ONELEVEL, mandatory ); |
| |
| if ( ( beans == null ) || ( beans.size() == 0 ) ) |
| { |
| // If the element is mandatory, this is an error |
| if ( mandatory ) |
| { |
| String message = "The composite " + beanAT.getName() |
| + " is mandatory, and was not found under the " |
| + "configuration entry " + entry.getDn(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| } |
| else |
| { |
| // Update the field |
| beanField.set( bean, beans ); |
| } |
| } |
| } |
| else |
| // A standard AttributeType (ie, boolean, long, int or String) |
| { |
| // Process the field accordingly to its cardinality |
| if ( beanAT.isSingleValued() ) |
| { |
| readSingleValueField( bean, beanField, fieldAttr, mandatory ); |
| } |
| else |
| { |
| readMultiValuedField( bean, beanField, fieldAttr, mandatory ); |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Get the list of MUST AttributeTypes for an objectClass |
| */ |
| private Set<MutableAttributeTypeImpl> getAllMusts( ObjectClass objectClass ) |
| { |
| Set<MutableAttributeTypeImpl> musts = new HashSet<MutableAttributeTypeImpl>(); |
| |
| // First, gets the direct MUST |
| musts.addAll( objectClass.getMustAttributeTypes() ); |
| |
| // then add all the superiors MUST (recursively) |
| List<ObjectClass> superiors = objectClass.getSuperiors(); |
| |
| if ( superiors != null ) |
| { |
| for ( ObjectClass superior : superiors ) |
| { |
| musts.addAll( getAllMusts( superior ) ); |
| } |
| } |
| |
| return musts; |
| } |
| |
| |
| /** |
| * Get the list of MAY AttributeTypes for an objectClass |
| */ |
| private Set<MutableAttributeTypeImpl> getAllMays( ObjectClass objectClass ) |
| { |
| Set<MutableAttributeTypeImpl> mays = new HashSet<MutableAttributeTypeImpl>(); |
| |
| // First, gets the direct MAY |
| mays.addAll( objectClass.getMayAttributeTypes() ); |
| |
| // then add all the superiors MAY (recursively) |
| List<ObjectClass> superiors = objectClass.getSuperiors(); |
| |
| if ( superiors != null ) |
| { |
| for ( ObjectClass superior : superiors ) |
| { |
| mays.addAll( getAllMays( superior ) ); |
| } |
| } |
| |
| return mays; |
| } |
| |
| |
| /** |
| * Helper method to print a list of AT's names. |
| */ |
| private String dumpATs( Set<MutableAttributeTypeImpl> attributeTypes ) |
| { |
| if ( ( attributeTypes == null ) || ( attributeTypes.size() == 0 ) ) |
| { |
| return ""; |
| } |
| |
| StringBuilder sb = new StringBuilder(); |
| boolean isFirst = true; |
| sb.append( '{' ); |
| |
| for ( MutableAttributeTypeImpl attributeType : attributeTypes ) |
| { |
| if ( isFirst ) |
| { |
| isFirst = false; |
| } |
| else |
| { |
| sb.append( ", " ); |
| } |
| |
| sb.append( attributeType.getName() ); |
| } |
| |
| sb.append( '}' ); |
| |
| return sb.toString(); |
| } |
| |
| |
| /** |
| * Read some configuration element from the DIT using its name |
| */ |
| private List<AdsBaseBean> read( Dn baseDn, String name, SearchScope scope, boolean mandatory ) |
| throws ConfigurationException |
| { |
| LOG.debug( "Reading from '{}', entry {}", baseDn, name ); |
| |
| // Search for the element starting at some point in the DIT |
| // Prepare the search request |
| MutableAttributeTypeImpl adsdAt = schemaManager.getAttributeType( SchemaConstants.OBJECT_CLASS_AT ); |
| EqualityNode<?> filter = new EqualityNode( adsdAt, new StringValue( name ) ); |
| SearchControls controls = new SearchControls(); |
| controls.setSearchScope( scope.ordinal() ); |
| IndexCursor<Long, Entry, Long> cursor = null; |
| |
| // Create a container for all the read beans |
| List<AdsBaseBean> beans = new ArrayList<AdsBaseBean>(); |
| |
| try |
| { |
| // Do the search |
| cursor = se.cursor( baseDn, AliasDerefMode.NEVER_DEREF_ALIASES, filter, controls ); |
| |
| // First, check if we have some entries to process. |
| if ( !cursor.next() ) |
| { |
| if ( mandatory ) |
| { |
| cursor.close(); |
| |
| // the requested element is mandatory so let's throw an exception |
| String message = "No directoryService instance was configured under the Dn " |
| + configPartition.getSuffix(); |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| // Loop on all the found elements |
| do |
| { |
| ForwardIndexEntry<Long, Entry, Long> forwardEntry = ( ForwardIndexEntry<Long, Entry, Long> ) cursor |
| .get(); |
| |
| // Now, get the entry |
| Entry entry = configPartition.lookup( forwardEntry.getId() ); |
| LOG.debug( "Entry read : {}", entry ); |
| |
| // Let's instanciate the bean we need. The upper ObjectClass's name |
| // will be used to do that |
| EntryAttribute objectClassAttr = entry.get( SchemaConstants.OBJECT_CLASS_AT ); |
| |
| ObjectClass objectClass = findObjectClass( objectClassAttr ); |
| AdsBaseBean bean = createBean( objectClass ); |
| |
| // Now, read the AttributeTypes and store the values into the bean fields |
| // The MAY |
| Set<MutableAttributeTypeImpl> mays = getAllMays( objectClass ); |
| LOG.debug( "Fetching the following MAY attributes : {}", dumpATs( mays ) ); |
| readFields( bean, entry, mays, OPTIONNAL ); |
| |
| // The MUST |
| Set<MutableAttributeTypeImpl> musts = getAllMusts( objectClass ); |
| LOG.debug( "Fetching the following MAY attributes : {}", dumpATs( musts ) ); |
| readFields( bean, entry, musts, MANDATORY ); |
| |
| bean.setDn( entry.getDn() ); |
| |
| // Done, we can add the bean into the list |
| beans.add( bean ); |
| } |
| while ( cursor.next() ); |
| } |
| catch ( ConfigurationException ce ) |
| { |
| ce.printStackTrace(); |
| throw ce; |
| } |
| catch ( Exception e ) |
| { |
| String message = "Cannot open a cursor to read the configuration on " + baseDn; |
| LOG.error( message ); |
| throw new ConfigurationException( message ); |
| } |
| finally |
| { |
| if ( cursor != null ) |
| { |
| try |
| { |
| cursor.close(); |
| } |
| catch ( Exception e ) |
| { |
| // So ??? If the cursor can't be close, there is nothing we can do |
| // but rethrow the exception |
| throw new ConfigurationException( e.getMessage(), e.getCause() ); |
| } |
| } |
| } |
| |
| return beans; |
| |
| } |
| |
| |
| /** |
| * Read the configuration from the DIT, returning a bean containing all of it. |
| * <p> |
| * This method implicitly uses <em>"ou=config"</em> as base Dn |
| * |
| * @return The Config bean, containing the whole configuration |
| * @throws ConfigurationException If we had some issue reading the configuration |
| */ |
| public ConfigBean readConfig() throws LdapException |
| { |
| // The starting point is the DirectoryService element |
| return readConfig( new Dn( new Rdn( SchemaConstants.OU_AT, "config" ) ) ); |
| } |
| |
| |
| /** |
| * Read the configuration from the DIT, returning a bean containing all of it. |
| * |
| * @param base The base Dn in the DIT where the configuration is stored |
| * @return The Config bean, containing the whole configuration |
| * @throws ConfigurationException If we had some issue reading the configuration |
| */ |
| public ConfigBean readConfig( String baseDn ) throws LdapException |
| { |
| // The starting point is the DirectoryService element |
| return readConfig( new Dn( baseDn ), ConfigSchemaConstants.ADS_DIRECTORY_SERVICE_OC.getValue() ); |
| } |
| |
| |
| /** |
| * Read the configuration from the DIT, returning a bean containing all of it. |
| * |
| * @param base The base Dn in the DIT where the configuration is stored |
| * @return The Config bean, containing the whole configuration |
| * @throws ConfigurationException If we had some issue reading the configuration |
| */ |
| public ConfigBean readConfig( Dn baseDn ) throws ConfigurationException |
| { |
| // The starting point is the DirectoryService element |
| return readConfig( baseDn, ConfigSchemaConstants.ADS_DIRECTORY_SERVICE_OC.getValue() ); |
| } |
| |
| |
| /** |
| * Read the configuration from the DIT, returning a bean containing all of it. |
| * |
| * @param baseDn The base Dn in the DIT where the configuration is stored |
| * @param objectClass The element to read from the DIT |
| * @return The bean containing the configuration for the required element |
| * @throws ConfigurationException |
| */ |
| public ConfigBean readConfig( String baseDn, String objectClass ) throws LdapException |
| { |
| return readConfig( new Dn( baseDn ), objectClass ); |
| } |
| |
| |
| /** |
| * Read the configuration from the DIT, returning a bean containing all of it. |
| * |
| * @param baseDn The base Dn in the DIT where the configuration is stored |
| * @param objectClass The element to read from the DIT |
| * @return The bean containing the configuration for the required element |
| * @throws ConfigurationException |
| */ |
| public ConfigBean readConfig( Dn baseDn, String objectClass ) throws ConfigurationException |
| { |
| LOG.debug( "Reading configuration for the {} element, from {} ", objectClass, baseDn ); |
| ConfigBean configBean = new ConfigBean(); |
| |
| if ( baseDn == null ) |
| { |
| baseDn = configPartition.getSuffix(); |
| } |
| |
| List<AdsBaseBean> beans = read( baseDn, objectClass, SearchScope.ONELEVEL, MANDATORY ); |
| |
| if ( LOG.isDebugEnabled() ) |
| { |
| if ( ( beans == null ) || ( beans.size() == 0 ) ) |
| { |
| LOG.debug( "No {} element to read", objectClass ); |
| } |
| else |
| { |
| LOG.debug( beans.get( 0 ).toString() ); |
| } |
| } |
| |
| configBean.setDirectoryServiceBeans( beans ); |
| |
| return configBean; |
| } |
| } |
