fetchSchema method to retrieve
* the schema used by a server. (The server must support LDAP v3
* and the capability to retrieve the schema over the LDAP protocol.)
* * * After you retrieve the schema, you can use this object to get * the object class, attribute type, and matching rule descriptions * in the schema. You can also add your own object classes, * attribute types, and matching rules to the schema. *
*
* To remove any object classes, attribute types, and matching rules
* that you added, call the remove methods of the
* LDAPObjectClassSchema, LDAPAttributeSchema,
* and LDAPMatchingRuleSchema classes. (This method is
* inherited from the LDAPSchemaElement class.)
*
* * The following class is an example of an LDAP client that can * fetch the schema, get and print object class descriptions and * attribute type descriptions, and add object classes and attribute * types to the schema over the LDAP protocol. *
* *
* import netscape.ldap.*;
* public class TestSchema {
* public static void main( String[] args ) {
* String HOSTNAME = "ldap.netscape.com";
* int PORT_NUMBER = DEFAULT_PORT;
* String ROOT_DN = "cn=Directory Manager";
* String ROOT_PASSWORD = "23skidoo";
*
* LDAPConnection ld = new LDAPConnection();
*
* // Construct a new LDAPSchema object to get the schema.
* LDAPSchema dirSchema = new LDAPSchema();
*
* try {
* // Connect to the server.
* ld.connect( HOSTNAME, PORT_NUMBER );
*
* // Get the schema from the directory.
* dirSchema.fetchSchema( ld );
*
* // Get and print the inetOrgPerson object class description.
* LDAPObjectClassSchema objClass = dirSchema.getObjectClass(
* "inetOrgPerson" );
* if ( objClass != null ) {
* System.out.println("inetOrgPerson := "+objClass.toString());
* }
*
* // Get and print the definition of the userPassword attribute.
* LDAPAttributeSchema attrType = dirSchema.getAttribute(
* "userpassword" );
* if ( attrType != null ) {
* System.out.println("userPassword := "+attrType.toString());
* }
*
* // Add a new object class.
* String[] requiredAttrs = {"cn", "mail"};
* String[] optionalAttrs = {"sn", "phoneNumber"};
* LDAPObjectClassSchema newObjClass = new LDAPObjectClassSchema(
* "newInetOrgPerson", "1.2.3.4.5.6.7", "top", "Experiment",
* requiredAttrs, optionalAttrs );
*
* // Authenticate as root DN to get permissions to edit the schema.
* ld.authenticate( ROOT_DN, ROOT_PASSWORD );
*
* // Add the new object class to the schema.
* newObjClass.add( ld );
*
* // Create a new attribute type "hairColor".
* LDAPAttributeSchema newAttrType = new LDAPAttributeSchema(
* "hairColor", "1.2.3.4.5.4.3.2.1", "Blonde, red, etc",
* LDAPAttributeSchema.cis, false );
*
* // Add the new attribute type to the schema.
* newAttrType.add( ld );
*
* // Fetch the schema again to verify that changes were made.
* dirSchema.fetchSchema( ld );
*
* // Get and print the new attribute type.
* newAttrType = dirSchema.getAttribute( "hairColor" );
* if ( newAttrType != null )
* System.out.println("hairColor := "+newAttrType.toString());
*
* // Get and print the new object class.
* newObjClass = dirSchema.getObjectClass( "newInetOrgPerson" );
* if ( newObjClass != null )
* System.out.println("newInetOrgPerson := "+newObjClass.toString());
*
* ld.disconnect();
*
* } catch ( Exception e ) {
* System.err.println( e.toString() );
* System.exit( 1 );
* }
*
* System.exit( 0 );
* }
* }
*
*
* If you are using the Netscape Directory Server 3.0, you can also
* verify that the class and attribute type have been added through
* the directory server manager (go to Schema | Edit or View Attributes
* or Schema | Edit or View Object Classes).
*
*
* To remove the classes and attribute types added by the example,
* see the examples under the LDAPSchemaElement class.
*
*
* @see netscape.ldap.LDAPAttributeSchema
* @see netscape.ldap.LDAPObjectClassSchema
* @see netscape.ldap.LDAPMatchingRuleSchema
* @see netscape.ldap.LDAPSchemaElement
* @version 1.0
* @author Rob Weltman
**/
public class LDAPSchema {
/**
* Constructs a new LDAPSchema object.
* Once you construct the object, you can get
* the schema by calling fetchSchema.
*
*
* You can also print out the schema by using the
* main method. For example, you can enter
* the following command:
*
* java netscape.ldap.LDAPSchema myhost.mydomain.com 389
*
*
* Note that you need to call fetchSchema
* to get the schema from the server. Constructing the
* object does not fetch the schema.
*
*
* @see netscape.ldap.LDAPSchema#fetchSchema
* @see netscape.ldap.LDAPSchema#main
*/
public LDAPSchema() {
}
/**
* Adds an object class schema definition to the current schema.
* You can also add object class schema definitions by calling the
* add method of your newly constructed
* LDAPObjectClassSchema object.
*
*
* To remove an object class schema definition that you have added,
* call the getObjectClass method to get the
* LDAPObjectClassSchema object representing your
* object class and call the remove method.
*
*
* NOTE: For information on the add and
* remove methods of LDAPObjectClassSchema,
* see the documentation for LDAPSchemaElement.
* (These methods are inherited from LDAPSchemaElement.)
*
*
* @param objectSchema LDAPObjectClassSchema object
* representing the object class schema definition that you want
* to add.
* @see netscape.ldap.LDAPObjectClassSchema
* @see netscape.ldap.LDAPSchemaElement#add
* @see netscape.ldap.LDAPSchemaElement#remove
*/
public void addObjectClass( LDAPObjectClassSchema objectSchema ) {
objectClasses.put( objectSchema.getName().toLowerCase(),
objectSchema );
}
/**
* Add an attribute type schema definition to the current schema.
* You can also add attribute type schema definitions by calling the
* add method of your newly constructed
* LDAPAttributeSchema object.
*
*
* To remove an attribute type schema definition that you have added,
* call the getAttribute method to get the
* LDAPAttributeSchema object representing your
* attribute type and call the remove method.
*
*
* NOTE: For information on the add and
* remove methods of LDAPAttributeSchema,
* see the documentation for LDAPSchemaElement.
* (These methods are inherited from LDAPSchemaElement.)
*
*
* @param attrSchema LDAPAttributeSchema object
* representing the attribute type schema definition that you
* want to add.
* @see netscape.ldap.LDAPAttributeSchema
* @see netscape.ldap.LDAPSchemaElement#add
* @see netscape.ldap.LDAPSchemaElement#remove
*/
public void addAttribute( LDAPAttributeSchema attrSchema ) {
attributes.put( attrSchema.getName().toLowerCase(), attrSchema );
}
/**
* Add a matching rule schema definition to the current schema.
* You can also add matching rule schema definitions by calling the
* add method of your newly constructed
* LDAPMatchingRuleSchema object.
*
*
* To remove an attribute type schema definition that you have added,
* call the getMatchingRule method to get the
* LDAPMatchingRuleSchema object representing your
* matching rule and call the remove method.
*
*
* NOTE: For information on the add and
* remove methods of LDAPMatchingRuleSchema,
* see the documentation for LDAPSchemaElement.
* (These methods are inherited from LDAPSchemaElement.)
*
*
* @param matchSchema LDAPMatchingRuleSchema object
* representing the matching rule schema definition that you want
* to add.
* @see netscape.ldap.LDAPMatchingRuleSchema
* @see netscape.ldap.LDAPSchemaElement#add
* @see netscape.ldap.LDAPSchemaElement#remove
*/
public void addMatchingRule( LDAPMatchingRuleSchema matchSchema ) {
matchingRules.put( matchSchema.getName().toLowerCase(), matchSchema );
}
/**
* Gets an enumeration ofthe object class definitions in this schema.
* @return An enumeration ofobject class definitions.
*/
public Enumeration getObjectClasses() {
return objectClasses.elements();
}
/**
* Gets an enumeration ofthe attribute type definitions in this schema.
* @return An enumeration ofattribute type definitions.
*/
public Enumeration getAttributes() {
return attributes.elements();
}
/**
* Gets an enumeration ofthe matching rule definitions in this schema.
* @return An enumeration ofmatching rule definitions.
*/
public Enumeration getMatchingRules() {
return matchingRules.elements();
}
/**
* Gets the definition of the object class with the specified name.
* @param name Name of the object class that you want to find.
* @return An LDAPObjectClassSchema object representing
* the object class definition, or null if not found.
*/
public LDAPObjectClassSchema getObjectClass( String name ) {
return (LDAPObjectClassSchema)objectClasses.get( name.toLowerCase() );
}
/**
* Gets the definition of the attribute type with the specified name.
* @param name Name of the attribute type that you want to find.
* @return An LDAPAttributeSchema object representing
* the attribute type definition, or null if not found.
*/
public LDAPAttributeSchema getAttribute( String name ) {
return (LDAPAttributeSchema)attributes.get( name.toLowerCase() );
}
/**
* Gets the definition of a matching rule with the specified name.
* @param name Name of the matching rule that you want to find.
* @return An LDAPMatchingRuleSchema object representing
* the matching rule definition, or null if not found.
*/
public LDAPMatchingRuleSchema getMatchingRule( String name ) {
return (LDAPMatchingRuleSchema)matchingRules.get( name.toLowerCase() );
}
/**
* Get an enumeration of the names of the object classes in this schema.
* @return An enumeration of object class names (all lower-case).
*/
public Enumeration getObjectClassNames() {
return objectClasses.keys();
}
/**
* Get an enumeration of the names of the attribute types in this schema.
* @return An enumeration of attribute names (all lower-case).
*/
public Enumeration getAttributeNames() {
return attributes.keys();
}
/**
* Get an enumeration of the names of the matching rules in this schema.
* @return An enumeration of matching rule names (all lower-case).
*/
public Enumeration getMatchingRuleNames() {
return matchingRules.keys();
}
/**
* Retrieve the entire schema from a Directory Server.
* @param ld An active connection to a Directory Server.
* @exception LDAPException on failure.
*/
public void fetchSchema( LDAPConnection ld ) throws LDAPException {
if ( (ld == null) || !ld.isConnected() ) {
throw new LDAPException( "No connection", LDAPException.OTHER );
}
LDAPEntry entry = ld.read( "" );
if ( entry == null )
throw new LDAPException( "", LDAPException.NO_SUCH_OBJECT );
LDAPAttribute attr = entry.getAttribute( "subschemasubentry" );
entryName = "cn=schema";
Enumeration en;
if ( attr != null ) {
en = attr.getStringValues();
if ( en.hasMoreElements() )
entryName = (String)en.nextElement();
}
/* Get the entire schema definition entry */
entry = ld.read( entryName );
/* Get all object class definitions */
attr = entry.getAttribute( "objectclasses" );
if ( attr != null ) {
en = attr.getStringValues();
while( en.hasMoreElements() ) {
LDAPObjectClassSchema sch =
new LDAPObjectClassSchema( (String)en.nextElement() );
addObjectClass( sch );
}
}
/* Get all attribute definitions */
attr = entry.getAttribute( "attributetypes" );
if ( attr != null ) {
en = attr.getStringValues();
while( en.hasMoreElements() ) {
LDAPAttributeSchema sch =
new LDAPAttributeSchema( (String)en.nextElement() );
addAttribute( sch );
}
}
/* Matching rules are tricky, because we have to match up a
rule with its use. First get all the uses. */
Hashtable h = new Hashtable();
attr = entry.getAttribute( "matchingruleuse" );
if ( attr != null ) {
en = attr.getStringValues();
while( en.hasMoreElements() ) {
String use = (String)en.nextElement();
LDAPMatchingRuleSchema sch =
new LDAPMatchingRuleSchema( null, use );
h.put( sch.getOID(), use );
}
}
/* Now get the rules, and assign uses to them */
attr = entry.getAttribute( "matchingrules" );
if ( attr != null ) {
en = attr.getStringValues();
while( en.hasMoreElements() ) {
String raw = (String)en.nextElement();
LDAPMatchingRuleSchema sch =
new LDAPMatchingRuleSchema( raw, null );
String use = (String)h.get( sch.getOID() );
if ( use != null )
sch = new LDAPMatchingRuleSchema( raw, use );
addMatchingRule( sch );
}
}
}
/**
* Displays the schema (including the descriptions of its object
* classes, attribute types, and matching rules) in an easily
* readable format (not the same as the format expected by
* an LDAP server).
* @return A string containing the schema in printable format.
*/
public String toString() {
String s = "Object classes: ";
Enumeration en = getObjectClasses();
while( en.hasMoreElements() ) {
s += (String)en.nextElement();
s += ' ';
}
s += "Attributes: ";
en = getAttributes();
while( en.hasMoreElements() ) {
s += (String)en.nextElement();
s += ' ';
}
s += "Matching rules: ";
en = getMatchingRules();
while( en.hasMoreElements() ) {
s += (String)en.nextElement();
s += ' ';
}
return s;
}
/**
* Helper for "main" to print out schema elements.
* @param en Enumeration of schema elements.
*/
private static void printEnum( Enumeration en ) {
while( en.hasMoreElements() ) {
LDAPSchemaElement s = (LDAPSchemaElement)en.nextElement();
System.out.println( " " + s );
}
}
/**
* Fetch the schema from the LDAP server at the specified
* host and port, and print out the schema (including descriptions
* of its object classes, attribute types, and matching rules).
* The schema is printed in an easily readable format (not the
* same as the format expected by an LDAP server). For example,
* you can enter the following command to print the schema:
*
* java netscape.ldap.LDAPSchema myhost.mydomain.com 389
*
*
* @param args The host name and the port number of the LDAP server
* (for example, netscape.ldap.LDAPSchema directory.netscape.com
* 389).
*/
public static void main( String[] args ) {
if ( args.length < 2 ) {
System.err.println( "Usage: netscape.ldap.LDAPSchema HOST PORT" );
System.exit(1 );
}
int port = Integer.parseInt( args[1] );
LDAPConnection ld = new LDAPConnection();
try {
ld.connect( args[0], port );
LDAPSchema schema = new LDAPSchema();
schema.fetchSchema( ld );
ld.disconnect();
System.out.println( "Object classes: " );
printEnum( schema.getObjectClasses() );
System.out.println( "\nAttributes: " );
printEnum( schema.getAttributes() );
System.out.println( "\nMatching rules: " );
printEnum( schema.getMatchingRules() );
System.exit( 0 );
} catch ( LDAPException e ) {
System.err.println( e );
}
}
private Hashtable objectClasses = new Hashtable();
private Hashtable attributes = new Hashtable();
private Hashtable matchingRules = new Hashtable();
String entryName = null;
}