Spring/spring-ldap
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Made lots of fixes based on warnings from Maven 3.0.

Browse Source 
Removed duplicates of ldif-core that were left in core-tiger.
This commit is contained in:
Ulrik Sandberg
2010-11-17 22:10:52 +00:00
parent bede63b2c7
commit 1e74c3ecda
27 changed files with 20 additions and 2038 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core-tiger/pom.xml
View File

@@ -8,6 +8,7 @@
<groupId>org.springframework.ldap</groupId>
<artifactId>spring-ldap-parent</artifactId>
<version>1.3.1.CI-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-ldap-core-tiger</artifactId>

225
core-tiger/src/main/java/org/springframework/ldap/core/LdapAttribute.java
View File

@@ -1,225 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.core;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import javax.naming.directory.BasicAttribute;
/**
* Extends {@link javax.naming.directory.BasicAttribute} to add support for
* options as defined in RFC2849.
* <p>
* While uncommon, options can be used to specify additional descriptors for
* the attribute. Options are backed by a {@link java.util.HashSet} of
* {@link java.lang.String}.
*
* @author Keith Barlow
*
*/
public class LdapAttribute extends BasicAttribute {
private static final long serialVersionUID = -5263905906016179429L;
/**
* Holds the attributes options.
*/
protected Set<String> options = new HashSet<String>();
/**
* Creates an unordered attribute with the specified ID.
*
* @param id {@link java.lang.String} ID of the attribute.
*/
public LdapAttribute(String id) {
super(id);
}
/**
* Creates an unordered attribute with the specified ID and value.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param value Attribute value.
*/
public LdapAttribute(String id, Object value) {
super(id, value);
}
/**
* Creates an unordered attribute with the specified ID, value, and options.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param value Attribute value.
* @param options {@link java.util.Collection} of {@link java.lang.String} attribute options.
*/
public LdapAttribute(String id, Object value, Collection<String> options) {
super(id, value);
this.options.addAll(options);
}
/**
* Creates an attribute with the specified ID whose values may be ordered.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param ordered boolean indicating whether or not the attributes values are ordered.
*/
public LdapAttribute(String id, boolean ordered) {
super(id, ordered);
}
/**
* Creates an attribute with the specified ID and options whose values may be ordered.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param options {@link java.util.Collection} of {@link java.lang.String} attribute options.
* @param ordered boolean indicating whether or not the attributes values are ordered.
*/
public LdapAttribute(String id, Collection<String> options, boolean ordered) {
super(id, ordered);
this.options.addAll(options);
}
/**
* Creates an attribute with the specified ID and value whose values may be ordered.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param value Attribute value.
* @param ordered boolean indicating whether or not the attributes values are ordered.
*/
public LdapAttribute(String id, Object value, boolean ordered) {
super(id, value, ordered);
}
/**
* Creates an attribute with the specified ID, value, and options whose values may be ordered.
*
* @param id {@link java.lang.String} ID of the attribute.
* @param value Attribute value.
* @param options {@link java.util.Collection} of {@link java.lang.String} attribute options.
* @param ordered boolean indicating whether or not the attributes values are ordered.
*/
public LdapAttribute(String id, Object value, Collection<String> options, boolean ordered) {
super(id, value, ordered);
this.options.addAll(options);
}
/**
* Get options.
*
* @return returns a {@link java.util.Set} of {@link java.lang.String}
*/
public Set<String> getOptions() {
return this.options;
}
/**
* Set options.
*
* @param options {@link java.util.Set} of {@link java.lang.String}
*/
public void setOptions(Set<String> options) {
this.options = options;
}
/**
* Add an option.
*
* @param option {@link java.lang.String} option.
* @return boolean indication successful addition of option.
*/
public boolean addOption(String option) {
return this.options.add(option);
}
/**
* Add all values in the collection to the options.
*
* @param options {@link java.util.Collection} of {@link java.lang.String} values.
* @return boolean indication successful addition of options.
*/
public boolean addAllOptions(Collection<String> options) {
return this.options.addAll(options);
}
/**
* Clears all stored options.
*/
public void clearOptions() {
this.options.clear();
}
/**
* Checks for existence of a particular option on the set.
*
* @param option {@link java.lang.String} option.
* @return boolean indicating result.
*/
public boolean contains(String option) {
return this.options.contains(option);
}
/**
* Checks for existence of a series of options on the set.
*
* @param options {@link java.util.Collection} of {@link java.lang.String} options.
* @return boolean indicating result.
*/
public boolean containsAll(Collection<String> options) {
return this.options.containsAll(options);
}
/**
* Tests for the presence of options.
*
* @return boolean indicating result.
*/
public boolean hasOptions() {
return !options.isEmpty();
}
/**
* Removes an option from the the set.
*
* @param option {@link java.lang.String} option.
* @return boolean indicating successful removal of option.
*/
public boolean removeOption(String option) {
return this.options.remove(options);
}
/**
* Removes all options listed in the supplied set.
*
* @param options {@link java.util.Collection} of {@link java.lang.String} options.
* @return boolean indicating successful removal of options.
*/
public boolean removeAllOptions(Collection<String> options) {
return this.options.removeAll(options);
}
/**
* Removes any options not on the set of supplied options.
*
* @param options {@link java.util.Collection} of {@link java.lang.String} options.
* @return boolean indicating successful retention of options.
*/
public boolean retainAllOptions(Collection<String> options) {
return this.options.retainAll(options);
}
}

211
core-tiger/src/main/java/org/springframework/ldap/core/LdapAttributes.java
View File

@@ -1,211 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.core;
import java.net.URI;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.BasicAttributes;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.DistinguishedName;
import sun.misc.BASE64Encoder;
/**
* Extends {@link javax.naming.directory.BasicAttributes} to add specialized support
* for DNs.
* <p>
* While DNs appear to be and can be treated as attributes, they have a special
* meaning in that they define the address to which the object is bound. DNs must
* conform to special formating rules and are typically required to be handled
* separately from other attributes.
* <p>
* This class makes this distinction between the DN and other
* attributes prominent and apparent.
*
* @author Keith Barlow
*
*/
public class LdapAttributes extends BasicAttributes {
private static final long serialVersionUID = 97903297123869138L;
private static Log log = LogFactory.getLog(LdapAttributes.class);
private static final String SAFE_CHAR = "[\\p{ASCII}&&[^\\x00\\x0A\\x0D]]"; //Any ASCII except NUL, LF, and CR
private static final String SAFE_INIT_CHAR = "[\\p{ASCII}&&[^ \\x00\\x0A\\x0D\\x3A\\x3C]]"; //Any ASCII except NUL, LF, CR, SPACE, colon, and less-than
/**
* Distinguished name to which the object is bound.
*/
protected DistinguishedName dn = new DistinguishedName();
/**
* Default constructor.
*/
public LdapAttributes() {
}
/**
* Creates an LdapAttributes object with the specified DN.
*
* @param dn The {@link org.springframework.ldap.core.DistinguishedName} to which this object is bound.
*/
public LdapAttributes(DistinguishedName dn) {
super();
this.dn = dn;
}
/**
* Constructor for specifying whether or not the object is case sensitive.
*
* @param ignoreCase boolean indicator.
*/
public LdapAttributes(boolean ignoreCase) {
super(ignoreCase);
}
/**
* Creates an LdapAttributes object with the specified DN and case sensitivity setting.
*
* @param dn The {@link org.springframework.ldap.core.DistinguishedName} to which this object is bound.
* @param ignoreCase boolean indicator.
*/
public LdapAttributes(DistinguishedName dn, boolean ignoreCase) {
super(ignoreCase);
this.dn = dn;
}
/**
* Creates an LdapAttributes object with the specified attribute.
*
* @param attrID {@link java.lang.String} ID of the attribute.
* @param val Value of the attribute.
*/
public LdapAttributes(String attrID, Object val) {
put(new LdapAttribute(attrID, val));
}
/**
* Creates an LdapAttributes object with the specifying attribute and value and case sensitivity setting.
*
* @param dn The {@link org.springframework.ldap.core.DistinguishedName} to which this object is bound.
* @param attrID {@link java.lang.String} ID of the attribute.
* @param val Value of the attribute.
*/
public LdapAttributes(DistinguishedName dn, String attrID, Object val) {
this.dn = dn;
put(new LdapAttribute(attrID, val));
}
/**
* Creates an LdapAttributes object with the specifying attribute and value and case sensitivity setting.
*
* @param attrID {@link java.lang.String} ID of the attribute.
* @param val Value of the attribute.
* @param ignoreCase boolean indicator.
*/
public LdapAttributes(String attrID, Object val, boolean ignoreCase) {
put(new LdapAttribute(attrID, val, ignoreCase));
}
/**
* Creates an LdapAttributes object for the supplied DN with the attribute specified.
*
* @param dn The {@link org.springframework.ldap.core.DistinguishedName} to which this object is bound.
* @param attrID {@link java.lang.String} ID of the attribute.
* @param val Value of the attribute.
* @param ignoreCase boolean indicator.
*/
public LdapAttributes(DistinguishedName dn, String attrID, Object val, boolean ignoreCase) {
this.dn = dn;
put(new LdapAttribute(attrID, val, ignoreCase));
}
/**
* Returns the distinguished name to which the object is bound.
*
* @return {@link org.springframework.ldap.core.DistinguishedName} specifying the name to which the object is bound.
*/
public DistinguishedName getDN() {
return dn;
}
/**
* Sets the distinguished name of the object.
*
* @param dn {@link org.springframework.ldap.core.DistinguishedName} specifying the name to which the object is bound.
*/
public void setDN(DistinguishedName dn) {
this.dn = dn;
}
/**
* Returns a string representation of the object in LDIF format.
*
* @return {@link java.lang.String} formated to RFC2849 LDIF specifications.
*/
public String toString() {
StringBuilder sb = new StringBuilder();
try {
DistinguishedName dn = getDN();
if (!dn.toString().matches(SAFE_INIT_CHAR + SAFE_CHAR + "*")) {
sb.append("dn:: " + new BASE64Encoder().encode(dn.toString().getBytes()) + "\n");
} else {
sb.append("dn: " + getDN() + "\n");
}
NamingEnumeration<Attribute> attributes = getAll();
while (attributes.hasMore()) {
Attribute attribute = attributes.next();
NamingEnumeration<?> values = attribute.getAll();
while (values.hasMore()) {
Object value = values.next();
if (value instanceof String)
sb.append(attribute.getID() + ": " + (String) value + "\n");
else if (value instanceof byte[])
sb.append(attribute.getID() + ":: " + new BASE64Encoder().encode((byte[]) value) + "\n");
else if (value instanceof URI)
sb.append(attribute.getID() + ":< " + (URI) value + "\n");
else {
sb.append(attribute.getID() + ": " + value + "\n");
}
}
}
} catch (NamingException e) {
log.error("Error formating attributes for output.", e);
sb = new StringBuilder();
}
return sb.toString();
}
}

52
core-tiger/src/main/java/org/springframework/ldap/ldif/InvalidAttributeFormatException.java
View File

@@ -1,52 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif;
import org.springframework.ldap.NamingException;
/**
* Thrown whenever a parsed attribute does not conform to LDAP specifications.
*
* @author Keith Barlow
*
*/
public class InvalidAttributeFormatException extends NamingException {
private static final long serialVersionUID = -4529380160785322985L;
/**
* @param msg
*/
public InvalidAttributeFormatException(String msg) {
super(msg);
}
/**
* @param cause
*/
public InvalidAttributeFormatException(Throwable cause) {
super(cause);
}
/**
* @param msg
* @param cause
*/
public InvalidAttributeFormatException(String msg, Throwable cause) {
super(msg, cause);
}
}

52
core-tiger/src/main/java/org/springframework/ldap/ldif/InvalidRecordFormatException.java
View File

@@ -1,52 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif;
import org.springframework.ldap.NamingException;
/**
* Thrown whenever a parsed record does not conform to LDAP specifications.
*
* @author Keith Barlow
*
*/
public class InvalidRecordFormatException extends NamingException {
private static final long serialVersionUID = -5047874723621065139L;
/**
* @param msg
*/
public InvalidRecordFormatException(String msg) {
super(msg);
}
/**
* @param cause
*/
public InvalidRecordFormatException(Throwable cause) {
super(cause);
}
/**
* @param msg
* @param cause
*/
public InvalidRecordFormatException(String msg, Throwable cause) {
super(msg, cause);
}
}

10
core-tiger/src/main/java/org/springframework/ldap/ldif/package.html
View File

@@ -1,10 +0,0 @@
<html>
<body>
The base package for Spring LDAPs LDIF parser implementation.
<p>
Classes declared in this package include the new base types for
LDAP objects as well as exception types for the LDIF parser.
</body>
</html>

363
core-tiger/src/main/java/org/springframework/ldap/ldif/parser/LdifParser.java
View File

@@ -1,363 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.parser;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.NoSuchElementException;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapAttributes;
import org.springframework.ldap.ldif.InvalidRecordFormatException;
import org.springframework.ldap.ldif.support.AttributeValidationPolicy;
import org.springframework.ldap.ldif.support.DefaultAttributeValidationPolicy;
import org.springframework.ldap.ldif.support.LineIdentifier;
import org.springframework.ldap.ldif.support.SeparatorPolicy;
import org.springframework.ldap.schema.DefaultSchemaSpecification;
import org.springframework.ldap.schema.Specification;
import org.springframework.util.Assert;
/**
* The {@link LdifParser LdifParser} is the main class of the {@link org.springframework.ldap.ldif} package.
* This class reads lines from a resource and assembles them into an {@link LdapAttributes LdapAttributes} object.
* The {@link LdifParser LdifParser} does ignores <i>changetype</i> LDIF entries as their usefulness in the
* context of an application has yet to be determined.
* <p>
* <b>Design</b><br/>
* {@link LdifParser LdifParser} provides the main interface for operation but requires three supporting classes to
* enable operation:
* <ul>
* <li>{@link SeparatorPolicy SeparatorPolicy} - establishes the mechanism by which lines are assembled into attributes.</li>
* <li>{@link AttributeValidationPolicy AttributeValidationPolicy} - ensures that attributes are correctly structured prior to parsing.</li>
* <li>{@link Specification Specification} - provides a mechanism by which object structure can be validated after assembly.</li>
* </ul>
* Together, these 4 classes read from the resource line by line and translate the data into objects for use.
* <p>
* <b>Usage</b><br/>
* {@link #getRecord() getRecord()} reads the next available record from the resource. Lines are read and
* passed to the {@link SeparatorPolicy SeparatorPolicy} for interpretation. The parser continues to read
* lines and appends them to the buffer until it encounters the start of a new attribute or an end of record
* delimiter. When the new attribute or end of record is encountered, the buffer is passed to the
* {@link AttributeValidationPolicy AttributeValidationPolicy} which ensures the buffer conforms to a valid
* attribute definition as defined in RFC2849 and returns an {@link org.springframework.ldap.core.LdapAttribute LdapAttribute} object
* which is then added to the record, an {@link LdapAttributes LdapAttributes} object. Upon encountering the
* end of record, the record is validated by the {@link Specification Specification} policy and,
* if valid, returned to the requester.
* <p>
* <i>NOTE: By default, objects are not validated. If validation is required,
* an appropriate specification object must be set.</i>
* <p>
* The parser requires the resource to be {@link #open() open()} prior to an invocation of {@link #getRecord() getRecord()}.
* {@link #hasMoreRecords() hasMoreRecords()} can be used to loop over the resource until all records have been
* retrieved. Likewise, the {@link #reset() reset()} method will reset the resource.
* <p>
* Objects implementing the {@link javax.naming.directory.Attributes Attributes} interface are required to support a case sensitivity setting
* which controls whether or not the attribute IDs of the object are case sensitive. The {@link #caseInsensitive caseInsensitive}
* setting of the {@link LdifParser LdifParser} is passed to the constructor of any {@link javax.naming.directory.Attributes Attributes} created. The
* default value for this setting is true so that case insensitive objects are created.
*
* @author Keith Barlow
*
*/
public class LdifParser implements Parser, InitializingBean {
private static final Log log = LogFactory.getLog(LdifParser.class);
/**
* The resource to parse.
*/
private Resource resource;
/**
* A BufferedReader to read the file.
*/
private BufferedReader reader;
/**
* The SeparatorPolicy to use for interpreting attributes from the lines of the resource.
*/
private SeparatorPolicy separatorPolicy = new SeparatorPolicy();
/**
* The AttributeValidationPolicy to use to interpret attributes.
*/
private AttributeValidationPolicy attributePolicy = new DefaultAttributeValidationPolicy();
/**
* The RecordSpecification for validating records produced.
*/
private Specification<LdapAttributes> specification = new DefaultSchemaSpecification();
/**
* This setting is used to control the case sensitivity of LdapAttribute objects returned by the parser.
*/
private boolean caseInsensitive = true;
/**
* Default constructor.
*/
public LdifParser() {
}
/**
* Creates a LdifParser with the indicated case sensitivity setting.
*
* @param caseInsensitive Case sensitivity setting for LdapAttributes objects returned by the parser.
*/
public LdifParser(boolean caseInsensitive) {
this.caseInsensitive = caseInsensitive;
}
/**
* Creates an LdifParser for the specified resource with the provided case sensitivity setting.
*
* @param resource The resource to parse.
* @param caseInsensitive Case sensitivity setting for LdapAttributes objects returned by the parser.
*/
public LdifParser(Resource resource, boolean caseInsensitive) {
this.resource = resource;
this.caseInsensitive = caseInsensitive;
}
/**
* Convenience constructor for resource specification.
*
* @param resource The resource to parse.
*/
public LdifParser(Resource resource) {
this.resource = resource;
}
/**
* Convenience constructor: accepts a File object.
*
* @param file The file to parse.
*/
public LdifParser(File file) {
this.resource = new FileSystemResource(file);
}
/**
* Set the separator policy.
*
* The default separator policy should suffice for most needs.
*
* @param separatorPolicy Separator policy.
*/
public void setSeparatorPolicy(SeparatorPolicy separatorPolicy) {
this.separatorPolicy = separatorPolicy;
}
/**
* Policy object enforcing the rules for acceptable attributes.
*
* @param avPolicy Attribute validation policy.
*/
public void setAttributeValidationPolicy(AttributeValidationPolicy avPolicy) {
this.attributePolicy = avPolicy;
}
/**
* Policy object for enforcing rules to acceptable LDAP objects.
*
* This policy may be used to enforce schema restrictions.
* @param specification
*/
public void setRecordSpecification(Specification<LdapAttributes> specification) {
this.specification = specification;
}
public void setResource(Resource resource) {
this.resource = resource;
}
public void setCaseInsensitive(boolean caseInsensitive) {
this.caseInsensitive = caseInsensitive;
}
public void open() throws IOException {
Assert.notNull(resource, "Resource must be set.");
reader = new BufferedReader(new InputStreamReader(resource.getInputStream()));
}
public boolean isReady() throws IOException {
return reader.ready();
}
public void close() throws IOException {
if (resource.isOpen())
reader.close();
}
public void reset() throws IOException {
Assert.notNull(reader, "A reader has not been obtained.");
reader.reset();
}
public boolean hasMoreRecords() throws IOException {
return reader.ready();
}
public LdapAttributes getRecord() throws IOException {
Assert.notNull(reader, "A reader must be obtained: parser not open.");
if (!reader.ready()) {
log.debug("Reader not ready!");
return null;
}
LdapAttributes record = new LdapAttributes(caseInsensitive);
StringBuilder builder = new StringBuilder();
String line = reader.readLine();
while(true) {
LineIdentifier identifier = separatorPolicy.assess(line);
switch(identifier) {
case NewRecord:
log.trace("Starting new record.");
//Start new record.
builder = new StringBuilder(line);
break;
case Control:
log.trace("'control' encountered.");
//Log WARN and discard record.
log.warn("LDIF change records have no implementation: record will be ignored.");
builder = null;
record = null;
break;
case ChangeType:
log.trace("'changetype' encountered.");
//Log WARN and discard record.
log.warn("LDIF change records have no implementation: record will be ignored.");
builder = null;
record = null;
break;
case Attribute:
//flush buffer.
addAttributeToRecord(builder.toString(), record);
log.trace("Starting new attribute.");
//Start new attribute.
builder = new StringBuilder(line);
break;
case Continuation:
log.trace("...appending line to buffer.");
//Append line to buffer.
builder.append(line.replaceFirst(" ", ""));
break;
case EndOfRecord:
log.trace("...done parsing record. (EndOfRecord)");
//Validate record and return.
if (record == null) return null;
else {
try {
//flush buffer.
addAttributeToRecord(builder.toString(), record);
if (specification.isSatisfiedBy(record)) {
log.debug("record parsed:\n" + record);
return record;
} else {
throw new InvalidRecordFormatException("Record [dn: " + record.getDN() + "] does not conform to specification.");
}
} catch(NamingException e) {
log.error(e);
return null;
}
}
default:
//Take no action -- applies to VersionIdentifier, Comments, and voided records.
}
line = reader.readLine();
}
}
private void addAttributeToRecord(String buffer, LdapAttributes record) {
try {
if (StringUtils.isNotEmpty(buffer) && record != null) {
//Validate previous attribute and add to record.
Attribute attribute = attributePolicy.parse(buffer);
if (attribute.getID().equalsIgnoreCase("dn")) {
log.trace("...adding DN to record.");
String dn;
if (attribute.get() instanceof byte[]) {
dn = new String((byte[]) attribute.get());
} else {
dn = (String) attribute.get();
}
record.setDN(new DistinguishedName(dn));
} else {
log.trace("...adding attribute to record.");
Attribute attr = record.get(attribute.getID());
if (attr != null) {
attr.add(attribute.get());
} else {
record.put(attribute);
}
}
}
} catch (NamingException e) {
log.error(e);
} catch (NoSuchElementException e) {
log.error(e);
}
}
public void afterPropertiesSet() throws Exception {
Assert.notNull(resource, "A resource to parse is required.");
Assert.isTrue(resource.exists(), resource.getDescription() + ": resource does not exist!");
Assert.isTrue(resource.isReadable(), "Resource is not readable.");
}
}

90
core-tiger/src/main/java/org/springframework/ldap/ldif/parser/Parser.java
View File

@@ -1,90 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.parser;
import java.io.IOException;
import javax.naming.directory.Attributes;
import org.springframework.core.io.Resource;
/**
* The Parser interface represents the required methods to be implemented by parser utilities.
* These methods are the base set of methods needed to provide parsing ability.
*
* @author Keith Barlow
*/
public interface Parser {
/**
* Sets the resource to parse.
*
* @param resource The resource to parse.
*/
public void setResource(Resource resource);
/**
* Sets the control parameter for specifying case sensitivity on creation of the {@link Attributes} object.
*
* @param caseInsensitive The resource to parse.
*/
public void setCaseInsensitive(boolean caseInsensitive);
/**
* Opens the resource: the resource must be opened prior to parsing.
*
* @throws IOException if a problem is encountered while trying to open the resource.
*/
public void open() throws IOException;
/**
* Closes the resource after parsing.
*
* @throws IOException if a problem is encountered while trying to close the resource.
*/
public void close() throws IOException;
/**
* Resets the line read parser.
*
* @throws Exception if a problem is encountered while trying to reset the resource.
*/
public void reset() throws IOException;
/**
* True if the resource contains more records; false otherwise.
*
* @return boolean indicating whether or not the end of record has been reached.
* @throws IOException if a problem is encountered while trying to validate the resource is ready.
*/
public boolean hasMoreRecords() throws IOException;
/**
* Parses the next record from the resource.
*
* @return LdapAttributes object representing the record parsed.
* @throws IOException if a problem is encountered while trying to read from the resource.
*/
public Attributes getRecord() throws IOException;
/**
* Indicates whether or not the parser is ready to to return results.
*
* @return boolean indicator
* @throws IOException if there is a problem with the underlying resource.
*/
public boolean isReady() throws IOException;
}

7
core-tiger/src/main/java/org/springframework/ldap/ldif/parser/package.html
View File

@@ -1,7 +0,0 @@
<html>
<body>
This package contains the parser classes and interfaces.
</body>
</html>

36
core-tiger/src/main/java/org/springframework/ldap/ldif/support/AttributeValidationPolicy.java
View File

@@ -1,36 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.support;
import javax.naming.directory.Attribute;
/**
* Interface defining the required methods for AttributeValidationPolicies.
*
* @author Keith Barlow
*
*/
public interface AttributeValidationPolicy {
/**
* Validates attribute contained in the buffer and returns an LdapAttribute.
*
* @param buffer Buffer containing the line parsed from the resource.
* @return LdapAttribute representing the attribute parsed.
*/
Attribute parse(String buffer);
}

368
core-tiger/src/main/java/org/springframework/ldap/ldif/support/DefaultAttributeValidationPolicy.java
View File

@@ -1,368 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.support;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.naming.directory.Attribute;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.LdapAttribute;
import org.springframework.ldap.ldif.InvalidAttributeFormatException;
import sun.misc.BASE64Decoder;
/**
* Ensures the buffer represents a valid attribute as defined by RFC2849.
*
* Meets the standards imposed by RFC 2849 for the "LDAP Data Interchange Format (LDIF)
* - Technical Specification".
*
* Special attention is called to URL support: RFC 2849 requires that
* LDIFs support URLs as defined in 1738; however, RFC 1738 has been updated by several RFCs including
* RFC 1808, RFC 2396, and RFC 3986 (which obsoleted the formers). Unsupported features of this
* implementation of URL identification include query strings and fragments in HTTP URLs.
*
* @author Keith Barlow
*
*/
@SuppressWarnings("unused")
public class DefaultAttributeValidationPolicy implements AttributeValidationPolicy {
private static Log log = LogFactory.getLog(DefaultAttributeValidationPolicy.class);
/**
* Pattern Declarations.
*/
//General Definitions
private static final String DIGIT = "\\p{Digit}";
private static final String LOW_ALPHA = "\\p{Lower}";
private static final String HIGH_ALPHA = "\\p{Upper}";
private static final String ALPHA = "\\p{Alpha}";
private static final String ALPHANUM = "\\p{Alnum}";
private static final String HEX = "\\p{XDigit}";
private static final String SAFE = "[\\x24\\x2D\\x5F\\x2E\\x2B]"; //$|-|_|.|+
private static final String EXTRA = "[\\x21\\x2A\\x27\\x7B\\x7D\\x2C]"; //!|*|'|(|)|,
private static final String PUNCTUATION = "[\\x3C\\x3E\\x23\\x25\\x22]"; //<|>|#|%|"
private static final String ESCAPE = "%" + HEX + "{2}";
private static final String RESERVED = "[\\x3B\\x2F\\x3F\\x3A\\x40\\x26\\x3D]"; //;|/|?|:|@|&|=
private static final String UNRESERVED = "[" + ALPHA + DIGIT + SAFE + EXTRA + "]";
private static final String UCHAR = "(?:" + UNRESERVED + "|" + ESCAPE + ")";
private static final String XCHAR = "(?:" + UNRESERVED + "|" + RESERVED + "|" + ESCAPE + ")";
private static final String DIGITS = DIGIT + "+";
//Standard LDAP Attribute Definitions
private static final String ATTRIBUTE_SEPARATOR = ":";
private static final String OPTION_SEPARATOR = ";";
private static final String BASE64_INDICATOR = ":";
private static final String URL_INDICATOR = "<";
private static final String ATTRIBUTE_TYPE_CHARS = ALPHA + DIGIT + "-";
private static final String LDAP_OID = "[[0-9]|[1-9][0-9]+][\\.(?:[0-9]|[1-9][0-9]+)]+";
private static final String OPTION = "[" + ATTRIBUTE_TYPE_CHARS + "]+";
private static final String OPTIONS = "[" + OPTION_SEPARATOR + OPTION + "]*";
private static final String ATTRIBUTE_TYPE = LDAP_OID + "|" + ALPHANUM + "[" + ATTRIBUTE_TYPE_CHARS + "]*";
private static final String ATTRIBUTE_DESCRIPTION = "(" + ATTRIBUTE_TYPE + ")(" + OPTIONS + ")";
private static final String SAFE_CHAR = "[\\p{ASCII}&&[^\\x00\\x0A\\x0D]]"; //Any ASCII except NUL, LF, and CR
private static final String SAFE_INIT_CHAR = "[\\p{ASCII}&&[^ \\x00\\x0A\\x0D\\x3A\\x3C]]"; //Any ASCII except NUL, LF, CR, SPACE, colon, and less-than
private static final String SAFE_STRING = "(" + SAFE_INIT_CHAR + SAFE_CHAR + "*)";
private static final String FILL = "[ ]*"; //Any number of spaces
//BASE64 Definitions
private static final String BASE64_CHAR = "[\\x2B\\x2F\\x30-\\x39\\x3D\\x41-\\x5A\\x61-\\x7A]"; //+, /, 0-9, -, A-Z, a-z
private static final String BASE64_STRING = "(" + BASE64_CHAR + "*)";
//URL Components
private static final String USER = "[" + UCHAR + "\\x3B\\x3F\\x26\\x3D]*"; //UCHAR|;|?|&|=
private static final String PASSWORD = "[" + UCHAR + "\\x3B\\x3F\\x26\\x3D]*"; //UCHAR|;|?|&|=
private static final String DOMAINLABEL = ALPHANUM + "|" + ALPHANUM + "[" + ALPHANUM + "-]*" + ALPHANUM;
private static final String TOPLABEL = ALPHA + "|" + ALPHA + "[" + ALPHANUM + "-]*" + ALPHANUM;
private static final String HOSTNAME = "(?:" + DOMAINLABEL + "\\.)*" + TOPLABEL;
private static final String IPADDRESS = "(?:" + DIGIT + "{1,3}\\.){3}" + DIGIT + "{1,3}";
private static final String HOST = "(?:" + HOSTNAME + "|" + IPADDRESS + ")";
private static final String PORT = DIGITS;
private static final String HOSTPORT = HOST + "(?::" + PORT + ")?";
private static final String URLPATH = XCHAR + "*";
private static final String LOGIN = "(?:" + USER + "(?::" + PASSWORD + ")?@)?" + HOSTPORT;
//URL Definitions
private static final String SCHEME = "[" + LOW_ALPHA + DIGIT + "\\x2B\\x2D\\x2E]+";
private static final String IP_SCHEMEPART = "//" + LOGIN + "(?:/" + URLPATH + ")?";
private static final String SCHEMEPART = "(?:" + XCHAR + "*|" + IP_SCHEMEPART + ")";
private static final String GENERIC_URL = SCHEME + ":" + SCHEMEPART;
//HTTP Definition
private static final String HSEGMENT = "[" + UCHAR + "\\x3A\\x3B\\x26\\x3D\\x40]*"; //UCHAR|:|;|&|=|@
private static final String HPATH = HSEGMENT + "[/" + HSEGMENT + "]*";
private static final String SEARCH = HSEGMENT;
private static final String HTTP_URL = "http://" + HOSTPORT + "(?:/" + HPATH + "(?:\\x3F" + SEARCH + ")?)?";
//FTP
private static final String FSEGMENT = "[" + UCHAR + "\\x3F\\x3A\\x26\\x3D\\x40]*"; //UCHAR|?|:|&|=|@
private static final String FPATH = FSEGMENT + "[/" + FSEGMENT + "]*";
private static final String FTPTYPE = "[AIDaid]";
private static final String FTP_URL = "ftp://" + LOGIN + "(?:/" + FPATH + "(?:;type=" + FTPTYPE + ")?)?";
//NEWS
private static final String GROUP = ALPHA + "[" + ALPHA + DIGIT + "\\x2D\\x2E\\x2B\\x5F]*"; //ALPHA [ALPHA|DIGIT|-|.|+|_]*
private static final String ARTICLE = "[" + UCHAR + "\\x3A\\x3B\\x2F\\x3F\\x26\\x3D]@" + HOST; //[UCHAR|;|/|?|:|&|=]@HOST
private static final String GROUPPART = "(?:\\x2A|" + GROUP + "|" + ARTICLE + ")";
private static final String NEWS_URL = "news:" + GROUPPART;
//NNTP
private static final String NNTP_URL = "nntp://" + HOSTPORT + "/" + GROUP + "/" + DIGITS;
//TELNET
private static final String TELNET_URL = "telnet://" + LOGIN + "[/]?";
//GOPHER
private static final String GTYPE = XCHAR;
private static final String SELECTOR = XCHAR + "*";
private static final String GOPHER_STRING = XCHAR + "*";
private static final String GOPHER_URL = "gopher://" + HOSTPORT + "(?:/(?:" + GTYPE + "(?:" + SELECTOR + "(?:%09" + SEARCH + "(?:%09" + GOPHER_STRING + ")?)?)?)?)?";
//WAIS
private static final String WPATH = UCHAR + "*";
private static final String WTYPE = UCHAR + "*";
private static final String DATABASE = UCHAR + "*";
private static final String WAIS_DOC = "wais://" + HOSTPORT + "/" + DATABASE + "/" + WTYPE + "/" + WPATH;
private static final String WAIS_INDEX = "wais://" + HOSTPORT + "/" + DATABASE + "\\?" + SEARCH;
private static final String WAIS_DATABASE = "wais://" + HOSTPORT + "/" + DATABASE;
private static final String WAIS_URL = WAIS_DATABASE + "|" + WAIS_INDEX + "|" + WAIS_DOC;
//MAILTO
private static final String ENCODED_822_ADDR = XCHAR + "+";
private static final String MAILTO_URL = "mailto:" + ENCODED_822_ADDR;
//FILE
private static final String FILE_URL = "file://(?:" + HOST + "|localhost)?/" + FPATH ;
//PROPERO
private static final String FIELD_VALUE = "[" + UCHAR + "\\x3F\\x3A\\x40\\x26]*"; //[UCHAR|?|:|@|&]*
private static final String FIELD_NAME = "[" + UCHAR + "\\x3F\\x3A\\x40\\x26]*"; //[UCHAR|?|:|@|&]*
private static final String FIELD_SPEC = ";" + FIELD_NAME + "=" + FIELD_VALUE;
private static final String PSEGMENT = "[" + UCHAR + "\\x3F\\x3A\\x40\\x26\\x3D]*"; //[UCHAR|?|:|@|&|=]*
private static final String PPATH = PSEGMENT + "(?:/" + PSEGMENT + ")*";
private static final String PROSPERO_URL = "prospero://" + HOSTPORT + "/" + PPATH + "(?:" + FIELD_SPEC + ")*";
//GENERIC
private static final String OTHER_URL = GENERIC_URL;
private static final String URL = "((?:" + HTTP_URL + ")|(?:" + FTP_URL + ")|(?:" + NEWS_URL + ")|(?:" + NNTP_URL + ")|(?:" + TELNET_URL + ")|(?:" + GOPHER_URL + ")|(?:" + WAIS_URL + ")|(?:" + MAILTO_URL + ")|(?:" + FILE_URL + ")|(?:" + PROSPERO_URL + ")|(?:" + OTHER_URL + "))"; //URL Pattern
//Expression Definitions
private static final String ATTRIBUTE_EXPRESSION = "^" + ATTRIBUTE_DESCRIPTION + ATTRIBUTE_SEPARATOR + FILL + SAFE_STRING + "{0,1}$"; //Regular Attribute
private static final String BASE64_ATTRIBUTE_EXPRESSION = "^" + ATTRIBUTE_DESCRIPTION + ATTRIBUTE_SEPARATOR + BASE64_INDICATOR + FILL + BASE64_STRING + "$"; //Base 64
private static final String URL_ATTRIBUTE_EXPRESSION = "^" + ATTRIBUTE_DESCRIPTION + ATTRIBUTE_SEPARATOR + URL_INDICATOR + FILL + URL + "$"; //URL
//Pattern Declarations
private static final Pattern ATTRIBUTE_PATTERN = Pattern.compile(ATTRIBUTE_EXPRESSION);
private static final Pattern BASE64_ATTRIBUTE_PATTERN = Pattern.compile(BASE64_ATTRIBUTE_EXPRESSION);
private static final Pattern URL_ATTRIBUTE_PATTERN = Pattern.compile(URL_ATTRIBUTE_EXPRESSION);
private boolean ordered = false;
/**
* Default constructor.
*/
public DefaultAttributeValidationPolicy() {
}
/**
* Constructor for indicating whether or not attribute values should be ordered alphabetically.
*
* @param ordered value.
*/
public DefaultAttributeValidationPolicy(boolean ordered) {
this.ordered = ordered;
}
/**
* Indicates whether or not the attribute values should be ordered alphabetically.
*
* @param ordered value.
*/
public void setOrdered(boolean ordered) {
this.ordered = ordered;
}
/**
* Validates attribute contained in the buffer and returns an LdapAttribute.
* <p>
* Ensures attributes meets one of three prescribed patterns for valid attributes:
* <ol>
* <li>A standard attribute pattern of the form: ATTR_ID[;options]: VALUE</li>
* <li>A Base64 attribute pattern of the form: ATTR_ID[;options]:: BASE64_VALUE</li>
* <li>A url attribute pattern of the form: ATTR_ID[;options]:< URL_VALUE</li>
* </ol>
* <p>
* Upon success an LdapAttribute object is returned.
*
* @param buffer {@inheritDoc}
* @return {@inheritDoc}
* @throws InvalidAttributeFormatException if the attribute does not meet one of the three patterns above
* or the attribute cannot be parsed.
*/
public Attribute parse(String buffer) {
log.trace("Parsing --> [" + buffer + "]");
Matcher matcher = ATTRIBUTE_PATTERN.matcher(buffer);
if (matcher.matches()) {
//Is a regular attribute...
return parseStringAttribute(matcher);
}
matcher = BASE64_ATTRIBUTE_PATTERN.matcher(buffer);
if (matcher.matches()) {
//Is a base64 attribute...
return parseBase64Attribute(matcher);
}
matcher = URL_ATTRIBUTE_PATTERN.matcher(buffer);
if (matcher.matches()) {
//Is a URL attribute...
return parseUrlAttribute(matcher);
}
//default: no match.
throw new InvalidAttributeFormatException("Not a valid attribute: [" + buffer + "]");
}
private LdapAttribute parseStringAttribute(Matcher matcher) {
String id = matcher.group(1);
String value = matcher.group(3);
List<String> options = Arrays.asList((StringUtils.isEmpty(matcher.group(2)) ? new String[] {} : matcher.group(2).replaceFirst(";","").split(OPTION_SEPARATOR)));
if (options.isEmpty()) {
return new LdapAttribute(id, value, ordered);
} else {
return new LdapAttribute(id, value, options, ordered);
}
}
private LdapAttribute parseBase64Attribute(Matcher matcher) {
try {
String id = matcher.group(1);
String value = matcher.group(3);
List<String> options = Arrays.asList((StringUtils.isEmpty(matcher.group(2)) ? new String[] {} : matcher.group(2).replaceFirst(";","").split(OPTION_SEPARATOR)));
if (options.isEmpty()) {
return new LdapAttribute(id, new BASE64Decoder().decodeBuffer(value), ordered);
} else {
return new LdapAttribute(id, new BASE64Decoder().decodeBuffer(value), options, ordered);
}
} catch (IOException e) {
throw new InvalidAttributeFormatException(e);
}
}
private LdapAttribute parseUrlAttribute(Matcher matcher) {
try {
String id = matcher.group(1);
String value = matcher.group(3);
List<String> options = Arrays.asList((StringUtils.isEmpty(matcher.group(2)) ? new String[] {} : matcher.group(2).replaceFirst(";","").split(OPTION_SEPARATOR)));
if (options.isEmpty()) {
return new LdapAttribute(id, new URI(value), ordered);
} else {
return new LdapAttribute(id, new URI(value), options, ordered);
}
} catch (URISyntaxException e) {
throw new InvalidAttributeFormatException(e);
}
}
}

69
core-tiger/src/main/java/org/springframework/ldap/ldif/support/LineIdentifier.java
View File

@@ -1,69 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.support;
/**
* Enumeration declaring possible event types when parsing LDIF files.
*
* @author Keith Barlow
*/
public enum LineIdentifier {
/**
* Every LDIF file may optionally start with a version identifier of the form 'version: 1'.
*/
VersionIdentifier,
/**
* Signifies the start of a new record in the file has been encountered: a DN declaration.
*/
NewRecord,
/**
* Signals the end of record has been reached.
*/
EndOfRecord,
/**
* Signifies the event when a new attribute is encountered.
*/
Attribute,
/**
* Indicates the current line parsed is a continuation of the previous line.
*/
Continuation,
/**
* The current line is a comment and should be ignored.
*/
Comment,
/**
* An LDAP changetype control was encountered.
*/
Control,
/**
* Record being parsed is a 'changetype' record.
*/
ChangeType,
/**
* Parsed line should be ignored - used to skip remaining lines in a 'changetype' record.
*/
Void
}

116
core-tiger/src/main/java/org/springframework/ldap/ldif/support/SeparatorPolicy.java
View File

@@ -1,116 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.ldif.support;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Policy object for enforcing LDIF record separation rules. Designed explicitly
* for use in LdifParser. This default separator policy should really not be
* required to be replaced but it is modular just in case.
* <p>
* This class applies the separation policy prescribed in RFC2849 for LDIF files
* and identifies the line type from the input.
*
* @author Keith Barlow
*
*/
public class SeparatorPolicy {
private static Log log = LogFactory.getLog(SeparatorPolicy.class);
/*
* Line Identification Patterns.
*/
private static final String VERSION_IDENTIFIER = "^version: [0-9]+(\\.[0-9]*){0,1}$";
private static final String CONTROL = "control:";
private static final String CHANGE_TYPE = "changetype:";
private static final String CONTINUATION = " ";
private static final String COMMENT = "#";
private static final String NewRecord = "^dn:.*$";
private boolean record = false;
private boolean skip = false;
public SeparatorPolicy() {
}
/**
* Assess a read line.
* <p>
* In LDIF, lines must adhere to a particular format. A line can only contain one attribute
* and its value. The value may span multiple lines. Continuation lines are marked by the presence
* of a single space in the 1st position. Non-continuation lines must start in the first position.
*
*/
public LineIdentifier assess(String line) {
log.trace("Assessing --> [" + line + "]");
if (record) {
if (StringUtils.isEmpty(line)) {
record = false;
skip = false;
return LineIdentifier.EndOfRecord;
} else if (skip) {
return LineIdentifier.Void;
} else {
if (line.startsWith(CONTROL)) {
skip = true;
return LineIdentifier.Control;
} else if (line.startsWith(CHANGE_TYPE)) {
skip = true;
return LineIdentifier.ChangeType;
} else if (line.startsWith(COMMENT)) {
return LineIdentifier.Comment;
} else if (line.startsWith(CONTINUATION)) {
return LineIdentifier.Continuation;
} else {
return LineIdentifier.Attribute;
}
}
} else {
if (StringUtils.isNotEmpty(line) && line.matches(VERSION_IDENTIFIER) && !skip) {
//Version Identifiers are ignored by parser.
return LineIdentifier.VersionIdentifier;
} else if (StringUtils.isNotEmpty(line) && line.matches(NewRecord)) {
record = true;
skip = false;
return LineIdentifier.NewRecord;
} else {
return LineIdentifier.Void;
}
}
}
}

13
core-tiger/src/main/java/org/springframework/ldap/ldif/support/package.html
View File

@@ -1,13 +0,0 @@
<html>
<body>
Provides the necessary auxiliary classes utilized by the LDIFParser.
<p>
Notable classes in this package include:
<ul>
<li>AttributeValidationPolicy - specifies the proper format valid attributes must adhere to.</li>
<li>SeparatorPolicy - translates lines read from the resource into attributes.</li>
</ul>
</body>
</html>

66
core-tiger/src/main/java/org/springframework/ldap/schema/BasicSchemaSpecification.java
View File

@@ -1,66 +0,0 @@
package org.springframework.ldap.schema;
import javax.naming.NamingException;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapAttributes;
import org.springframework.ldap.core.LdapRdn;
import sun.misc.BASE64Encoder;
/**
* BasicSchemaSpecification establishes a minimal set of requirements for object classes.
* <p>
* This basic specification, which does not actually validate against any schema, deems objects
* valid as long as they meet the following criteria:
* <ul>
* <li>the object has a non-null DN.</li>
* <li>the object contains the naming attribute declared by the DN.</li>
* <li>the object declares an objectClass.</li>
* </ul>
*
* @author Keith Barlow
*
*/
public class BasicSchemaSpecification implements Specification<LdapAttributes> {
/**
* Determines if the policy is satisfied by the supplied LdapAttributes object.
*
* @throws NamingException
*/
public boolean isSatisfiedBy(LdapAttributes record) throws NamingException {
if (record != null) {
//DN is required.
DistinguishedName dn = record.getDN();
if (dn != null) {
//objectClass definition is required.
if (record.get("objectClass") != null) {
//Naming attribute is required.
LdapRdn rdn = dn.getLdapRdn(dn.size() - 1);
if (record.get(rdn.getKey()) != null) {
Object object = record.get(rdn.getKey()).get();
if (object instanceof String) {
String value = (String) object;
if (rdn.getValue().equalsIgnoreCase(value)) {
return true;
}
} else if(object instanceof byte[]) {
BASE64Encoder encoder = new BASE64Encoder();
String rdnValue = encoder.encode(rdn.getValue().getBytes());
String attributeValue = encoder.encode((byte[]) object);
if (rdnValue.equals(attributeValue)) return true;
}
}
}
}
}
return false;
}
}

42
core-tiger/src/main/java/org/springframework/ldap/schema/DefaultSchemaSpecification.java
View File

@@ -1,42 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.schema;
import javax.naming.NamingException;
import org.springframework.ldap.core.LdapAttributes;
/**
* DefaultSchemaSpecification does not validate objects at all - it simply returns true.
* <p>
* This specification is intended for cases where validation of the parsed entries is not
* required.
*
* @author Keith Barlow
*
*/
public class DefaultSchemaSpecification implements Specification<LdapAttributes> {
/**
* Determines if the policy is satisfied by the supplied LdapAttributes object.
*
* @throws NamingException
*/
public boolean isSatisfiedBy(LdapAttributes record) throws NamingException {
return true;
}
}

33
core-tiger/src/main/java/org/springframework/ldap/schema/Specification.java
View File

@@ -1,33 +0,0 @@
/*
* Copyright 2005-2009 the original author or authors.
*
* Licensed 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.springframework.ldap.schema;
import javax.naming.NamingException;
/**
* The specification interface is implemented to declare rules that
* a record must conform to. The motivation behind this class was
* to provide a mechanism to enable schema validations.
*
* @author Keith Barlow
*
* @param <T>
*/
public interface Specification<T> {
boolean isSatisfiedBy(T record) throws NamingException;
}

10
core-tiger/src/main/java/org/springframework/ldap/schema/package.html
View File

@@ -1,10 +0,0 @@
<html>
<body>
This package is aimed at providing a mechanism to implement LDAP schemas.
<p>
Utilized by the LDIFParser to validate object composition post assembly, these
classes may also be referenced by other utilities where seen fit.
</body>
</html>

155
core-tiger/src/test/java/org/springframework/ldap/ldif/DefaultAttributeValidationPolicyTest.java
View File

@@ -1,155 +0,0 @@
package org.springframework.ldap.ldif;
import static org.junit.Assert.*;
import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Parameterized;
import org.springframework.ldap.core.LdapAttribute;
import org.springframework.ldap.ldif.support.DefaultAttributeValidationPolicy;
import sun.misc.BASE64Decoder;
/**
* Parses a preselected set of attributes to test the full spectrum of functionality
* expected of an attribute parser. Attributes are validated to ensure they conform to
* the requirements for attribute values prescribed in RFC2849.
*
* @author Keith Barlow
*
*/
@RunWith(Parameterized.class)
public class DefaultAttributeValidationPolicyTest {
private static Log log = LogFactory.getLog(DefaultAttributeValidationPolicyTest.class);
private static DefaultAttributeValidationPolicy policy = new DefaultAttributeValidationPolicy();
private static enum AttributeType { STRING, BASE64, URL }
private String line;
private String id;
private String options;
private String value;
private AttributeType type;
private List<String> exceptions = Arrays.asList(new String[] {
"description: :A big sailing fan.",
"cn;lang-ja:: 5bCP56yg5Y6fIO.ODreODieODi+ODvA==",
"url:< http://java.sun.com/j2se/1.3/docs/guide/collections/designfaq.html#28"
});
/**
* The data set to parse.
* @return
*/
@Parameters
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
//Format: line, id, options, value, type
//String
{ "cn: Keith Barlow", "cn", "", "Keith Barlow", AttributeType.STRING},
{ "sn: Jensen", "sn", "", "Jensen", AttributeType.STRING},
{ "cn: Barbara J Jensen", "cn", "", "Barbara J Jensen", AttributeType.STRING},
{ "telephonenumber: +1 408 555 1212", "telephonenumber", "", "+1 408 555 1212", AttributeType.STRING},
{ "description: A big sailing fan.", "description", "", "A big sailing fan.", AttributeType.STRING},
{ "title;lang-en;phonetic: Sales, Director", "title", ";lang-en;phonetic", "Sales, Director", AttributeType.STRING},
{ "mail: rogasawara@airius.co.jp", "mail", "", "rogasawara@airius.co.jp", AttributeType.STRING},
{ "description: A big sailing fan.", "description", "", "A big sailing fan.", AttributeType.STRING},
{ "description: :A big sailing fan.", "description", "", ":A big sailing fan.", AttributeType.STRING},
//Base64
{ "xml:: PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4=", "xml", "", "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4=", AttributeType.BASE64},
{ "ou;lang-ja;phonetic:: 44GI44GE44GO44KH44GG44G2", "ou", ";lang-ja;phonetic", "44GI44GE44GO44KH44GG44G2", AttributeType.BASE64 },
{ "dn:: dWlkPXJvZ2FzYXdhcmEsb3U95Za25qWt6YOoLG89QWlyaXVz", "dn", "", "dWlkPXJvZ2FzYXdhcmEsb3U95Za25qWt6YOoLG89QWlyaXVz", AttributeType.BASE64 },
{ "cn;lang-ja:: 5bCP56yg5Y6fIOODreODieODi+ODvA==", "cn", ";lang-ja", "5bCP56yg5Y6fIOODreODieODi+ODvA==", AttributeType.BASE64 },
{ "cn;lang-ja:: 5bCP56yg5Y6fIO.ODreODieODi+ODvA==", "cn", ";lang-ja", "5bCP56yg5Y6fIO.ODreODieODi+ODvA==", AttributeType.BASE64 },
//Url
{ "url:< http://www.oracle.com/", "url", "", "http://www.oracle.com/", AttributeType.URL},
{ "url:< http://java.sun.com/j2se/1.3/docs/guide/collections/designfaq.html", "url", "", "http://java.sun.com/j2se/1.3/docs/guide/collections/designfaq.html", AttributeType.URL},
{ "url:< ftp://kbarlow:test@ftp.is.co.za/rfc/rfc1808.txt", "url", "", "ftp://kbarlow:test@ftp.is.co.za/rfc/rfc1808.txt", AttributeType.URL},
{ "url;option:< ftp://ftp.is.co.za:2100/rfc/rfc1808.txt;type=a", "url", ";option", "ftp://ftp.is.co.za:2100/rfc/rfc1808.txt;type=a", AttributeType.URL},
{ "url:< telnet://kbarlow@melvyl.ucop.edu/", "url", "", "telnet://kbarlow@melvyl.ucop.edu/", AttributeType.URL},
{ "url;option1;option2:< telnet://kbarlow:test@melvyl.ucop.edu/", "url", ";option1;option2", "telnet://kbarlow:test@melvyl.ucop.edu/", AttributeType.URL},
{ "url:< gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles", "url", "", "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles", AttributeType.URL},
{ "url:< file:///usr/local/directory/photos/fiona.jpg", "url", "", "file:///usr/local/directory/photos/fiona.jpg", AttributeType.URL},
{ "url:< mailto:java-net@java.sun.com", "url", "", "mailto:java-net@java.sun.com", AttributeType.URL},
{ "url:< news:comp.infosystems.www.servers.unix", "url", "", "news:comp.infosystems.www.servers.unix", AttributeType.URL},
{ "url:< prospero://host.dom:1525//pros/name;key=value", "url", "", "prospero://host.dom:1525//pros/name;key=value", AttributeType.URL},
{ "url:< nntp://news.cs.hut.fi/alt.html/239157", "url", "", "nntp://news.cs.hut.fi/alt.html/239157", AttributeType.URL},
{ "url:< wais://vega.lib.ncsu.edu/alawon.src?nren", "url", "", "wais://vega.lib.ncsu.edu/alawon.src?nren", AttributeType.URL},
{ "url:< http://java.sun.com/j2se/1.3/docs/guide/collections/designfaq.html#28", "url", "", "http://java.sun.com/j2se/1.3/docs/guide/collections/designfaq.html#28", AttributeType.URL}
});
}
/**
* DefaultAttributeValidationPolicyTest: Parameterized constructor.
* @param line The attribute to parse.
* @param id The ID portion of the attribute expected on successful parsing.
* @param options The Options expected on successful parsing.
* @param value The value expected from successful parsing.
* @param type The attribute type: one of enum AttributeType.
*/
public DefaultAttributeValidationPolicyTest(String line, String id, String options, String value, AttributeType type) {
this.line = line;
this.id = id;
this.options = options;
this.value = value;
this.type = type;
}
/**
* The test case: parses passed in parameters and validates the outcome against the expected results.
*/
@Test
public void parseAttribute() {
try {
LdapAttribute attribute = (LdapAttribute) policy.parse(line);
assertTrue("IDs do not match: [expected: " + attribute.getID() + ", obtained: " + id + "]", id.equalsIgnoreCase(attribute.getID()));
String[] expected = StringUtils.isEmpty(options) ? new String[] {} : options.replaceFirst(";","").split(";");
Arrays.sort(expected);
String[] obtained = attribute.getOptions().toArray(new String[] {});
Arrays.sort(obtained);
assertArrayEquals("Options do not match: ", expected, obtained);
switch(type) {
case STRING:
assertTrue("Value is not a string.", attribute.get() instanceof String);
assertEquals("Values do not match: ", value, (String) attribute.get());
break;
case BASE64:
byte[] bytes = new BASE64Decoder().decodeBuffer(value);
assertTrue("Value is not a byte[].", attribute.get() instanceof byte[]);
assertArrayEquals("Values do not match: ", bytes, (byte[]) attribute.get());
break;
case URL:
URI url = new URI(value);
assertTrue("Value is not a URL.", attribute.get() instanceof URI);
assertEquals("Values do not match: ", url, (URI) attribute.get());
break;
}
log.info("Success!");
} catch (Exception e) {
if (!exceptions.contains(line))
fail("Exception thrown: " + e.getClass().getSimpleName() + " (message: " + e.getMessage() + ")");
}
}
}

110
core-tiger/src/test/java/org/springframework/ldap/ldif/LdifParserTest.java
View File

@@ -1,110 +0,0 @@
package org.springframework.ldap.ldif;
import static org.junit.Assert.*;
import java.io.IOException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.io.ClassPathResource;
import org.springframework.ldap.core.LdapAttributes;
import org.springframework.ldap.ldif.parser.LdifParser;
import org.springframework.ldap.schema.BasicSchemaSpecification;
/**
* Unit test for LdifParser.
*
* Test results in complete end to end test of all LdifParser functionality:
* 1.) Open a file
* 2.) Read lines and compose an attribute.
* 3.) Parse the attribute and create a LdapAttribute object.
* 4.) Repeat until end of record (Identify end of record).
* 5.) Return a valid LdapAttributes object.
* 6.) Close file upon completion.
*
* Provided test file is comprised of sample LDIFs from RFC2849 and exhausts the full range of
* the functionality prescribed by RFC2849 for the LDAP Data Interchange Format (LDIF).
*
* @author Keith Barlow
*
*/
public class LdifParserTest {
private static Log log = LogFactory.getLog(LdifParserTest.class);
private LdifParser parser;
/**
* Default constructor: loads a preselected resource with sample LDIF entries.
* Each entry is parsed and checked for a DN and objectclass. Output is printed for visual verification
* of LDIF correctness.
*/
public LdifParserTest() {
parser = new LdifParser(new ClassPathResource("test.ldif"));
parser.setRecordSpecification(new BasicSchemaSpecification());
}
/**
* Setup: opens file.
*/
@Before
public void openLdif() {
try {
parser.open();
} catch (IOException e) {
fail(e.getMessage());
}
}
/**
* Executes test: reads all records from LDIF file and validates an LdapAttributes object is successfully created.
*/
@Test
public void parseLdif() {
int count = 0;
try {
LdapAttributes attributes;
while (parser.hasMoreRecords()) {
try {
attributes = parser.getRecord();
log.info("attributes:\n" + attributes);
if (attributes != null) {
assertTrue("A dn is required.", attributes.getDN() != null);
assertTrue("Object class is required.", attributes.get("objectclass") != null);
count++;
}
} catch (InvalidAttributeFormatException e) {
log.error(e);
if (count != 6) fail();
}
log.debug("hasMoreRecords: " + parser.hasMoreRecords());
}
log.info("record count: " + count);
//assertTrue("An incorrect number of records were parsed.", count == 8);
log.info("Done!");
} catch (IOException e) {
fail(e.getMessage());
}
}
/**
* Cleanup: closes file.
*/
@After
public void closeLdif() {
try {
parser.close();
} catch (IOException e) {
fail(e.getMessage());
}
}
}

11
ldif/ldif-batch/src/test/resources/log4j.properties
View File

@@ -1,12 +1,7 @@
log4j.rootCategory=INFO, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.org.springframework.test=INFO, console
log4j.logger.org.springframework.beans=INFO, console
log4j.logger.org.springframework.context=INFO, console
log4j.logger.org.springframework.transaction=INFO, console
log4j.logger.org.springframework.aop=INFO, console
log4j.logger.org.springframework.batch=INFO, console
log4j.logger.org.springframework.ldap.ldif=INFO, console
log4j.logger.org.apache.directory=ERROR

1
ldif/ldif-core/pom.xml
View File

@@ -3,6 +3,7 @@
<groupId>org.springframework.ldap</groupId>
<artifactId>spring-ldap-parent-tiger</artifactId>
<version>1.3.1.CI-SNAPSHOT</version>
<relativePath>../../parent/tiger</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-ldap-ldif-core</artifactId>

5
ldif/ldif-core/src/test/resources/log4j.properties
View File

@@ -1,6 +1,7 @@
log4j.rootCategory=INFO, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.org.springframework.ldap.ldif=INFO, console
log4j.logger.org.apache.directory=ERROR

1
ldif/pom.xml
View File

@@ -3,6 +3,7 @@
<groupId>org.springframework.ldap</groupId>
<artifactId>spring-ldap-parent</artifactId>
<version>1.3.1.CI-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>

1
odm/pom.xml
View File

@@ -5,6 +5,7 @@
<groupId>org.springframework.ldap</groupId>
<artifactId>spring-ldap-parent</artifactId>
<version>1.3.1.CI-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework.ldap</groupId>

6
parent/pom.xml
View File

@@ -283,18 +283,23 @@
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>findbugs-maven-plugin</artifactId>
<version>1.2</version>
</plugin>
<plugin>
<artifactId>maven-jxr-plugin</artifactId>
<version>2.1</version>
</plugin>
<plugin>
<artifactId>maven-surefire-report-plugin</artifactId>
<version>2.4.3</version>
</plugin>
<plugin>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.5</version>
<reportSets>
<reportSet>
<reports>
@@ -306,6 +311,7 @@
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>cobertura-maven-plugin</artifactId>
<version>2.3</version>
</plugin>
</plugins>
</reporting>

4
pom.xml
View File

@@ -465,6 +465,7 @@
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>versions-maven-plugin</artifactId>
<version>1.1</version>
<reportSets>
<reportSet>
<reports>
@@ -477,9 +478,11 @@
</plugin>
<plugin>
<artifactId>maven-jxr-plugin</artifactId>
<version>2.1</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.5</version>
<reportSets>
<reportSet>
<reports>
@@ -490,6 +493,7 @@
</plugin>
<plugin>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.2</version>
</plugin>
</plugins>
</reporting>