Apache DS SchemaManager

Page edited by Emmanuel L=C3=83=C2=A9charny

=20

Introduction

Apache DS has to keep a lot of internal structures available from all th= e parts of the server. This is done through what we call the SchemaManag= er. It hide all the internal structure from the users.

SchemaManager

The SchemaManager stores Registries, which are hives where= each SchemaObjects are stored. We also store some dedicated data st= ructures :

factory : The object responsible for the SchemaObject instanc= e creation, given an Entry containing a SchemaObject description =09
namingContext : The partition this* SchemaManager* is associ= ated with. In the future, we want to associate a SchemaManager to a = Partition, allowing the server to have more than one SchemaManager =09
registries : The container for all the SchemaObject Registrie= s
schemaLoader : The loader for this instance. SchemaObjects ma= y be stored on disk, in a database... The loader is responsible for their r= etrieval
errors : The list of errors we got when we have updated the schema. = It should be empty before we can use this SchemaManager in the server

h2 Registries
This is the internal container for all the SchemaObject registries. = When modifying the schema, this object will be cloned, modified, chekced, a= nd if thee is no error, we will apply those modifications to the real regis= tries.

It contains a set of fields used to manage the schema :

globalOidRegistry : It stores the list of all the SchemaObject*s'= OIDs. A *SchemaObject has a unique OID in a SchemaManager =09
<SchemaObject>Registry : A registry per SchemaObject ty= pe.
loadedSchemas : The list of all the loaded schemas
schemaObjectsBySchemaName : A list of all SchemaObjects per s= chema
usedBy : a map containing the list of SchemaObject referencin= g a given SchemaObject
using : a map containing the list of SchemaObject used by a g= iven SchemaObject

SchemaObje= ct Registries

For each different type of SchemaObject, we have a dedicated Regi= stry.

The following diagram shows the class diagram for those registries :

SchemaObjects

We have 11 different SchemaObjects, 3 of them are Apache DS speci= fic :

(AT) AttributeType
(C) Comparator (specific)
(DCR) DITContentRule
(DSR) DITStructureRule
(MR) MatchingRule
(MRU) MatchingRuleUse
(NF) NameForm
(N) Normalizer (specific)
(OC) ObjectClass
(S) Syntax
(SC) SyntaxChecker (specific)

The specific SchemaObjects are those we can load into the server dynamic= ally : they are compiled Java classes.

All the SchemaObjects are related with each other. The following = schema shows all the existing relations :

This class diagram exposes the relations between all those classes :

All the Registries contain two data structure :

byOid : stores all the associated SchemaObject by their OID
byName : stores all the associated SchemaObject by their name (slao = contains the oid)

Note that the ObjectClassRegistry and the AttributeTypeRegistry contain = a specific data structure
to keep a track of the descendants for each AT or OC.

AttributeType

Here are the fields stored in a AttributeType instance :

Work in progress

T= his site is in the process of being reviewed and updated.

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	ATTRIBUTE_TYPE
oid	AT OID
schemaName	N/A
specification	not modifiable
canUserModify	TRUE
equality	MR reference
equalityOid	MR OID
isCollective	FALSE
isSingleValued	FALSE
ordering	MR reference
orderingOid	MR OID
substring	MR reference
substringOid	MR OID
superior	AT reference
superiorOid	MR OID
syntax	Syntax reference
syntaxLength	0
syntaxOid	Syntax OID
usage	userApplications

Adding an A= ttributeType

Register the AttributeType into the AttributeTypeRegistry :
update the AttributeTypeRegistry.byOid : add <oid, AttributeType>
for all the attributeType names, plus the oid,
update the AttributeTypeRegistry.byName : add <name, AttributeType&g= t;
update the AttributeTypeRegistry.byName : add <oid, AttributeType> associate the AttributeType with the schema : <schema, set<SchemaObje= ct>> +=3D AttributeType
update the Registries.globalOidRegistry : add <oid, AttributeType>

We also have a special data structure to update :

When all the schema modifications will be done, do the additional update= s :

update the AttributeType.syntax : SyntaxRegistry.lookup( syntaxOid )
update the AttributeType.equality : MatchingRuleRegistry.lookup( equalityOi= d )
update the AttributeType.ordering : MatchingRuleRegistry.lookup( orderingOi= d )
update the AttributeType.substring : MatchingRuleRegistry.lookup( substring= Oid )
update the AttributeType.sup : AttributeTypeRegistry.lookup( superiorOid )<= br/> update the Registries.using map : <AttributeType.oid, set<SchemaObjec= t>> +=3D
syntax, equality, ordering, substring, superior
update the Registries.usedBy map :
<Syntax.oid, set<SchemaObject>> +=3D AttributeType
<equalityOid, set<SchemaObject>> +=3D AttributeType
<orderingOid, set<SchemaObject>> +=3D AttributeType
<substringOid, set<SchemaObject>> +=3D AttributeType
<superiorOid, set<SchemaObject>> +=3D AttributeType

last, not least, update the AttributeTypeRegistry oidNormalizerMap and o= idToDescendant data structures :
AttributeTypeRegistry.oidNormalizerMap +=3D new OidNormalizer( oid, Norma= lizerRegistry.lookup( equality.getNormalizer() )
AttributeTypeRegistry.oidToDescendant : <superiorOid, Set<Attribute= Type>> +=3D attributeType

There are special cases to deal with :

if the Syntax is null, then inherit it from the superior, whcih must= not be null
if the equality is null, and if we have a superior, inherit the equa= lity from it
if there is a superior, the Usage must be the same than its superior= 's
if the superior is COLLECTIVE, the it must also be COLLECTIVE
if it's COLLECTIVE, then the Usage must be operational

NOTE : The OidNormalizerMap is probably useless

Modifyin= g an AttributeType

We won't create a new object, but will update the existing one. The OID = can't be changed

If we have changed one of the MRs, or the S, or the superior AT, when al= l the schema
modifications will be done, do the additional updates :
update the AttributeType.<MR/S/sup> : <MR/S/AT>Registry.lookup(= oid )
update the Registries.using map : <AttributeType.oid, set<SchemaObjec= t>> -=3D old <MR/S/AT>
update the Registries.using map : <AttributeType.oid, set<SchemzObjec= t>> +=3D new <MR/S/AT>
update the Registries.usedBy map : <old <MR/S/AT>.oid, set<Sche= maObject>> -=3D AttributeType
update the Registries.usedBy map : <new <MR/S/AT>.oid, set<Sche= maObject>> +=3D AttributeType
update the oidNormalizerMap : remove the Oidnormalizer, add the new one
update the oidToDescendant Map : remove the AT from the old superior, add i= t to the new superior

We will also have to check that the modified AT is still valid

Deleting = an AttributeType

We can't delete an AttributeType if it's refered by an ObjectClass, or a= nother AttributeType.
This is checked by verifying inthe usedBy table :

if usedBy.get( attributeType.oid ) is not empty, generate an error.

remove the oid from the AttributeTypeRegistry.byOid
for each AttributeType's name,
remove the AttributeType.name from the AttributeTypeRegistry.byName
+ remove the AttributeType.oid from the AttributeTypeRegistry.byName
remove all the names and the oid from the AttributeTypeRegistry.byName
remove the AttributeType from the bySchemaNameSchemaObject map : <schema= , set<SchemaObject>> -=3D AttributeType
remove the AttributeType.oid from the globalOidRegistry : remove <oid, A= ttributeType>
remove the AttributeType's OidNormalizer from the oidNormalizerMap

When all the schema modifications will be done, do the additional update= s :

update the Registries.using map : remove the relation <AttributeType.= oid, set<SchemaObject>>
update the Registries.usedBy map for each AT/MR/S referenced in the Attribu= teType :
<<AT/MR/S>.oid, set<SchemaObject>> -=3D AttributeType remove the AttributeType from the oidToDescendant Map

Comparator

Here are the fields stored in a Comparator instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	COMPARATOR
oid	MR OID
schemaName	N/A
specification	not modifiable
bytecode	not modifiable
fqcn	not modifiable

Adding a compar= ator

Register the comparator into the ComparatorRegistry :
update the ComparatorRegistry.byOid : add <oid, comparator>
update the ComparatorRegistry.byName : add <oid, comparator>
associate the Comparator with the schema : <schema, set<SchemaObject&= gt;> +=3D comparator

Modifying a = comparator

Nothing to do but update the comparator in place (replacing all the fiel= ds of the original comparator).

Note that all the fields are not modifiables.

Deleting a co= mparator

We can't delete a comparator if it is used by a MatchingRule. This is ch= ecked by verifying in
the usedBy table :

if usedBy.get( comparator.oid ) is not empty, generate an error.

This is a more complex operation, as we may have some MatchingRules poin= ting on this object.
We have to :
remove the oid from the ComparatorRegistry.byOid
remove the oid from the ComparatorRegistry.byName
remove the Comparator from the bySchemaNameSchemaObject map : <schema, s= et<SchemaObject>> -=3D comparator

DITContentRule
Not Yet Implemented

DITStructureRule=

Not Yet Implemented

MatchingRule

Here are the fields stored in a MatchingRule instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	ATTRIBUTE_TYPE
oid	AT OID
schemaName	N/A
ldapComparator	Comparator reference
ldapSyntax	Syntax reference
ldapSyntaxOid	The Syntax OID
normalizer	Normalizer reference

Adding a Matc= hingRule

Register the MatchingRule into the MatchingRuleRegistry :
update the MatchingRuleRegistry.byOid : add <oid, MatchingRule>
update the MatchingRuleRegistry.byName : add <oid, MatchingRule>
associate the MatchingRule with the schema : <schema, set<SchemaObjec= t>> +=3D MatchingRule
update the Registries.globalOidRegistry : add <oid, MatchingRule>

When all the schema modifications will be done, do the additional update= s :

update the MatchingRule.syntax : SyntaxRegistry.lookup( syntaxoid )
update the MatchingRule.normalizer : NormalizerRegistry.lookup( matchingRul= e.oid )
update the MatchingRule.comparator : ComparatorRegistry.lookup( matchingRul= e.oid )
update the Registries.using map : <MatchingRule.oid, set<SchemaObject= >> +=3D syntax, normalizer, comparator
update the Registries.usedBy map :
<Syntax.oid, set<SchemaObject>> +=3D MatchingRule
<Comparator.oid, set<SchemaObject>> +=3D MatchingRule
<Normalizer.oid, set<SchemaObject>> +=3D MatchingRule

Modifying = a MatchingRule

We won't create a new object, but will update the existing one. The OID = can't be changed

If we have changed the (N)ormalizer, the (S)yntax or the (C)omparator, w= hen all the schema
modifications will be done, do the additional updates :
update the MatchingRule.<C/N/S> : <C/S/N>Registry.lookup( oid )=
update the Registries.using map : <MatchingRule.oid, set<SchemaObject= >> -=3D old <C/S/N>
update the Registries.using map : <MatchingRule.oid, set<SchemzObject= >> +=3D new <C/S/N>
update the Registries.usedBy map : <old <C/S/N>.oid, set<Schema= Object>> -=3D MatchingRule
update the Registries.usedBy map : <new <C/S/N>.oid, set<Schema= Object>> +=3D MatchingRule

Deleting a = MatchingRule

We can't delete a MatchingRule which is used by an AttributeType. This i= s checked by verifying in
the usedBy table :

if usedBy.get( MatchingRule.oid ) is not empty, generate an error.

Otherwise, here are the operations we have to conduct :
remove the MatchingRule.oid from the MatchingRuleRegistry.byOid
for each MatchingRule's name,
remove the MatchingRule.name from the MatchingRuleRegistry.byName
+ remove the MatchingRule.oid from the MatchingRuleRegistry.byName
remove the MatchingRule from the bySchemaNameSchemaObject map : <schema,= set<SchemaObject>> -=3D MatchingRule
remove the Registries.globalOidRegistry : remove <oid, MatchingRule><= /p>

When all the schema modifications will be done, do the additional update= s :

update the Registries.using map : remove the relation <MatchingRule.o= id, set<SchemaObject>>
update the Registries.usedBy map for each C/S/N referenced in the MatchingR= ule :
<<C/S/N>.oid, set<SchemaObject>> -=3D MatchingRule

MatchingRuleUse
Not Yet Implemented

NameForm

Not Yet Implemented

Normaliz= er (specific)

Here are the fields stored in a Normalizer instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	NORMALIZER
oid	MR OID
schemaName	N/A
specification	not modifiable
bytecode	not modifiable
fqcn	not modifiable

Adding a Normal= izer

Register the Normalizer into the NormalizerRegistry :
update the NormalizerRegistry.byOid : add <oid, Normalizer>
update the NormalizerRegistry.byName : add <oid, Normalizer>
associate the Normalizer with the schema : <schema, set<SchemaObject&= gt;> +=3D Normalizer

Modifying a = Normalizer

Nothing to do but update the Normalizer in place (replacing all the fiel= ds of the original Normalizer).

Note that all the fields are not modifiables.

Deleting a No= rmalizer

We can't delete a Normalizer if it is used by a MatchingRule. This is ch= ecked by verifying in
the usedBy table :

if usedBy.get( Normalizer.oid ) is not empty, generate an error.

This is a more complex operation, as we may have some MatchingRules poin= ting on this object.
We have to :
remove the oid from the NormalizerRegistry.byOid
remove the oid from the NormalizerRegistry.byName
remove the Normalizer from the bySchemaNameSchemaObject map : <schema, s= et<SchemaObject>> -=3D Normalizer

ObjectClass

Here are the fields stored in a ObjectClass instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	NORMALIZER
oid	MR OID
schemaName	N/A
specification	not modifiable
mayAttributeTypes	all the referenced MAY attributeType
mayAttributeTypeOids	all the referenced MAY attributeType's oid
mustAttributeTypes	all the referenced MUST attributeType
mustAttributeTypeOids	all the referenced MUST attributeType's oid
objectClassType	STRUCTURAL
superiors	all the inherited SUPERIOR
superiorOids	all the inherited SUPERIOR's oid

Adding an Obj= ectClass

Register the ObjectClass into the ObjectClassRegistry :
update the ObjectClassRegistry.byOid : add <oid, ObjectClass>
for all the ObjectClass names, plus the oid,
update the ObjectClassRegistry.byName : add <name, ObjectClass> update the ObjectClassRegistry.byName : add <oid, ObjectClass>
associate the ObjectClassType with the schema : <schema, set<SchemaOb= ject>> +=3D ObjectClass
update the Registries.globalOidRegistry : add <oid, ObjectClass>

When all the schema modifications will be done, do the additional update= s :

update all the ObjectClass.may : AttributeTypeRegistry.lookup( mayOid )<= br/> update all the ObjectClassType.must : AttributeTypeRegistry.lookup( mustOid= )
update all the ObjectClass.superiors : ObjectClassRegistry.lookup( superior= Oid )
update the Registries.using map : <ObjectClass.oid, set<SchemaObject&= gt;> +=3D
all the may, all the must, all the superiors
update the Registries.usedBy map for each may, must and superior :
<may.oid, set<SchemaObject>> +=3D ObjectClass
<must.Oid, set<SchemaObject>> +=3D ObjectClassuteType
<superior.oid, set<SchemaObject>> +=3D ObjectClass

If the added ObjectClass inherits from one ore more ObjectClass, update = the oidToDescendant map :
for each superiorOid :
<superiorOid, Set<ObjectClass>> +=3D ObjectClass

There are special cases to deal with :

If the ObjectClass is ABSTRACT, then it can inherit from a STRUCTURA= L or AUXILIARY ObjectClass
If the ObjectClass is AUXILIARY, then it can't inherit from a STRUCT= URAL ObjectClass
If the ObjectClass is STRUCTURAL, then it can't inherit from a AUXIL= IARY ObjectClass

Modifying = an ObjectClass

We won't create a new object, but will update the existing one. The OID = can't be changed

We will also have to check that the modified AT is still valid

Deleting an= ObjectClass

We can't delete an Objectlass if it's refered by another ObjectClass. This is checked by verifying inthe usedBy table :

if usedBy.get( objectClass.oid ) is not empty, generate an error.

remove the oid from the ObjectClassRegistry.byOid
for each ObjectClass's name,
remove the ObjectClass.name from the ObjectClassRegistry.byName
+ remove the ObjectClass.oid from the ObjectClassRegistry.byName
remove the ObjectClass from the bySchemaNameSchemaObject map : <schema, = set<SchemaObject>> -=3D ObjectClass
remove the ObjectClass.oid from the globalOidRegistry : remove <oid, Obj= ectClass>

When all the schema modifications will be done, do the additional update= s :

update the Registries.using map : remove the relation <ObjectClass.oi= d, set<SchemaObject>>

Syntax

Here are the fields stored in a Syntax instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	ATTRIBUTE_TYPE
oid	AT OID
schemaName	N/A
isHumanReadable	FALSE
syntaxChecker	SC reference

Adding a Syntax
Register the Syntax into the SyntaxRegistry :
update the SyntaxRegistry.byOid : add <oid, Syntax>
update the SyntaxRegistry.byName : add <oid, Syntax>
associate the Syntax with the schema : <schema, set<SchemaObject>&= gt; +=3D Syntax
update the Registries.globalOidRegistry : add <oid, Syntax>

When all the schema modifications will be done, do the additional update= s :

update the Syntax.syntaxChecker : SyntaxCheckerRegistry.lookup( oid ) update the Registries.using map : <Syntax.oid, set<SchemaObject>&g= t; +=3D SyntaxChecker
update the Registries.usedBy map : <SyntaxChecker.oid, set<SchemaObje= ct>> +=3D Syntax

Modifying a Synt= ax

We won't create a new object, but will update the existing one. The OID = can't be changed

If we have changed the SyntaxChecker, when all the schema modifications = will be done, do the
additional updates :
update the Syntax.syntaxChecker : SyntaxCheckerRegistry.lookup( oid )
update the Registries.using map : <Syntax.oid, set<SchemaObject>&g= t; -=3D old SyntaxChecker
update the Registries.using map : <Syntax.oid, set<SchemaObject>&g= t; +=3D new SyntaxChecker
update the Registries.usedBy map : <old SyntaxChecker.oid, set<Schema= Object>> -=3D Syntax
update the Registries.usedBy map : <new SyntaxChecker.oid, set<Schema= Object>> +=3D Syntax

Deleting a Syntax=

We can't delete a Syntax which is used by either a MatchingRule or an At= tributeType. This is checked by verifying in
the usedBy table :

if usedBy.get( Syntax.oid ) is not empty, generate an error.

Otherwise, here are the operations we have to conduct :
remove the Syntax.oid from the SyntaxRegistry.byOid
for each Syntax' name,
remove the Syntax.name from the SyntaxRegistry.byName
+ remove the Syntax.oid from the SyntaxRegistry.byName
remove the Syntax from the bySchemaNameSchemaObject map : <schema, set&l= t;SchemaObject>> -=3D Syntax
remove the Registries.globalOidRegistry : remove <oid, Syntax>

When all the schema modifications will be done, do the additional update= s :

update the Registries.using map : remove the relation <Syntax.oid, se= t<SchemaObject>>
update the Registries.usedBy map : <SyntaxChecker.oid, set<SchemaObje= ct>> -=3D Syntax

Synta= xChecker (specific)

Here are the fields stored in a SyntaxChecker instance :

Name	default
description	N/A
extensions	N/A
isEnabled	TRUE
isObsolete	FALSE
isReadOnly	FALSE
names	No names
objectType	SYNTAX_CHECKER
oid	SYNTAX OID
schemaName	N/A
specification	not modifiable
bytecode	not modifiable
fqcn	not modifiable

Adding a Syn= taxChecker

Register the SyntaxChecker into the SyntaxCheckerRegistry :
update the SyntaxCheckerRegistry.byOid : add <oid, SyntaxChecker>
update the SyntaxCheckerRegistry.byName : add <oid, SyntaxChecker> associate the SyntaxChecker with the schema : <schema, set<SchemaObje= ct>> +=3D SyntaxChecker

Modifying= a SyntaxChecker

Nothing to do but update the SyntaxChecker in place (replacing all the f= ields of the original SyntaxChecker).

Note that all the fields are not modifiables.

Deleting a= SyntaxChecker

We can't delete a SyntaxChecker if it is used by a Syntax. This is check= ed by verifying in
the usedBy table :

if usedBy.get( SyntaxChecker.oid ) is not empty, generate an error.

This is a more complex operation, as we may have some Syntax pointing on= this object.
We have to :
remove the oid from the SyntaxCheckerRegistry.byOid
remove the oid from the SyntaxCheckerRegistry.byName
remove the SyntaxChecker from the bySchemaNameSchemaObject map : <schema= , set<SchemaObject>> -=3D SyntaxChecker

SyntaxCheckers= list

We can see that we may have many syntax checkers. The list are gi= ven in RFC 2252, RFC 4517 and RFC 4523:

RFC 2252/22566	RFC 4517/4523	Syntax Checker	OID	H/R
X	X	Attribute Type Description	1.3.6.1.4.1.1466.115.121.1.3	Y
X	(removed)	Binary	1.3.6.1.4.1.1466.115.121.1.5	N
X	X	Bit String	1.3.6.1.4.1.1466.115.121.1.6	Y
X	X	Boolean	1.3.6.1.4.1.1466.115.121.1.7	Y
X	(RFC 4523)	Certificate	1.3.6.1.4.1.1466.115.121.1.8	N
X	(RFC 4523)	Certificate List	1.3.6.1.4.1.1466.115.121.1.9	N
X	(RFC 4523)	Certificate Pair	1.3.6.1.4.1.1466.115.121.1.10	N
X	X	Country String	1.3.6.1.4.1.1466.115.121.1.11	Y
X	X	Delivery Method	1.3.6.1.4.1.1466.115.121.1.14	Y
X	X	Directory String	1.3.6.1.4.1.1466.115.121.1.15	Y
X	X	DIT Content Rule Description	1.3.6.1.4.1.1466.115.121.1.16	Y
X	X	DIT Structure Rule Description	1.3.6.1.4.1.1466.115.121.1.17	Y
X	X	DN	1.3.6.1.4.1.1466.115.121.1.12	Y
X	X	Enhanced Guide	1.3.6.1.4.1.1466.115.121.1.21	Y
X	X	Facsimile Telephone Number	1.3.6.1.4.1.1466.115.121.1.22	Y
X	X	Fax	1.3.6.1.4.1.1466.115.121.1.23	N
X	X	Generalized Time	1.3.6.1.4.1.1466.115.121.1.24	Y
X	X	Guide	1.3.6.1.4.1.1466.115.121.1.25	Y
X	X	IA5 String	1.3.6.1.4.1.1466.115.121.1.26	Y
X	X	Integer	1.3.6.1.4.1.1466.115.121.1.27	Y
X	X	JPEG	1.3.6.1.4.1.1466.115.121.1.28	N
X	X	LDAP Syntax Description	1.3.6.1.4.1.1466.115.121.1.54	Y
X	X	Matching Rule Description	1.3.6.1.4.1.1466.115.121.1.30	Y
X	X	Matching Rule Use Description	1.3.6.1.4.1.1466.115.121.1.31	Y
X	(removed)	MHS OR Address	1.3.6.1.4.1.1466.115.121.1.33	Y
X	X	Name and Optional UID	1.3.6.1.4.1.1466.115.121.1.34	Y
X	X	Name Form Description	1.3.6.1.4.1.1466.115.121.1.35	Y
X	X	Numeric String	1.3.6.1.4.1.1466.115.121.1.36	Y
X	X	Object Class Description	1.3.6.1.4.1.1466.115.121.1.37	Y
X	X	Octet String	1.3.6.1.4.1.1466.115.121.1.40	Y
X	X	OID	1.3.6.1.4.1.1466.115.121.1.38	Y
X	X	Other Mailbox	1.3.6.1.4.1.1466.115.121.1.39	Y
X	X	Postal Address	1.3.6.1.4.1.1466.115.121.1.41	Y
X	(removed)	Presentation Address	1.3.6.1.4.1.1466.115.121.1.43	Y
X	X	Printable String	1.3.6.1.4.1.1466.115.121.1.44	Y
-	X	Substring Assertion	1.3.6.1.4.1.1466.115.121.1.58	Y
X	(RFC 4523)	Supported Algorithm	1.3.6.1.4.1.1466.115.121.1.49	N
X	X	Telephone Number	1.3.6.1.4.1.1466.115.121.1.50	Y
X	X	Teletex Terminal Identifier	1.3.6.1.4.1.1466.115.121.1.51	Y
X	X	Telex Number	1.3.6.1.4.1.1466.115.121.1.52	Y
X	X	UTC Time	1.3.6.1.4.1.1466.115.121.1.53	Y

As we can see, each syntax should have a specific class associated with = a specific check method used to control that the attribute value is = correct. This value will be checked for every entry adsded or modified by a= user. Each DN submitted will also be checked against those classes.=

To be able to extend the server with new syntaxes, thoses checker classe= s will be dynamically loaded at startup. We can do that in different ways :=

defining those classes into ADS code, and load them statically durin= g the compilation of the server : this will not be dynamic, but anyway, we = will follow the specification and the server will be LDAP V3 compliant
compiling the syntaxChecker classes and injecting the .class = into the cn=3Dschema,ou=3Dsystem partition : This is possible by eit= her injecting a LDIF file where the .class is serialized, or using a descri= ption containing the SyntaxChecker

TO BE CONTIINUED

Change Notification Preferences

View Online | View Cha= nge

Apache DS SchemaManager

Page edited by Emmanuel L=C3=83=C2=A9charny

Introduction

SchemaManager

SchemaObje= ct Registries

SchemaObjects

AttributeType

Adding an A= ttributeType

Modifyin= g an AttributeType

Deleting = an AttributeType

Comparator

Adding a compar= ator

Modifying a = comparator

Deleting a co= mparator

DITContentRule Not Yet Implemented

DITStructureRule=

MatchingRule

Adding a Matc= hingRule

Modifying = a MatchingRule

Deleting a = MatchingRule

MatchingRuleUse Not Yet Implemented

NameForm

Normaliz= er (specific)

Adding a Normal= izer

Modifying a = Normalizer

Deleting a No= rmalizer

ObjectClass

Adding an Obj= ectClass

Modifying = an ObjectClass

Deleting an= ObjectClass

Syntax

Modifying a Synt= ax

Deleting a Syntax=

Synta= xChecker (specific)

Adding a Syn= taxChecker

Modifying= a SyntaxChecker

Deleting a= SyntaxChecker

SyntaxCheckers= list

DITContentRule
Not Yet Implemented

MatchingRuleUse
Not Yet Implemented