directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r1183537 [6/11] - in /directory/apacheds/trunk/interceptors: admin/ admin/.settings/ authn/ authn/.settings/ authz/.settings/ changelog/ changelog/src/ changelog/src/main/ changelog/src/main/java/ changelog/src/main/java/org/ changelog/src/...
Date Fri, 14 Oct 2011 22:36:15 GMT
Added: directory/apacheds/trunk/interceptors/schema/src/main/java/org/apache/directory/server/core/schema/PartitionSchemaLoader.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/interceptors/schema/src/main/java/org/apache/directory/server/core/schema/PartitionSchemaLoader.java?rev=1183537&view=auto
==============================================================================
--- directory/apacheds/trunk/interceptors/schema/src/main/java/org/apache/directory/server/core/schema/PartitionSchemaLoader.java
(added)
+++ directory/apacheds/trunk/interceptors/schema/src/main/java/org/apache/directory/server/core/schema/PartitionSchemaLoader.java
Fri Oct 14 22:36:08 2011
@@ -0,0 +1,615 @@
+/*
+ *  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.core.schema;
+
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.directory.server.core.api.filtering.EntryFilteringCursor;
+import org.apache.directory.server.core.api.interceptor.context.EntryOperationContext;
+import org.apache.directory.server.core.api.interceptor.context.ListOperationContext;
+import org.apache.directory.server.core.api.interceptor.context.SearchOperationContext;
+import org.apache.directory.server.core.api.partition.Partition;
+import org.apache.directory.server.core.api.schema.SchemaPartitionDao;
+import org.apache.directory.server.core.api.schema.SchemaPartitionDaoImpl;
+import org.apache.directory.server.core.normalization.FilterNormalizingVisitor;
+import org.apache.directory.server.i18n.I18n;
+import org.apache.directory.shared.ldap.model.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.model.entry.Attribute;
+import org.apache.directory.shared.ldap.model.entry.Entry;
+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.exception.LdapOtherException;
+import org.apache.directory.shared.ldap.model.filter.ExprNode;
+import org.apache.directory.shared.ldap.model.filter.FilterParser;
+import org.apache.directory.shared.ldap.model.message.SearchScope;
+import org.apache.directory.shared.ldap.model.name.Dn;
+import org.apache.directory.shared.ldap.model.schema.AttributeType;
+import org.apache.directory.shared.ldap.model.schema.SchemaManager;
+import org.apache.directory.shared.ldap.model.schema.normalizers.ConcreteNameComponentNormalizer;
+import org.apache.directory.shared.ldap.model.schema.normalizers.NameComponentNormalizer;
+import org.apache.directory.shared.ldap.model.schema.registries.AbstractSchemaLoader;
+import org.apache.directory.shared.ldap.model.schema.registries.Registries;
+import org.apache.directory.shared.ldap.model.schema.registries.Schema;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * A class that loads schemas from a partition.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+public class PartitionSchemaLoader extends AbstractSchemaLoader
+{
+    /** static class logger */
+    private static final Logger LOG = LoggerFactory.getLogger( PartitionSchemaLoader.class
);
+
+    private final SchemaPartitionDao dao;
+    private Partition partition;
+
+    /** The attributeType registry */
+    private SchemaManager schemaManager;
+
+    private final AttributeType cnAT;
+
+
+    public PartitionSchemaLoader( Partition partition, SchemaManager schemaManager ) throws
Exception
+    {
+        this.partition = partition;
+        this.schemaManager = schemaManager;
+
+        dao = new SchemaPartitionDaoImpl( this.partition, schemaManager );
+        cnAT = schemaManager.getAttributeType( SchemaConstants.CN_AT );
+
+        initializeSchemas();
+    }
+
+
+    private void initializeSchemas() throws Exception
+    {
+        Dn dn = new Dn( schemaManager, SchemaConstants.OU_SCHEMA );
+
+        // Check that the ou=schema entry exists
+        if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+        {
+            return;
+        }
+
+        LOG.debug( "Loading schemas" );
+
+        // One-level search for all schema entries
+        SearchOperationContext searchCtx = new SearchOperationContext( null );
+        searchCtx.setDn( dn );
+        searchCtx.setScope( SearchScope.ONELEVEL );
+        ExprNode filter = FilterParser.parse(schemaManager, "(objectClass=metaSchema)");
+        NameComponentNormalizer ncn = new ConcreteNameComponentNormalizer( schemaManager
);
+        FilterNormalizingVisitor visitor = new FilterNormalizingVisitor( ncn, schemaManager
);
+        filter.accept( visitor );
+        searchCtx.setFilter( filter );
+        EntryFilteringCursor list = partition.search( searchCtx );
+
+        // Loop on all the schema entries
+        while ( list.next() )
+        {
+            Entry entry = list.get();
+            Schema schema = getSchema( entry );
+            schemaMap.put( schema.getSchemaName(), schema );
+        }
+    }
+
+
+    /**
+     * Gets the base Dn for an Schema Object
+     */
+    private Dn getBaseDN( String path, Schema schema ) throws LdapInvalidDnException
+    {
+        Dn dn = new Dn( schemaManager, path, "cn=" + schema.getSchemaName(), SchemaConstants.OU_SCHEMA
);
+
+        return dn;
+    }
+
+
+    /**
+     * Lists the names of the schemas that depend on the schema name provided.
+     * 
+     * @param schemaName the name of the schema to find dependents for
+     * @return a set of schemas (String names) that depend on the schema
+     * @throws Exception if there are problems searching the schema partition
+     */
+    public Set<String> listDependentSchemaNames( String schemaName ) throws Exception
+    {
+        Set<String> dependees = new HashSet<String>();
+        Set<Entry> results = dao.listSchemaDependents( schemaName );
+
+        if ( results.isEmpty() )
+        {
+            return dependees;
+        }
+
+        for ( Entry sr : results )
+        {
+            Attribute cn = sr.get( cnAT );
+            dependees.add( cn.getString() );
+        }
+
+        return dependees;
+    }
+
+
+    /**
+     * Lists the names of the enabled schemas that depend on the schema name 
+     * provided.
+     * 
+     * @param schemaName the name of the schema to find dependents for
+     * @return a set of enabled schemas (String names) that depend on the schema
+     * @throws Exception if there are problems searching the schema partition
+     */
+    public Set<String> listEnabledDependentSchemaNames( String schemaName ) throws
Exception
+    {
+        Set<String> dependees = new HashSet<String>();
+        Set<Entry> results = dao.listEnabledSchemaDependents( schemaName );
+
+        if ( results.isEmpty() )
+        {
+            return dependees;
+        }
+
+        for ( Entry sr : results )
+        {
+            Attribute cn = sr.get( cnAT );
+            dependees.add( cn.getString() );
+        }
+
+        return dependees;
+    }
+
+
+    public Map<String, Schema> getSchemas() throws Exception
+    {
+        return dao.getSchemas();
+    }
+
+
+    public Set<String> getSchemaNames() throws Exception
+    {
+        return dao.getSchemaNames();
+    }
+
+
+    public Schema getSchema( String schemaName )
+    {
+        try
+        {
+            return dao.getSchema( schemaName );
+        }
+        catch ( Exception e )
+        {
+            // TODO fixme
+            return null;
+        }
+    }
+
+
+    public final void load( Schema schema, Registries targetRegistries, boolean isDepLoad
) throws Exception
+    {
+        // if we're loading a dependency and it has not been enabled on 
+        // disk then enable it on disk before we proceed to load it
+        if ( schema.isDisabled() && isDepLoad )
+        {
+            dao.enableSchema( schema.getSchemaName() );
+        }
+
+        if ( targetRegistries.isSchemaLoaded( schema.getSchemaName() ) )
+        {
+            LOG.debug( "schema {} already seems to be loaded", schema.getSchemaName() );
+            return;
+        }
+
+        LOG.debug( "loading {} schema ...", schema.getSchemaName() );
+
+        loadComparators( schema );
+        loadNormalizers( schema );
+        loadSyntaxCheckers( schema );
+        loadSyntaxes( schema );
+        loadMatchingRules( schema );
+        loadAttributeTypes( schema );
+        loadObjectClasses( schema );
+        loadMatchingRuleUses( schema );
+        loadDitContentRules( schema );
+        loadNameForms( schema );
+
+        // order does matter here so some special trickery is needed
+        // we cannot load a DSR before the DSRs it depends on are loaded?
+        // TODO need to confirm this ( or we must make the class for this and use deferred

+        // resolution until everything is available?
+
+        loadDitStructureRules( schema );
+
+        notifyListenerOrRegistries( schema, targetRegistries );
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadAttributeTypes( Schema... schemas ) throws LdapException
+    {
+        List<Entry> attributeTypeList = new ArrayList<Entry>();
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.ATTRIBUTE_TYPES_PATH, schema );
+
+            // Check that we don't have an entry in the Dit for this schema
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                // No : get out, no AttributeType to load
+                return attributeTypeList;
+            }
+
+            LOG.debug( "{} schema: loading attributeTypes", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                // Loop on all the AttributeTypes and add them to the list
+                while ( list.next() )
+                {
+                    Entry result = list.get();
+    
+                    attributeTypeList.add( result );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return attributeTypeList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadComparators( Schema... schemas ) throws LdapException
+    {
+        List<Entry> comparatorList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return comparatorList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.COMPARATORS_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return comparatorList;
+            }
+
+            LOG.debug( "{} schema: loading comparators", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    comparatorList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return comparatorList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadDitContentRules( Schema... schemas ) throws LdapException
+    {
+        LOG.error( I18n.err( I18n.ERR_86 ) );
+
+        List<Entry> ditContentRuleList = new ArrayList<Entry>();
+        return ditContentRuleList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadDitStructureRules( Schema... schemas ) throws LdapException
+    {
+        LOG.error( I18n.err( I18n.ERR_87 ) );
+
+        List<Entry> ditStructureRuleList = new ArrayList<Entry>();
+        return ditStructureRuleList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadMatchingRules( Schema... schemas ) throws LdapException
+    {
+        List<Entry> matchingRuleList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return matchingRuleList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.MATCHING_RULES_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return matchingRuleList;
+            }
+
+            LOG.debug( "{} schema: loading matchingRules", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    matchingRuleList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return matchingRuleList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadMatchingRuleUses( Schema... schemas ) throws LdapException
+    {
+        LOG.error( I18n.err( I18n.ERR_88 ) );
+
+        List<Entry> matchingRuleUsesList = new ArrayList<Entry>();
+        return matchingRuleUsesList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadNameForms( Schema... schemas ) throws LdapException
+    {
+        LOG.error( I18n.err( I18n.ERR_89 ) );
+
+        List<Entry> nameFormList = new ArrayList<Entry>();
+        return nameFormList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadNormalizers( Schema... schemas ) throws LdapException
+    {
+        List<Entry> normalizerList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return normalizerList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.NORMALIZERS_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return normalizerList;
+            }
+
+            LOG.debug( "{} schema: loading normalizers", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    normalizerList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return normalizerList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadObjectClasses( Schema... schemas ) throws LdapException
+    {
+        List<Entry> objectClassList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return objectClassList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.OBJECT_CLASSES_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return objectClassList;
+            }
+
+            LOG.debug( "{} schema: loading objectClasses", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    objectClassList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return objectClassList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadSyntaxes( Schema... schemas ) throws LdapException
+    {
+        List<Entry> syntaxList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return syntaxList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.SYNTAXES_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return syntaxList;
+            }
+
+            LOG.debug( "{} schema: loading syntaxes", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    syntaxList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return syntaxList;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    public List<Entry> loadSyntaxCheckers( Schema... schemas ) throws LdapException
+    {
+        List<Entry> syntaxCheckerList = new ArrayList<Entry>();
+
+        if ( schemas == null )
+        {
+            return syntaxCheckerList;
+        }
+
+        for ( Schema schema : schemas )
+        {
+            Dn dn = getBaseDN( SchemaConstants.SYNTAX_CHECKERS_PATH, schema );
+
+            if ( !partition.hasEntry( new EntryOperationContext( null, dn ) ) )
+            {
+                return syntaxCheckerList;
+            }
+
+            LOG.debug( "{} schema: loading syntaxCsheckers", schema.getSchemaName() );
+
+            EntryFilteringCursor list = partition.list( new ListOperationContext( null, dn
) );
+
+            try
+            {            
+                while ( list.next() )
+                {
+                    Entry entry = list.get();
+    
+                    syntaxCheckerList.add( entry );
+                }
+            }
+            catch ( Exception e )
+            {
+                throw new LdapOtherException( e.getMessage(), e );
+            }
+        }
+
+        return syntaxCheckerList;
+    }
+
+
+    /**
+     * @return the dao
+     */
+    public SchemaPartitionDao getDao()
+    {
+        return dao;
+    }
+}



Mime
View raw message