Authors
Authors
cn=[fullname],ou=[company],c=[country], so
* the values of these attributes must be extracted from the DN. For this,
* we use the DistinguishedName.
*
*Mattias Hellborg Arthurssonellborg Arthursson
* @author Ulrik Sandberg
*/
private static class PersonContextMapper implements ContextMapper {
public Object mapFromContext(Object ctx) {
DirContextAdapter context = (DirContextAdapter) ctx;
DistinguishedName dn = new DistinguishedName(context.getDn());
Person person = new Person();
person.setCountry(dn.getLdapRdn(0).getComponent().getValue());
person.setCompany(dn.getLdapRdn(1).getComponent().getValue());
person.setFullName(context.getStringAttribute("cn"));
person.setLastName(context.getStringAttribute("sn"));
person.setDescription(context.getStringAttribute("description"));
person.setPhone(context.getStringAttribute("telephoneNumber"));
return person;
}
}
public void setLdapTemplate(LdapTemplate ldapTemplate) {
this.ldapTemplate = ldapTemplate;
}
}
libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring20/src/main/webapp/ 0002755 0000000 0000000 00000000000 11475313400 023770 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring20/src/main/webapp/WEB-INF/ 0002755 0000000 0000000 00000000000 11475313400 025017 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring20/src/main/webapp/WEB-INF/jsp/ 0002755 0000000 0000000 00000000000 11475313400 025613 5 ustar ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring20/src/main/webapp/WEB-INF/jsp/showPerson.jsp libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring20/src/main/webapp/WEB-INF/jsp/showPers0000644 0000000 0000000 00000000534 11475313400 027350 0 ustar <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
Back
Full name: ${person.fullName}
LastName: ${person.lastName}
Description: ${person.description}
Country: ${person.country}
Company: ${person.company}
Phone: ${person.phone}
Operations
Clicking a link below performs the described operation which will be reflected in the LDAP tree below
Add new test person 'John Doe' (only works once)Add a '0' to the phone number of test person (only works if the person has been created)
Remove test person
Tree contents
Click a person row to see the attribute values (country and company rows do not have additional info)
cn=[fullname],ou=[company],c=[country], so
* the values of these attributes must be extracted from the DN. For this,
* we use the DistinguishedName.
*
*Mattias Hellborg Arthurssonellborg Arthursson
* @author Ulrik Sandberg
*/
private static class PersonContextMapper implements ContextMapper {
public Object mapFromContext(Object ctx) {
DirContextAdapter context = (DirContextAdapter) ctx;
DistinguishedName dn = new DistinguishedName(context.getDn());
Person person = new Person();
person.setCountry(dn.getLdapRdn(0).getComponent().getValue());
person.setCompany(dn.getLdapRdn(1).getComponent().getValue());
person.setFullName(context.getStringAttribute("cn"));
person.setLastName(context.getStringAttribute("sn"));
person.setDescription(context.getStringAttribute("description"));
person.setPhone(context.getStringAttribute("telephoneNumber"));
return person;
}
}
public void setLdapTemplate(LdapTemplate ldapTemplate) {
this.ldapTemplate = ldapTemplate;
}
}
libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring30/src/main/webapp/ 0002755 0000000 0000000 00000000000 11475313400 023771 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring30/src/main/webapp/WEB-INF/ 0002755 0000000 0000000 00000000000 11475313400 025020 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring30/src/main/webapp/WEB-INF/jsp/ 0002755 0000000 0000000 00000000000 11475313400 025614 5 ustar ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring30/src/main/webapp/WEB-INF/jsp/showPerson.jsp libspring-ldap-java-1.3.1.RELEASE.orig/samples/article-spring30/src/main/webapp/WEB-INF/jsp/showPers0000644 0000000 0000000 00000000534 11475313400 027351 0 ustar <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
Back
Full name: ${person.fullName}
LastName: ${person.lastName}
Description: ${person.description}
Country: ${person.country}
Company: ${person.company}
Phone: ${person.phone}
Operations
Clicking a link below performs the described operation which will be reflected in the LDAP tree below
Add new test person 'John Doe' (only works once)Add a '0' to the phone number of test person (only works if the person has been created)
Remove test person
Tree contents
Click a person row to see the attribute values (country and company rows do not have additional info)
\n"); rows.add(sb.toString()); } protected String getLinkForNode(DirContextOperations node) { return "#"; } public List
cn=[fullname],ou=[company],c=[country], so
* the values of these attributes must be extracted from the DN. For this,
* we use the DistinguishedName.
*
*Mattias Hellborg Arthurssonellborg Arthursson
* @author Ulrik Sandberg
*/
private static class PersonContextMapper implements ContextMapper {
public Object mapFromContext(Object ctx) {
DirContextAdapter context = (DirContextAdapter) ctx;
DistinguishedName dn = new DistinguishedName(context.getDn());
Person person = new Person();
person.setCountry(dn.getLdapRdn(0).getComponent().getValue());
person.setCompany(dn.getLdapRdn(1).getComponent().getValue());
person.setFullName(context.getStringAttribute("cn"));
person.setLastName(context.getStringAttribute("sn"));
person.setDescription(context.getStringAttribute("description"));
person.setPhone(context.getStringAttribute("telephoneNumber"));
return person;
}
}
public void setLdapTemplate(LdapTemplate ldapTemplate) {
this.ldapTemplate = ldapTemplate;
}
}
libspring-ldap-java-1.3.1.RELEASE.orig/samples/article/src/main/webapp/ 0002755 0000000 0000000 00000000000 11475313400 022326 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article/src/main/webapp/WEB-INF/ 0002755 0000000 0000000 00000000000 11475313400 023355 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article/src/main/webapp/WEB-INF/jsp/ 0002755 0000000 0000000 00000000000 11475313400 024151 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/samples/article/src/main/webapp/WEB-INF/jsp/showPerson.jsp 0000644 0000000 0000000 00000000534 11475313400 027036 0 ustar <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
Back
Full name: ${person.fullName}
LastName: ${person.lastName}
Description: ${person.description}
Country: ${person.country}
Company: ${person.company}
Phone: ${person.phone}
Operations
Clicking a link below performs the described operation which will be reflected in the LDAP tree below
Add new test person 'John Doe' (only works once)Add a '0' to the phone number of test person (only works if the person has been created)
Remove test person
Tree contents
Click a person row to see the attribute values (country and company rows do not have additional info)
* The {@link MappingLdifReader MappingLdifReader} requires an {@link RecordMapper RecordMapper} implementation. If mapping * is not required, the {@link LdifReader LdifReader} should be used instead. It simply returns an {@link LdapAttributes LdapAttributes} * object which can be consumed and manipulated as necessary by {@link org.springframework.batch.item.ItemProcessor ItemProcessor} or any * output service. *
* {@link LdifReader LdifReader} usage is mimics that of the FlatFileItemReader for all intensive purposes. Adjustments have been made to * process records instead of lines, however. As such, the {@link #recordsToSkip recordsToSkip} attribute indicates the number of records * from the top of the file that should not be processed. Implementations of the {@link RecordCallbackHandler RecordCallbackHandler} * interface can be used to execute operations on those skipped records. *
* As with the {@link org.springframework.batch.item.file.FlatFileItemReader FlatFileItemReader}, the {@link #strict strict} option
* differentiates between whether or not to require the resource to exist before processing. In the case of a value set to false, a warning
* is logged instead of an exception being thrown.
*
* @author Keith Barlow
*
*/
public class MappingLdifReader
* Unlike the {@link org.springframework.batch.item.file.FlatFileItemReader FlatFileItemReader}, the {@link LdifReader LdifReader}
* does not require a mapper. Instead, this version of the {@link LdifReader LdifReader} simply returns an {@link LdapAttributes LdapAttributes}
* object which can be consumed and manipulated as necessary by {@link org.springframework.batch.item.ItemProcessor ItemProcessor} or any
* output service. Alternatively, the {@link RecordMapper RecordMapper} interface can be implemented and set in a
* {@link MappingLdifReader MappingLdifReader} to map records to objects for return.
*
* {@link LdifReader LdifReader} usage is mimics that of the {@link org.springframework.batch.item.file.FlatFileItemReader FlatFileItemReader}
* for all intensive purposes. Adjustments have been made to process records instead of lines, however. As such, the
* {@link #recordsToSkip recordsToSkip} attribute indicates the number of records from the top of the file that should not be processed.
* Implementations of the {@link RecordCallbackHandler RecordCallbackHandler} interface can be used to execute operations on those skipped records.
*
* As with the {@link org.springframework.batch.item.file.FlatFileItemReader FlatFileItemReader}, the {@link #strict strict} option differentiates
* between whether or not to require the resource to exist before processing. In the case of a value set to false, a warning is logged instead of
* an exception being thrown.
*
* @author Keith Barlow
*
*/
public class LdifReader extends AbstractItemCountingItemStreamItemReader
* Example: If the specified
* Note that using this strategy means that the entry remains in virtually the
* same location as where it originally resided. This means that searches later
* in the same transaction might return references to the temporary entry even
* though it should have been removed or rebound.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class DefaultTempEntryRenamingStrategy implements
TempEntryRenamingStrategy {
/**
* The default temp entry suffix, "_temp".
*/
public static final String DEFAULT_TEMP_SUFFIX = "_temp";
private String tempSuffix = DEFAULT_TEMP_SUFFIX;
/*
* @see org.springframework.ldap.support.transaction.TempEntryRenamingStrategy#getTemporaryName(javax.naming.Name)
*/
public Name getTemporaryName(Name originalName) {
DistinguishedName temporaryName = new DistinguishedName(originalName);
List names = temporaryName.getNames();
LdapRdn rdn = (LdapRdn) names.get(names.size() - 1);
LdapRdnComponent rdnComponent = rdn.getComponent();
String value = rdnComponent.getValue();
rdnComponent.setValue(value + DEFAULT_TEMP_SUFFIX);
return temporaryName;
}
/**
* Get the suffix that will be used for renaming temporary entries.
*
* @return the suffix.
*/
public String getTempSuffix() {
return tempSuffix;
}
/**
* Set the suffix to use for renaming temporary entries. Default value is
* {@link #DEFAULT_TEMP_SUFFIX}.
*
* @param tempSuffix
* the suffix.
*/
public void setTempSuffix(String tempSuffix) {
this.tempSuffix = tempSuffix;
}
}
././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000161 11475313376 030207 0 ustar
* NOTE: The transactions provided by this TransactionManager are all
* client side and are by no means 'real' transactions, in the sense
* that we know them in the ordinary database world, e.g.:
*
* While the points above should be noted and considered, the compensating
* transaction approach will be perfectly sufficient for all but the most
* unfortunate of circumstances. Considering that there currently is a total
* absence of server-side transaction support in the LDAP world, being able to
* mark operations as transactional in the same way as for relational database
* operations is surely a step forward.
*
* An LDAP transaction is tied to a {@link ContextSource}, to be supplied to
* the {@link #setContextSource(ContextSource)} method. While the actual
* ContextSource used by the target LdapTemplate instance needs to be of the
* type {@link TransactionAwareContextSourceProxy}, the ContextSource supplied
* to this class should be the actual target ContextSource.
*
* Using this TransactionManager along with
* {@link TransactionAwareContextSourceProxy}, all modifying operations (bind,
* unbind, rebind, rename, modifyAttributes) in a transaction will be
* intercepted. Each modification has its corresponding
* {@link CompensatingTransactionOperationRecorder}, which collects the
* information necessary to perform a rollback and produces a
* {@link CompensatingTransactionOperationExecutor} which is then used to
* execute the actual operation and is later called for performing the commit or
* rollback.
*
* For several of the operations, performing a rollback is pretty
* straightforward. For example, in order to roll back a rename operation, it
* will only be required to rename the entry back to its original position. For
* other operations, however, it's a bit more complicated. An unbind operation
* is not possible to roll back by simply binding the entry back with the
* attributes retrieved from the original entry. It might not be possible to get
* all the information from the original entry. Consequently, the
* {@link UnbindOperationExecutor} will move the original entry to a temporary
* location in its performOperation() method. The commit() method will know that
* everything went well, so it will be OK to unbind the entry. The rollback
* operation will be to rename the entry back to its original location. The same
* behaviour is used for rebind() operations. The operation of calculating a
* temporary location for an entry is delegated to a
* {@link TempEntryRenamingStrategy} (default
* {@link DefaultTempEntryRenamingStrategy}), specified in
* {@link #setRenamingStrategy(TempEntryRenamingStrategy)}.
*
* The actual work of this Transaction Manager is delegated to a
* {@link ContextSourceTransactionManagerDelegate}. This is because the exact
* same logic needs to be used if we want to wrap a JDBC and LDAP transaction in
* the same logical transaction.
*
* Example:
*
*
*
* Configuration:
*
*
*
* @author Eric Dalquist
*/
public class PoolingContextSource implements ContextSource, DisposableBean {
/**
* The logger for this class and sub-classes
*/
protected final Log logger = LogFactory.getLog(this.getClass());
protected final GenericKeyedObjectPool keyedObjectPool;
private final DirContextPoolableObjectFactory dirContextPoolableObjectFactory;
/**
* Creates a new pooling context source, setting up the DirContext object
* factory and generic keyed object pool.
*/
public PoolingContextSource() {
this.dirContextPoolableObjectFactory = new DirContextPoolableObjectFactory();
this.keyedObjectPool = new GenericKeyedObjectPool();
this.keyedObjectPool.setFactory(this.dirContextPoolableObjectFactory);
}
// ***** Pool Property Configuration *****//
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMaxActive()
*/
public int getMaxActive() {
return this.keyedObjectPool.getMaxActive();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMaxIdle()
*/
public int getMaxIdle() {
return this.keyedObjectPool.getMaxIdle();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMaxTotal()
*/
public int getMaxTotal() {
return this.keyedObjectPool.getMaxTotal();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMaxWait()
*/
public long getMaxWait() {
return this.keyedObjectPool.getMaxWait();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMinEvictableIdleTimeMillis()
*/
public long getMinEvictableIdleTimeMillis() {
return this.keyedObjectPool.getMinEvictableIdleTimeMillis();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getMinIdle()
*/
public int getMinIdle() {
return this.keyedObjectPool.getMinIdle();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getNumActive()
*/
public int getNumActive() {
return this.keyedObjectPool.getNumActive();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getNumIdle()
*/
public int getNumIdle() {
return this.keyedObjectPool.getNumIdle();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getNumTestsPerEvictionRun()
*/
public int getNumTestsPerEvictionRun() {
return this.keyedObjectPool.getNumTestsPerEvictionRun();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getTestOnBorrow()
*/
public boolean getTestOnBorrow() {
return this.keyedObjectPool.getTestOnBorrow();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getTestOnReturn()
*/
public boolean getTestOnReturn() {
return this.keyedObjectPool.getTestOnReturn();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getTestWhileIdle()
*/
public boolean getTestWhileIdle() {
return this.keyedObjectPool.getTestWhileIdle();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getTimeBetweenEvictionRunsMillis()
*/
public long getTimeBetweenEvictionRunsMillis() {
return this.keyedObjectPool.getTimeBetweenEvictionRunsMillis();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#getWhenExhaustedAction()
*/
public byte getWhenExhaustedAction() {
return this.keyedObjectPool.getWhenExhaustedAction();
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMaxActive(int)
*/
public void setMaxActive(int maxActive) {
this.keyedObjectPool.setMaxActive(maxActive);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMaxIdle(int)
*/
public void setMaxIdle(int maxIdle) {
this.keyedObjectPool.setMaxIdle(maxIdle);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMaxTotal(int)
*/
public void setMaxTotal(int maxTotal) {
this.keyedObjectPool.setMaxTotal(maxTotal);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMaxWait(long)
*/
public void setMaxWait(long maxWait) {
this.keyedObjectPool.setMaxWait(maxWait);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMinEvictableIdleTimeMillis(long)
*/
public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
this.keyedObjectPool.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setMinIdle(int)
*/
public void setMinIdle(int poolSize) {
this.keyedObjectPool.setMinIdle(poolSize);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setNumTestsPerEvictionRun(int)
*/
public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
this.keyedObjectPool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setTestOnBorrow(boolean)
*/
public void setTestOnBorrow(boolean testOnBorrow) {
this.keyedObjectPool.setTestOnBorrow(testOnBorrow);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setTestOnReturn(boolean)
*/
public void setTestOnReturn(boolean testOnReturn) {
this.keyedObjectPool.setTestOnReturn(testOnReturn);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setTestWhileIdle(boolean)
*/
public void setTestWhileIdle(boolean testWhileIdle) {
this.keyedObjectPool.setTestWhileIdle(testWhileIdle);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setTimeBetweenEvictionRunsMillis(long)
*/
public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
this.keyedObjectPool.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
}
/**
* @see org.apache.commons.pool.impl.GenericKeyedObjectPool#setWhenExhaustedAction(byte)
*/
public void setWhenExhaustedAction(byte whenExhaustedAction) {
this.keyedObjectPool.setWhenExhaustedAction(whenExhaustedAction);
}
// ***** Object Factory Property Configuration *****//
/**
* @return the contextSource
*/
public ContextSource getContextSource() {
return this.dirContextPoolableObjectFactory.getContextSource();
}
/**
* @return the dirContextValidator
*/
public DirContextValidator getDirContextValidator() {
return this.dirContextPoolableObjectFactory.getDirContextValidator();
}
/**
* @param contextSource the contextSource to set
* Required
*/
public void setContextSource(ContextSource contextSource) {
this.dirContextPoolableObjectFactory.setContextSource(contextSource);
}
/**
* @param dirContextValidator the dirContextValidator to set
* Required
*/
public void setDirContextValidator(DirContextValidator dirContextValidator) {
this.dirContextPoolableObjectFactory.setDirContextValidator(dirContextValidator);
}
// ***** DisposableBean interface methods *****//
/*
* (non-Javadoc)
*
* @see org.springframework.beans.factory.DisposableBean#destroy()
*/
public void destroy() throws Exception {
try {
this.keyedObjectPool.close();
}
catch (Exception e) {
this.logger.warn("An exception occured while closing the underlying pool.", e);
}
}
// ***** ContextSource interface methods *****//
/*
* @see ContextSource#getReadOnlyContext()
*/
public DirContext getReadOnlyContext() throws NamingException {
return this.getContext(DirContextType.READ_ONLY);
}
/*
* @see ContextSource#getReadWriteContext()
*/
public DirContext getReadWriteContext() throws NamingException {
return this.getContext(DirContextType.READ_WRITE);
}
/**
* Gets a DirContext of the specified type from the keyed object pool.
*
* @param dirContextType The type of context to return.
* @return A wrapped DirContext of the specified type.
* @throws DataAccessResourceFailureException If retrieving the object from
* the pool throws an exception
*/
protected DirContext getContext(DirContextType dirContextType) {
final DirContext dirContext;
try {
dirContext = (DirContext) this.keyedObjectPool.borrowObject(dirContextType);
}
catch (Exception e) {
throw new DataAccessResourceFailureException("Failed to borrow DirContext from pool.", e);
}
if (dirContext instanceof LdapContext) {
return new DelegatingLdapContext(this.keyedObjectPool, (LdapContext) dirContext, dirContextType);
}
return new DelegatingDirContext(this.keyedObjectPool, dirContext, dirContextType);
}
public DirContext getContext(String principal, String credentials) throws NamingException {
throw new UnsupportedOperationException("Not supported for this implementation");
}
}
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/factory/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000115 11475313376 030206 0 ustar
Core classes for the pooling library.
././@LongLink 0000000 0000000 0000000 00000000223 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/factory/MutablePoolingContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003522 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.pool.factory;
import javax.naming.directory.DirContext;
import javax.naming.ldap.LdapContext;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.ldap.pool.DelegatingDirContext;
import org.springframework.ldap.pool.DirContextType;
import org.springframework.ldap.pool.MutableDelegatingLdapContext;
/**
* A {@link PoolingContextSource} subclass that creates
* {@link MutableDelegatingLdapContext} instances. This enables the Spring LDAP
* pooling to be used in scenarios that require request controls to be set, such
* as paged results.
*/
public class MutablePoolingContextSource extends PoolingContextSource {
protected DirContext getContext(DirContextType dirContextType) {
final DirContext dirContext;
try {
dirContext = (DirContext) this.keyedObjectPool.borrowObject(dirContextType);
}
catch (Exception e) {
throw new DataAccessResourceFailureException("Failed to borrow DirContext from pool.", e);
}
if (dirContext instanceof LdapContext) {
return new MutableDelegatingLdapContext(this.keyedObjectPool, (LdapContext) dirContext, dirContextType);
}
return new DelegatingDirContext(this.keyedObjectPool, dirContext, dirContextType);
}
}
././@LongLink 0000000 0000000 0000000 00000000227 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/factory/DirContextPoolableObjectFactory.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000015673 11475313376 030225 0 ustar /*
* Copyright 2005-2010 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.pool.factory;
import javax.naming.directory.DirContext;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool.BaseKeyedPoolableObjectFactory;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.pool.DirContextType;
import org.springframework.ldap.pool.validation.DirContextValidator;
/**
* Factory that creates {@link DirContext} instances for pooling via a
* configured {@link ContextSource}. The {@link DirContext}s are keyed based
* on if they are read only or read/write. The expected key type is the
* {@link DirContextType} enum.
*
*
*
* Property Description Required Default
*
*
* contextSource
*
* The {@link ContextSource} to get {@link DirContext}s from for adding to the
* pool.
* Yes
* null
*
*
* dirContextValidator
*
* The {@link DirContextValidator} to use for validating {@link DirContext}s.
* Required if any of the test/validate options are enabled.
* No
* null
*
*
* minIdle
* {@link GenericKeyedObjectPool#setMinIdle(int)}
* No
* 0
*
*
* maxIdle
* {@link GenericKeyedObjectPool#setMaxIdle(int)}
* No
* 8
*
*
* maxActive
* {@link GenericKeyedObjectPool#setMaxActive(int)}
* No
* 8
*
*
* maxTotal
* {@link GenericKeyedObjectPool#setMaxTotal(int)}
* No
* -1
*
*
* maxWait
* {@link GenericKeyedObjectPool#setMaxWait(long)}
* No
* -1L
*
*
* whenExhaustedAction
* {@link GenericKeyedObjectPool#setWhenExhaustedAction(byte)}
* No
* {@link GenericKeyedObjectPool#WHEN_EXHAUSTED_BLOCK}
*
*
* testOnBorrow
* {@link GenericKeyedObjectPool#setTestOnBorrow(boolean)}
* No
* false
*
*
* testOnReturn
* {@link GenericKeyedObjectPool#setTestOnReturn(boolean)}
* No
* false
*
*
* testWhileIdle
* {@link GenericKeyedObjectPool#setTestWhileIdle(boolean)}
* No
* false
*
*
* timeBetweenEvictionRunsMillis
*
* {@link GenericKeyedObjectPool#setTimeBetweenEvictionRunsMillis(long)}
* No
* -1L
*
*
* minEvictableIdleTimeMillis
*
* {@link GenericKeyedObjectPool#setMinEvictableIdleTimeMillis(long)}
* No
* 1000L * 60L * 30L
*
*
* numTestsPerEvictionRun
*
* {@link GenericKeyedObjectPool#setNumTestsPerEvictionRun(int)}
* No
* 3
*
*
* Configuration:
*
*
* @author Eric Dalquist eric.dalquist@doit.wisc.edu
*/
class DirContextPoolableObjectFactory extends BaseKeyedPoolableObjectFactory {
/**
* Logger for this class and subclasses
*/
protected final Log logger = LogFactory.getLog(this.getClass());
private ContextSource contextSource;
private DirContextValidator dirContextValidator;
/**
* @return the contextSource
*/
public ContextSource getContextSource() {
return this.contextSource;
}
/**
* @param contextSource
* the contextSource to set
*/
public void setContextSource(ContextSource contextSource) {
if (contextSource == null) {
throw new IllegalArgumentException("contextSource may not be null");
}
this.contextSource = contextSource;
}
/**
* @return the dirContextValidator
*/
public DirContextValidator getDirContextValidator() {
return this.dirContextValidator;
}
/**
* @param dirContextValidator
* the dirContextValidator to set
*/
public void setDirContextValidator(DirContextValidator dirContextValidator) {
if (dirContextValidator == null) {
throw new IllegalArgumentException(
"dirContextValidator may not be null");
}
this.dirContextValidator = dirContextValidator;
}
/**
* @see org.apache.commons.pool.BaseKeyedPoolableObjectFactory#makeObject(java.lang.Object)
*/
public Object makeObject(Object key) throws Exception {
Validate.notNull(this.contextSource, "ContextSource may not be null");
Validate.isTrue(key instanceof DirContextType,
"key must be a DirContextType");
final DirContextType contextType = (DirContextType) key;
if (this.logger.isDebugEnabled()) {
this.logger.debug("Creating a new " + contextType + " DirContext");
}
if (contextType == DirContextType.READ_WRITE) {
final DirContext readWriteContext = this.contextSource
.getReadWriteContext();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Created new " + DirContextType.READ_WRITE
+ " DirContext='" + readWriteContext + "'");
}
return readWriteContext;
} else if (contextType == DirContextType.READ_ONLY) {
final DirContext readOnlyContext = this.contextSource
.getReadOnlyContext();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Created new " + DirContextType.READ_ONLY
+ " DirContext='" + readOnlyContext + "'");
}
return readOnlyContext;
} else {
throw new IllegalArgumentException("Unrecognized ContextType: "
+ contextType);
}
}
/**
* @see org.apache.commons.pool.BaseKeyedPoolableObjectFactory#validateObject(java.lang.Object,
* java.lang.Object)
*/
public boolean validateObject(Object key, Object obj) {
Validate.notNull(this.dirContextValidator,
"DirContextValidator may not be null");
Validate.isTrue(key instanceof DirContextType,
"key must be a DirContextType");
Validate.isTrue(obj instanceof DirContext,
"The Object to validate must be of type '" + DirContext.class
+ "'");
try {
final DirContextType contextType = (DirContextType) key;
final DirContext dirContext = (DirContext) obj;
return this.dirContextValidator.validateDirContext(contextType,
dirContext);
} catch (Exception e) {
this.logger.warn("Failed to validate '" + obj
+ "' due to an unexpected exception.", e);
return false;
}
}
/**
* @see org.apache.commons.pool.BaseKeyedPoolableObjectFactory#destroyObject(java.lang.Object,
* java.lang.Object)
*/
public void destroyObject(Object key, Object obj) throws Exception {
Validate.isTrue(obj instanceof DirContext,
"The Object to validate must be of type '" + DirContext.class
+ "'");
try {
final DirContext dirContext = (DirContext) obj;
if (this.logger.isDebugEnabled()) {
this.logger.debug("Closing " + key + " DirContext='"
+ dirContext + "'");
}
dirContext.close();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Closed " + key + " DirContext='"
+ dirContext + "'");
}
} catch (Exception e) {
this.logger.warn(
"An exception occured while closing '" + obj + "'", e);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000166 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/validation/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/validation/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000136 11475313376 030211 0 ustar
Connection validation support for the pooling library.
././@LongLink 0000000 0000000 0000000 00000000225 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/validation/DefaultDirContextValidator.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000013654 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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.pool.validation;
import javax.naming.NamingEnumeration;
import javax.naming.directory.DirContext;
import javax.naming.directory.SearchControls;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.pool.DirContextType;
/**
* Default {@link DirContext} validator that executes {@link DirContext#search(String, String, SearchControls)}. The
* name, filter and {@link SearchControls} are all configurable. There is no special handling for read only versus
* read write {@link DirContext}s.
*
*
*
* Property
* Description
* Required
* Default
*
*
* contextSource
* The {@link ContextSource} to get {@link DirContext}s from
* for adding to the pool.
* Yes
* null
*
*
* dirContextValidator
* The {@link DirContextValidator} to use to validate
* {@link DirContext}s. This is only required if the pool has validation of any
* kind turned on.
* No
* null
*
*
* Configuration:
*
*
*
* @author Eric Dalquist
*/
public class DefaultDirContextValidator implements DirContextValidator {
/**
* Logger for this class and sub-classes
*/
protected final Log logger = LogFactory.getLog(this.getClass());
private String base;
private String filter;
private SearchControls searchControls;
/**
* Create the default validator, creates {@link SearchControls} with search scope
*
* Property
* Description
* Required
* Default
*
*
* base
*
* The name parameter to the search method.
*
* No
* ""
*
*
* filter
*
* The filter parameter to the search method.
*
* No
* "objectclass=*"
*
*
* searchControls
*
* The {@link SearchControls} parameter to the search method.
*
* No
*
* {@link SearchControls#setCountLimit(long)} = 1
*
* {@link SearchControls#setReturningAttributes(String[])} = new String[] { "objectclass" }
* {@link SearchControls#setTimeLimit(int)} = 500
* OBJECT_SCOPE,
* a countLimit of 1, returningAttributes of objectclass and timeLimit of 500.
* The default base is an empty string and the default filter is objectclass=*
*/
public DefaultDirContextValidator() {
this(SearchControls.OBJECT_SCOPE);
}
/**
* Create a validator with all the defaults of the default constructor, but with the search scope set to the
* referred value.
*
* @param searchScope The searchScope to be set in the default SearchControls
*/
public DefaultDirContextValidator(int searchScope) {
this.searchControls = new SearchControls();
this.searchControls.setSearchScope(searchScope);
this.searchControls.setCountLimit(1);
this.searchControls.setReturningAttributes(new String[] { "objectclass" });
this.searchControls.setTimeLimit(500);
this.base = "";
this.filter = "objectclass=*";
}
/**
* @return the baseName
*/
public String getBase() {
return this.base;
}
/**
* @param base the baseName to set
*/
public void setBase(String base) {
this.base = base;
}
/**
* @return the filter
*/
public String getFilter() {
return this.filter;
}
/**
* @param filter the filter to set
*/
public void setFilter(String filter) {
if (filter == null) {
throw new IllegalArgumentException("filter may not be null");
}
this.filter = filter;
}
/**
* @return the searchControls
*/
public SearchControls getSearchControls() {
return this.searchControls;
}
/**
* @param searchControls the searchControls to set
*/
public void setSearchControls(SearchControls searchControls) {
if (searchControls == null) {
throw new IllegalArgumentException("searchControls may not be null");
}
this.searchControls = searchControls;
}
/**
* @see DirContextValidator#validateDirContext(DirContextType, javax.naming.directory.DirContext)
*/
public boolean validateDirContext(DirContextType contextType, DirContext dirContext) {
Validate.notNull(contextType, "contextType may not be null");
Validate.notNull(dirContext, "dirContext may not be null");
try {
final NamingEnumeration searchResults = dirContext.search(this.base, this.filter, this.searchControls);
if (searchResults.hasMore()) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("DirContext '" + dirContext + "' passed validation.");
}
return true;
}
}
catch (Exception e) {
this.logger.warn("DirContext '" + dirContext + "' failed validation with an exception.", e);
}
if (this.logger.isInfoEnabled()) {
this.logger.info("DirContext '" + dirContext + "' failed validation.");
}
return false;
}
}
././@LongLink 0000000 0000000 0000000 00000000216 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/validation/DirContextValidator.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003034 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.pool.validation;
import javax.naming.directory.DirContext;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.pool.DirContextType;
/**
* A validator for {@link DirContext}s.
*
* @author Eric Dalquist
*/
public interface DirContextValidator {
/**
* Validates the {@link DirContext}. A valid {@link DirContext} should be able
* to answer queries and if applicable write to the directory.
*
* @param contextType The type of the {@link DirContext}, refers to if {@link ContextSource#getReadOnlyContext()} or {@link ContextSource#getReadWriteContext()} was called to create the {@link DirContext}
* @param dirContext The {@link DirContext} to validate.
* @return true if the {@link DirContext} operated correctly during validation.
*/
boolean validateDirContext(DirContextType contextType, DirContext dirContext);
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/DelegatingLdapContext.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000015361 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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.pool;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.Control;
import javax.naming.ldap.ExtendedRequest;
import javax.naming.ldap.ExtendedResponse;
import javax.naming.ldap.LdapContext;
import org.apache.commons.lang.Validate;
import org.apache.commons.pool.KeyedObjectPool;
import org.springframework.ldap.pool.factory.PoolingContextSource;
/**
* Used by {@link PoolingContextSource} to wrap a {@link LdapContext}, delegating most methods
* to the underlying context. This class extends {@link DelegatingDirContext} which handles returning
* the context to the pool on a call to {@link #close()}
*
* @author Eric Dalquist
*/
public class DelegatingLdapContext extends DelegatingDirContext implements LdapContext {
private LdapContext delegateLdapContext;
/**
* Create a new delegating ldap context for the specified pool, context and context type.
*
* @param keyedObjectPool The pool the delegate context was checked out from.
* @param delegateLdapContext The ldap context to delegate operations to.
* @param dirContextType The type of context, used as a key for the pool.
* @throws IllegalArgumentException if any of the arguments are null
*/
public DelegatingLdapContext(KeyedObjectPool keyedObjectPool, LdapContext delegateLdapContext, DirContextType dirContextType) {
super(keyedObjectPool, delegateLdapContext, dirContextType);
Validate.notNull(delegateLdapContext, "delegateLdapContext may not be null");
this.delegateLdapContext = delegateLdapContext;
}
//***** Helper Methods *****//
/**
* @return The direct delegate for this ldap context proxy
*/
public LdapContext getDelegateLdapContext() {
return this.delegateLdapContext;
}
// cannot return subtype in overridden method unless Java5
public DirContext getDelegateDirContext() {
return this.getDelegateLdapContext();
}
/**
* Recursivley inspect delegates until a non-delegating ldap context is found.
*
* @return The innermost (real) DirContext that is being delegated to.
*/
public LdapContext getInnermostDelegateLdapContext() {
final LdapContext delegateLdapContext = this.getDelegateLdapContext();
if (delegateLdapContext instanceof DelegatingLdapContext) {
return ((DelegatingLdapContext)delegateLdapContext).getInnermostDelegateLdapContext();
}
return delegateLdapContext;
}
protected void assertOpen() throws NamingException {
if (this.delegateLdapContext == null) {
throw new NamingException("LdapContext is closed.");
}
super.assertOpen();
}
//***** Object methods *****//
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof LdapContext)) {
return false;
}
final LdapContext thisLdapContext = this.getInnermostDelegateLdapContext();
LdapContext otherLdapContext = (LdapContext)obj;
if (otherLdapContext instanceof DelegatingLdapContext) {
otherLdapContext = ((DelegatingLdapContext)otherLdapContext).getInnermostDelegateLdapContext();
}
return thisLdapContext == otherLdapContext || (thisLdapContext != null && thisLdapContext.equals(otherLdapContext));
}
/**
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
final LdapContext context = this.getInnermostDelegateLdapContext();
return (context != null ? context.hashCode() : 0);
}
/**
* @see java.lang.Object#toString()
*/
public String toString() {
final LdapContext context = this.getInnermostDelegateLdapContext();
return (context != null ? context.toString() : "LdapContext is closed");
}
//***** LdapContext Interface Delegates *****//
/**
* @see javax.naming.ldap.LdapContext#extendedOperation(javax.naming.ldap.ExtendedRequest)
*/
public ExtendedResponse extendedOperation(ExtendedRequest request) throws NamingException {
this.assertOpen();
return this.getDelegateLdapContext().extendedOperation(request);
}
/**
* @see javax.naming.ldap.LdapContext#getConnectControls()
*/
public Control[] getConnectControls() throws NamingException {
this.assertOpen();
return this.getDelegateLdapContext().getConnectControls();
}
/**
* @see javax.naming.ldap.LdapContext#getRequestControls()
*/
public Control[] getRequestControls() throws NamingException {
this.assertOpen();
return this.getDelegateLdapContext().getRequestControls();
}
/**
* @see javax.naming.ldap.LdapContext#getResponseControls()
*/
public Control[] getResponseControls() throws NamingException {
this.assertOpen();
return this.getDelegateLdapContext().getResponseControls();
}
/**
* @see javax.naming.ldap.LdapContext#newInstance(javax.naming.ldap.Control[])
*/
public LdapContext newInstance(Control[] requestControls) throws NamingException {
throw new UnsupportedOperationException("Cannot call newInstance on a pooled context");
}
/**
* @see javax.naming.ldap.LdapContext#reconnect(javax.naming.ldap.Control[])
*/
public void reconnect(Control[] connCtls) throws NamingException {
throw new UnsupportedOperationException("Cannot call reconnect on a pooled context");
}
/**
* @see javax.naming.ldap.LdapContext#setRequestControls(javax.naming.ldap.Control[])
*/
public void setRequestControls(Control[] requestControls) throws NamingException {
throw new UnsupportedOperationException("Cannot call setRequestControls on a pooled context");
}
/**
* @see DelegatingDirContext#close()
*/
public void close() throws NamingException {
if (this.delegateLdapContext == null) {
return;
}
super.close();
this.delegateLdapContext = null;
}
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/DirContextType.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003046 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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.pool;
import javax.naming.directory.DirContext;
import org.springframework.ldap.core.ContextSource;
/**
* An enum representing the two types of {@link DirContext}s that can be returned by a
* {@link ContextSource}.
*
* @author Eric Dalquist
*/
public final class DirContextType {
private String name;
private DirContextType(String name) {
this.name = name;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
return name;
}
/**
* The type of {@link DirContext} returned by {@link ContextSource#getReadOnlyContext()}
*/
public static final DirContextType READ_ONLY = new DirContextType("READ_ONLY");
/**
* The type of {@link DirContext} returned by {@link ContextSource#getReadWriteContext()}
*/
public static final DirContextType READ_WRITE = new DirContextType("READ_WRITE");
}
././@LongLink 0000000 0000000 0000000 00000000214 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/pool/MutableDelegatingLdapContext.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004340 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.pool;
import javax.naming.NamingException;
import javax.naming.ldap.Control;
import javax.naming.ldap.LdapContext;
import org.apache.commons.pool.KeyedObjectPool;
import org.springframework.ldap.pool.factory.MutablePoolingContextSource;
/**
* Used by {@link MutablePoolingContextSource} to wrap a {@link LdapContext},
* delegating most methods to the underlying context. This class extends
* {@link DelegatingLdapContext}, allowing request controls to be set on the
* wrapped ldap context. This enables the Spring LDAP pooling to be used for
* scenarios such as paged results.
*
* @author Ulrik Sandberg
*/
public class MutableDelegatingLdapContext extends DelegatingLdapContext {
/**
* Create a new mutable delegating ldap context for the specified pool,
* context and context type.
*
* @param keyedObjectPool The pool the delegate context was checked out
* from.
* @param delegateLdapContext The ldap context to delegate operations to.
* @param dirContextType The type of context, used as a key for the pool.
* @throws IllegalArgumentException if any of the arguments are null
*/
public MutableDelegatingLdapContext(KeyedObjectPool keyedObjectPool, LdapContext delegateLdapContext,
DirContextType dirContextType) {
super(keyedObjectPool, delegateLdapContext, dirContextType);
}
/*
* @see
* org.springframework.ldap.pool.DelegatingLdapContext#setRequestControls
* (javax.naming.ldap.Control[])
*/
public void setRequestControls(Control[] requestControls) throws NamingException {
assertOpen();
getDelegateLdapContext().setRequestControls(requestControls);
}
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/CommunicationException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001774 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI CommunicationException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.CommunicationException
*/
public class CommunicationException extends NamingException {
public CommunicationException(javax.naming.CommunicationException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000235 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/TempEntryRenamingStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002415 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
import javax.naming.Name;
/**
* Interface for different strategies to rename temporary entries for unbind and
* rebind operations.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface TempEntryRenamingStrategy {
/**
* Get a temporary name for the current entry to be renamed to.
*
* @param originalName
* The original name of the entry.
* @return The name to which the entry should be temporarily renamed
* according to this strategy.
*/
Name getTemporaryName(Name originalName);
}
././@LongLink 0000000 0000000 0000000 00000000233 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/RenameOperationExecutor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006456 11475313376 030224 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
import javax.naming.Name;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.LdapOperations;
import org.springframework.transaction.compensating.CompensatingTransactionOperationExecutor;
/**
* A {@link CompensatingTransactionOperationExecutor} to manage a rename
* operation. Performs a rename operation in {@link #performOperation()}, a
* negating rename in {@link #rollback()}, and nothing in {@link #commit()}.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class RenameOperationExecutor implements
CompensatingTransactionOperationExecutor {
private static Log log = LogFactory.getLog(RenameOperationExecutor.class);
private LdapOperations ldapOperations;
private Name newDn;
private Name originalDn;
/**
* Constructor.
*
* @param ldapOperations
* The {@link LdapOperations} to use for performing the rollback
* operation.
* @param originalDn
* DN that the entry was moved from in the recorded operation.
* @param newDn
* DN that the entry has been moved to in the recorded operation.
*/
public RenameOperationExecutor(LdapOperations ldapOperations,
Name originalDn, Name newDn) {
this.ldapOperations = ldapOperations;
this.originalDn = originalDn;
this.newDn = newDn;
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback()
*/
public void rollback() {
log.debug("Rolling back rename operation");
try {
ldapOperations.rename(newDn, originalDn);
} catch (Exception e) {
log.warn("Unable to rollback rename operation. " + "originalDn: "
+ newDn + "; newDn: " + originalDn);
}
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
*/
public void commit() {
log.debug("Nothing to do in commit for rename operation");
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#performOperation()
*/
public void performOperation() {
log.debug("Performing rename operation");
ldapOperations.rename(originalDn, newDn);
}
Name getNewDn() {
return newDn;
}
LdapOperations getLdapOperations() {
return ldapOperations;
}
Name getOriginalDn() {
return originalDn;
}
}
././@LongLink 0000000 0000000 0000000 00000000233 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/RebindOperationRecorder.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006554 11475313376 030223 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
import javax.naming.Name;
import javax.naming.directory.Attributes;
import org.springframework.ldap.core.LdapOperations;
import org.springframework.transaction.compensating.CompensatingTransactionOperationExecutor;
import org.springframework.transaction.compensating.CompensatingTransactionOperationRecorder;
/**
* A {@link CompensatingTransactionOperationRecorder} keeping track of a rebind
* operation. Creates {@link RebindOperationExecutor} objects in
* {@link #recordOperation(Object[])}.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class RebindOperationRecorder implements
CompensatingTransactionOperationRecorder {
private LdapOperations ldapOperations;
private TempEntryRenamingStrategy renamingStrategy;
/**
* Constructor.
*
* @param ldapOperations
* {@link LdapOperations} to use for getting the rollback
* information and supply to the {@link RebindOperationExecutor}.
* @param renamingStrategy
* {@link TempEntryRenamingStrategy} to use for generating temp
* DNs.
*/
public RebindOperationRecorder(LdapOperations ldapOperations,
TempEntryRenamingStrategy renamingStrategy) {
this.ldapOperations = ldapOperations;
this.renamingStrategy = renamingStrategy;
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
*/
public CompensatingTransactionOperationExecutor recordOperation(
Object[] args) {
if (args == null || args.length != 3) {
throw new IllegalArgumentException(
"Invalid arguments for bind operation");
}
Name dn = LdapTransactionUtils.getFirstArgumentAsName(args);
Object object = args[1];
Attributes attributes = null;
if (args[2] != null && !(args[2] instanceof Attributes)) {
throw new IllegalArgumentException(
"Invalid third argument to bind operation");
} else if (args[2] != null) {
attributes = (Attributes) args[2];
}
Name temporaryName = renamingStrategy.getTemporaryName(dn);
return new RebindOperationExecutor(ldapOperations, dn, temporaryName,
object, attributes);
}
/**
* Get the LdapOperations. For testing purposes.
*
* @return the LdapOperations.
*/
LdapOperations getLdapOperations() {
return ldapOperations;
}
public TempEntryRenamingStrategy getRenamingStrategy() {
return renamingStrategy;
}
}
././@LongLink 0000000 0000000 0000000 00000000231 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/BindOperationRecorder.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000005502 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
import javax.naming.Name;
import javax.naming.directory.Attributes;
import org.springframework.ldap.core.LdapOperations;
import org.springframework.transaction.compensating.CompensatingTransactionOperationExecutor;
import org.springframework.transaction.compensating.CompensatingTransactionOperationRecorder;
/**
* A {@link CompensatingTransactionOperationRecorder} keeping track of bind
* operations. Creates {@link BindOperationExecutor} objects in
* {@link #recordOperation(Object[])}.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class BindOperationRecorder implements
CompensatingTransactionOperationRecorder {
private LdapOperations ldapOperations;
/**
* Constructor.
*
* @param ldapOperations
* {@link LdapOperations} to use for supplying to the
* corresponding rollback operation.
*/
public BindOperationRecorder(LdapOperations ldapOperations) {
this.ldapOperations = ldapOperations;
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
*/
public CompensatingTransactionOperationExecutor recordOperation(
Object[] args) {
if (args == null || args.length != 3) {
throw new IllegalArgumentException(
"Invalid arguments for bind operation");
}
Name dn = LdapTransactionUtils.getFirstArgumentAsName(args);
Object object = args[1];
Attributes attributes = null;
if (args[2] != null && !(args[2] instanceof Attributes)) {
throw new IllegalArgumentException(
"Invalid third argument to bind operation");
} else if (args[2] != null) {
attributes = (Attributes) args[2];
}
return new BindOperationExecutor(ldapOperations, dn, object, attributes);
}
/**
* Get the LdapOperations. For testing purposes.s
*
* @return the LdapOperations.
*/
LdapOperations getLdapOperations() {
return ldapOperations;
}
}
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/support/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000223 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/support/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000165 11475313376 030213 0 ustar
Useful helper implementations for client side Compensating LDAP Transactions.
././@LongLink 0000000 0000000 0000000 00000000265 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/support/DifferentSubtreeTempEntryRenamingStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006335 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import java.util.List;
import javax.naming.Name;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapRdn;
import org.springframework.ldap.core.LdapRdnComponent;
import org.springframework.ldap.transaction.compensating.TempEntryRenamingStrategy;
/**
* A {@link TempEntryRenamingStrategy} that moves the entry to a different
* subtree than the original entry. The specified subtree needs to be present in
* the LDAP tree; it will not be created and operations using this strategy will
* fail if the destination is not in place. However, this strategy is preferable
* to {@link DefaultTempEntryRenamingStrategy}, as it makes searches have the
* expected result even though the temporary entry still exists during the
* transaction.
* subtreeNode is
* ou=tempEntries and the originalName is
* cn=john doe, ou=company1, c=SE, the result of
* {@link #getTemporaryName(Name)} will be
* cn=john doe1, ou=tempEntries. The "1" suffix is a
* sequence number needed to prevent potential collisions in the temporary
* storage.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class DifferentSubtreeTempEntryRenamingStrategy implements
TempEntryRenamingStrategy {
private Name subtreeNode;
private static int nextSequenceNo = 1;
public DifferentSubtreeTempEntryRenamingStrategy(Name subtreeNode) {
this.subtreeNode = subtreeNode;
}
public Name getSubtreeNode() {
return subtreeNode;
}
public void setSubtreeNode(Name subtreeNode) {
this.subtreeNode = subtreeNode;
}
int getNextSequenceNo() {
return nextSequenceNo;
}
/*
* @see org.springframework.ldap.support.transaction.TempEntryRenamingStrategy#getTemporaryName(javax.naming.Name)
*/
public Name getTemporaryName(Name originalName) {
DistinguishedName tempName = new DistinguishedName(originalName);
List names = tempName.getNames();
LdapRdn rdn = (LdapRdn) names.get(names.size() - 1);
LdapRdnComponent component = rdn.getComponent();
LdapRdn newRdn;
synchronized (this) {
newRdn = new LdapRdn(component.getKey(), component.getValue()
+ nextSequenceNo++);
}
DistinguishedName newName = new DistinguishedName(subtreeNode);
newName.add(newRdn);
return newName;
}
}
././@LongLink 0000000 0000000 0000000 00000000254 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/support/DefaultTempEntryRenamingStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006032 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import java.util.List;
import javax.naming.Name;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.core.LdapRdn;
import org.springframework.ldap.core.LdapRdnComponent;
import org.springframework.ldap.transaction.compensating.TempEntryRenamingStrategy;
/**
* Default implementation of {@link TempEntryRenamingStrategy}. This
* implementation simply adds "_temp" to the leftmost (least significant part)
* of the name. For example:
*
*
* cn=john doe, ou=company1, c=SE
*
*
* becomes:
*
*
* cn=john doe_temp, ou=company1, c=SE
*
* true if this is a supported transaction operation,
* false otherwise.
*/
public static boolean isSupportedWriteTransactionOperation(String methodName) {
return (StringUtils.equals(methodName, BIND_METHOD_NAME)
|| StringUtils.equals(methodName, REBIND_METHOD_NAME)
|| StringUtils.equals(methodName, RENAME_METHOD_NAME)
|| StringUtils
.equals(methodName, MODIFY_ATTRIBUTES_METHOD_NAME) || StringUtils
.equals(methodName, UNBIND_METHOD_NAME));
}
}
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000263 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/ContextSourceTransactionManagerDelegate.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000012244 11475313376 030214 0 ustar /*
* Copyright 2002-2007 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.transaction.compensating.manager;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.transaction.compensating.LdapCompensatingTransactionOperationFactory;
import org.springframework.ldap.transaction.compensating.TempEntryRenamingStrategy;
import org.springframework.ldap.transaction.compensating.support.DefaultTempEntryRenamingStrategy;
import org.springframework.transaction.compensating.support.AbstractCompensatingTransactionManagerDelegate;
import org.springframework.transaction.compensating.support.CompensatingTransactionHolderSupport;
import org.springframework.transaction.compensating.support.DefaultCompensatingTransactionOperationManager;
/**
* This delegate performs all the work for the
* {@link ContextSourceTransactionManager}. The work is delegated in order to
* be able to perform the exact same work for the LDAP part in
* {@link ContextSourceAndDataSourceTransactionManager}.
*
* @author Mattias Hellborg Arthursson
* @see ContextSourceTransactionManager
* @see ContextSourceAndDataSourceTransactionManager
* @since 1.2
*/
public class ContextSourceTransactionManagerDelegate extends
AbstractCompensatingTransactionManagerDelegate {
private static final Log log = LogFactory
.getLog(ContextSourceTransactionManagerDelegate.class);
private ContextSource contextSource;
private TempEntryRenamingStrategy renamingStrategy = new DefaultTempEntryRenamingStrategy();
/**
* Set the ContextSource to work on. Even though the actual ContextSource
* sent to the LdapTemplate instance should be a
* {@link TransactionAwareContextSourceProxy}, the one sent to this method
* should be the target of that proxy. If it is not, the target will be
* extracted and used instead.
*
* @param contextSource
* the ContextSource to work on.
*/
public void setContextSource(ContextSource contextSource) {
if (contextSource instanceof TransactionAwareContextSourceProxy) {
TransactionAwareContextSourceProxy proxy = (TransactionAwareContextSourceProxy) contextSource;
this.contextSource = proxy.getTarget();
} else {
this.contextSource = contextSource;
}
}
public ContextSource getContextSource() {
return contextSource;
}
/*
* @see org.springframework.transaction.compensating.support.AbstractCompensatingTransactionManagerDelegate#getTransactionSynchronizationKey()
*/
protected Object getTransactionSynchronizationKey() {
return getContextSource();
}
/*
* @see org.springframework.transaction.compensating.support.AbstractCompensatingTransactionManagerDelegate#getNewHolder()
*/
protected CompensatingTransactionHolderSupport getNewHolder() {
DirContext newCtx = getContextSource().getReadWriteContext();
DirContextHolder contextHolder = new DirContextHolder(
new DefaultCompensatingTransactionOperationManager(
new LdapCompensatingTransactionOperationFactory(
renamingStrategy)), newCtx);
return contextHolder;
}
/*
* @see org.springframework.transaction.compensating.support.AbstractCompensatingTransactionManagerDelegate#closeTargetResource(org.springframework.transaction.compensating.support.CompensatingTransactionHolderSupport)
*/
protected void closeTargetResource(
CompensatingTransactionHolderSupport transactionHolderSupport) {
DirContextHolder contextHolder = (DirContextHolder) transactionHolderSupport;
DirContext ctx = contextHolder.getCtx();
try {
log.debug("Closing target context");
ctx.close();
} catch (NamingException e) {
log.warn("Failed to close target context", e);
}
}
/**
* Set the {@link TempEntryRenamingStrategy} to be used when renaming
* temporary entries in unbind and rebind operations. Default value is a
* {@link DefaultTempEntryRenamingStrategy}.
*
* @param renamingStrategy
* the {@link TempEntryRenamingStrategy} to use.
*/
public void setRenamingStrategy(TempEntryRenamingStrategy renamingStrategy) {
this.renamingStrategy = renamingStrategy;
}
}
././@LongLink 0000000 0000000 0000000 00000000234 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/DirContextHolder.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004677 11475313376 030227 0 ustar /*
* Copyright 2002-2007 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.transaction.compensating.manager;
import javax.naming.directory.DirContext;
import org.springframework.transaction.compensating.CompensatingTransactionOperationManager;
import org.springframework.transaction.compensating.support.CompensatingTransactionHolderSupport;
/**
* Keeps track of the transaction DirContext. The same DirContext instance will
* be reused throughout a transaction. Also keeps a
* {@link CompensatingTransactionOperationManager}, responsible for performing
* operations and keeping track of all changes and storing information necessary
* for commit or rollback.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class DirContextHolder extends CompensatingTransactionHolderSupport {
private DirContext ctx;
/**
* Constructor.
*
* @param manager
* The {@link CompensatingTransactionOperationManager}.
* @param ctx
* The DirContext associated with the current transaction.
*/
public DirContextHolder(CompensatingTransactionOperationManager manager,
DirContext ctx) {
super(manager);
this.ctx = ctx;
}
/**
* Set the DirContext associated with the current transaction.
*
* @param ctx
* The DirContext associated with the current transaction.
*/
public void setCtx(DirContext ctx) {
this.ctx = ctx;
}
/**
* Return the DirContext associated with the current transaction.
*/
public DirContext getCtx() {
return ctx;
}
/*
* @see org.springframework.transaction.compensating.support.CompensatingTransactionHolderSupport#getTransactedResource()
*/
protected Object getTransactedResource() {
return ctx;
}
}
././@LongLink 0000000 0000000 0000000 00000000223 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000152 11475313376 030207 0 ustar
The core implementation classes for client-side LDAP transactions.
././@LongLink 0000000 0000000 0000000 00000000267 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/ContextSourceAndHibernateTransactionManager.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000022004 11475313376 030207 0 ustar /*
* Copyright 2002-2008 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.transaction.compensating.manager;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.transaction.compensating.TempEntryRenamingStrategy;
import org.springframework.ldap.transaction.compensating.manager.ContextSourceTransactionManagerDelegate;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionSuspensionNotSupportedException;
import org.springframework.transaction.support.DefaultTransactionStatus;
/**
* A Transaction Manager to manage LDAP and Hibernate 3 operations within the same
* transaction. Note that even though the same logical transaction is used, this
* is not a JTA XA transaction; no two-phase commit will be performed,
* and thus commit and rollback may yield unexpected results.
* This Transaction Manager is as good as it gets when you are using in LDAP in
* combination with a Hibernate 3 and unable to use XA transactions because LDAP
* is not transactional by design to begin with.
*
* Furthermore, this manager does not support nested transactions
* @author Hans Westerbeek
* @since 1.2.2
*/
public class ContextSourceAndHibernateTransactionManager extends HibernateTransactionManager {
/**
*
*/
private static final long serialVersionUID = 1L;
private ContextSourceTransactionManagerDelegate ldapManagerDelegate = new ContextSourceTransactionManagerDelegate();
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#isExistingTransaction(java.lang.Object)
*/
protected boolean isExistingTransaction(Object transaction) {
ContextSourceAndHibernateTransactionObject actualTransactionObject = (ContextSourceAndHibernateTransactionObject) transaction;
return super.isExistingTransaction(actualTransactionObject
.getHibernateTransactionObject());
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doGetTransaction()
*/
protected Object doGetTransaction() throws TransactionException {
Object dataSourceTransactionObject = super.doGetTransaction();
Object contextSourceTransactionObject = ldapManagerDelegate
.doGetTransaction();
return new ContextSourceAndHibernateTransactionObject(
contextSourceTransactionObject, dataSourceTransactionObject);
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doBegin(java.lang.Object,
* org.springframework.transaction.TransactionDefinition)
*/
protected void doBegin(Object transaction, TransactionDefinition definition)
throws TransactionException {
ContextSourceAndHibernateTransactionObject actualTransactionObject = (ContextSourceAndHibernateTransactionObject) transaction;
super.doBegin(actualTransactionObject.getHibernateTransactionObject(),
definition);
ldapManagerDelegate.doBegin(actualTransactionObject
.getLdapTransactionObject(), definition);
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doCleanupAfterCompletion(java.lang.Object)
*/
protected void doCleanupAfterCompletion(Object transaction) {
ContextSourceAndHibernateTransactionObject actualTransactionObject = (ContextSourceAndHibernateTransactionObject) transaction;
super.doCleanupAfterCompletion(actualTransactionObject
.getHibernateTransactionObject());
ldapManagerDelegate.doCleanupAfterCompletion(actualTransactionObject
.getLdapTransactionObject());
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus)
*/
protected void doCommit(DefaultTransactionStatus status)
throws TransactionException {
ContextSourceAndHibernateTransactionObject actualTransactionObject = (ContextSourceAndHibernateTransactionObject) status
.getTransaction();
try {
super.doCommit(new DefaultTransactionStatus(actualTransactionObject
.getHibernateTransactionObject(), status
.isNewTransaction(), status.isNewSynchronization(), status
.isReadOnly(), status.isDebug(), status
.getSuspendedResources()));
} catch (TransactionException ex) {
if (isRollbackOnCommitFailure()) {
logger.debug("Failed to commit db resource, rethrowing", ex);
// If we are to rollback on commit failure, just rethrow the
// exception - this will cause a rollback to be performed on
// both resources.
throw ex;
} else {
logger
.warn("Failed to commit and resource is rollbackOnCommit not set -"
+ " proceeding to commit ldap resource.");
}
}
ldapManagerDelegate.doCommit(new DefaultTransactionStatus(
actualTransactionObject.getLdapTransactionObject(), status
.isNewTransaction(), status.isNewSynchronization(),
status.isReadOnly(), status.isDebug(), status
.getSuspendedResources()));
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus)
*/
protected void doRollback(DefaultTransactionStatus status)
throws TransactionException {
ContextSourceAndHibernateTransactionObject actualTransactionObject = (ContextSourceAndHibernateTransactionObject) status
.getTransaction();
super.doRollback(new DefaultTransactionStatus(actualTransactionObject
.getHibernateTransactionObject(), status.isNewTransaction(),
status.isNewSynchronization(), status.isReadOnly(), status
.isDebug(), status.getSuspendedResources()));
ldapManagerDelegate.doRollback(new DefaultTransactionStatus(
actualTransactionObject.getLdapTransactionObject(), status
.isNewTransaction(), status.isNewSynchronization(),
status.isReadOnly(), status.isDebug(), status
.getSuspendedResources()));
}
public ContextSource getContextSource() {
return ldapManagerDelegate.getContextSource();
}
public void setContextSource(ContextSource contextSource) {
ldapManagerDelegate.setContextSource(contextSource);
}
protected void setRenamingStrategy(
TempEntryRenamingStrategy renamingStrategy) {
ldapManagerDelegate.setRenamingStrategy(renamingStrategy);
}
private final static class ContextSourceAndHibernateTransactionObject {
private Object ldapTransactionObject;
private Object hibernateTransactionObject;
public ContextSourceAndHibernateTransactionObject(
Object ldapTransactionObject, Object hibernateTransactionObject) {
this.ldapTransactionObject = ldapTransactionObject;
this.hibernateTransactionObject = hibernateTransactionObject;
}
public Object getHibernateTransactionObject() {
return hibernateTransactionObject;
}
public Object getLdapTransactionObject() {
return ldapTransactionObject;
}
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doSuspend(java.lang.Object)
*/
protected Object doSuspend(Object transaction) throws TransactionException {
throw new TransactionSuspensionNotSupportedException(
"Transaction manager [" + getClass().getName()
+ "] does not support transaction suspension");
}
/*
* @see org.springframework.orm.hibernate3.HibernateTransactionManager#doResume(java.lang.Object,
* java.lang.Object)
*/
protected void doResume(Object transaction, Object suspendedResources)
throws TransactionException {
throw new TransactionSuspensionNotSupportedException(
"Transaction manager [" + getClass().getName()
+ "] does not support transaction suspension");
}
}
././@LongLink 0000000 0000000 0000000 00000000253 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/transaction/compensating/manager/ContextSourceTransactionManager.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000021415 11475313376 030214 0 ustar /*
* Copyright 2002-2007 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.transaction.compensating.manager;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.transaction.compensating.TempEntryRenamingStrategy;
import org.springframework.ldap.transaction.compensating.UnbindOperationExecutor;
import org.springframework.ldap.transaction.compensating.support.DefaultTempEntryRenamingStrategy;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.compensating.CompensatingTransactionOperationExecutor;
import org.springframework.transaction.compensating.CompensatingTransactionOperationRecorder;
import org.springframework.transaction.compensating.support.DefaultCompensatingTransactionOperationManager;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;
import org.springframework.transaction.support.DefaultTransactionStatus;
/**
* TransactionManager for managing LDAP transactions. Since transactions are not
* supported in the LDAP protocol, this class and its collaborators aim to
* provide compensating transactions instead. Should a transaction
* need to be rolled back, this TransactionManager will try to restore the
* original state using information recorded prior to each operation. The
* operation where the original state is restored is called a compensating
* operation.
*
*
* modifyAttributes operation. Performs a
* modifyAttributes in {@link #performOperation()}, a negating
* modifyAttributes in {@link #rollback()}, and nothing in {@link #commit()}.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class ModifyAttributesOperationExecutor implements
CompensatingTransactionOperationExecutor {
private static Log log = LogFactory
.getLog(ModifyAttributesOperationExecutor.class);
private LdapOperations ldapOperations;
private Name dn;
private ModificationItem[] compensatingModifications;
private ModificationItem[] actualModifications;
/**
* Constructor.
*
* @param ldapOperations
* The {@link LdapOperations} to use to perform the rollback
* operation.
* @param dn
* the DN of the target entry.
* @param actualModifications
* the actual modificationItems that were sent to the
* modifyAttributes operation.
* @param compensatingModifications
* the ModificationItems to undo the recorded operation.
*/
public ModifyAttributesOperationExecutor(LdapOperations ldapOperations,
Name dn, ModificationItem[] actualModifications,
ModificationItem[] compensatingModifications) {
this.ldapOperations = ldapOperations;
this.dn = dn;
this.actualModifications = (ModificationItem[]) actualModifications.clone();
this.compensatingModifications = (ModificationItem[]) compensatingModifications.clone();
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback()
*/
public void rollback() {
try {
log.debug("Rolling back modifyAttributes operation");
ldapOperations.modifyAttributes(dn, compensatingModifications);
} catch (Exception e) {
log
.warn("Failed to rollback ModifyAttributes operation, dn: "
+ dn);
}
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
*/
public void commit() {
log.debug("Nothing to do in commit for modifyAttributes");
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#performOperation()
*/
public void performOperation() {
log.debug("Performing modifyAttributes operation");
ldapOperations.modifyAttributes(dn, actualModifications);
}
Name getDn() {
return dn;
}
LdapOperations getLdapOperations() {
return ldapOperations;
}
ModificationItem[] getActualModifications() {
return actualModifications;
}
ModificationItem[] getCompensatingModifications() {
return compensatingModifications;
}
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NoSuchAttributeException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002133 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NoSuchAttributeException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.NoSuchAttributeException
*/
public class NoSuchAttributeException extends NamingException {
public NoSuchAttributeException(String message) {
super(message);
}
public NoSuchAttributeException(javax.naming.directory.NoSuchAttributeException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidSearchFilterException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002074 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidSearchFilterException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.InvalidSearchFilterException
*/
public class InvalidSearchFilterException extends NamingException {
public InvalidSearchFilterException(
javax.naming.directory.InvalidSearchFilterException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/TimeLimitExceededException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002045 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI TimeLimitExceededException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.TimeLimitExceededException
*/
public class TimeLimitExceededException extends LimitExceededException {
public TimeLimitExceededException(
javax.naming.TimeLimitExceededException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DistinguishedName.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000056413 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import javax.naming.CompositeName;
import javax.naming.InvalidNameException;
import javax.naming.Name;
import javax.naming.ldap.Rdn;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.BadLdapGrammarException;
import org.springframework.ldap.support.LdapUtils;
import org.springframework.ldap.support.ListComparator;
import org.springframework.util.Assert;
/**
* Default implementation of a {@link Name} corresponding to an LDAP path. A
* Distinguished Name manipulation implementation is included in JDK1.5
* (LdapName), but not in prior releases.
*
* A DistinguishedName is particularly useful when building or
* modifying an LDAP path dynamically, as escaping will be taken care of.
*
* A path is split into several names. The {@link Name} interface specifies that
* the most significant part be in position 0.
*
*
*
* Name instances, and consequently DistinguishedName
* instances are naturally mutable, which is useful when constructing
* DistinguishedNames. Example:
*
*
* DistinguishedName path = new DistinguishedName("dc=jayway,dc=se");
* path.add("ou", "People");
* path.add("uid", "adam.skogman");
* String dn = path.toString();
*
*
* will render uid=adam.skogman,ou=People,dc=jayway,dc=se.
*
*
* NOTE: The fact that DistinguishedName instances are mutable needs to
* be taken into careful account, as this means that they may be modified
* involuntarily. This means that whenever a DistinguishedName
* instance is kept for reference (e.g. for identification of a domain entry) or
* as a constant, you should consider getting an immutable copy of the instance
* using {@link #immutableDistinguishedName()} or
* {@link #immutableDistinguishedName(String)}.
*
* NB:As of version 1.3 the default toString representation of
* DistinguishedName now defaults to a compact one, without spaces between the
* respective RDNs. For backward compatibility, set the
* {@link #SPACED_DN_FORMAT_PROPERTY} ({@value #SPACED_DN_FORMAT_PROPERTY}) to
* true.
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class DistinguishedName implements Name {
/**
* System property that will be inspected to determine whether
* {@link #toString()} will format the DN with spaces after each comma or
* use a more compact representation, i.e.:
* uid=adam.skogman, ou=People, dc=jayway, dc=se rather than
* uid=adam.skogman,ou=People,dc=jayway,dc=se. A value other
* than null or blank will trigger the spaced format. Default is the compact
* representation.
*
* Valid values are: *
-
*
- blank or null (property not set) *
- any non-blank value *
* Valid values are: *
-
*
- "lower" or blank or null (property not set) *
- "upper" *
- "none" *
DistinguishedName from a String.
*
* @param path a String corresponding to a (syntactically) valid LDAP path.
*/
public DistinguishedName(String path) {
if (StringUtils.isBlank(path)) {
names = new LinkedList();
}
else {
parse(path);
}
}
/**
* Construct a new DistinguishedName from the supplied
* List of {@link LdapRdn} objects.
*
* @param list the components that this instance will consist of.
*/
public DistinguishedName(List list) {
this.names = list;
}
/**
* Construct a new DistinguishedName from the supplied
* {@link Name}. The parts of the supplied {@link Name} must be
* syntactically correct {@link LdapRdn}s.
*
* @param name the {@link Name} to construct a new
* DistinguishedName from.
*/
public DistinguishedName(Name name) {
Assert.notNull(name, "name cannot be null");
if (name instanceof CompositeName) {
parse(LdapUtils.convertCompositeNameToString((CompositeName) name));
return;
}
names = new LinkedList();
for (int i = 0; i < name.size(); i++) {
names.add(new LdapRdn(name.get(i)));
}
}
/**
* Parse the supplied String and make this instance represent the
* corresponding distinguished name.
*
* @param path the LDAP path to parse.
*/
protected void parse(String path) {
DnParser parser = DefaultDnParserFactory.createDnParser(unmangleCompositeName(path));
DistinguishedName dn;
try {
dn = parser.dn();
}
catch (ParseException e) {
throw new BadLdapGrammarException("Failed to parse DN", e);
}
catch (TokenMgrError e) {
throw new BadLdapGrammarException("Failed to parse DN", e);
}
this.names = dn.names;
}
/**
* If path is surrounded by quotes, strip them. JNDI considers forward slash
* ('/') special, but LDAP doesn't. {@link CompositeName#toString()} tends
* to mangle a {@link Name} with a slash by surrounding it with quotes
* ('"').
*
* @param path Path to check and possibly strip.
* @return A String with the possibly stripped path.
*/
private String unmangleCompositeName(String path) {
String tempPath;
// Check if CompositeName has mangled the name with quotes
if (path.startsWith("\"") && path.endsWith("\"")) {
tempPath = path.substring(1, path.length() - 1);
}
else {
tempPath = path;
}
return tempPath;
}
/**
* Get the {@link LdapRdn} at a specified position.
*
* @param index the {@link LdapRdn} to retrieve.
* @return the {@link LdapRdn} at the requested position.
*/
public LdapRdn getLdapRdn(int index) {
return (LdapRdn) names.get(index);
}
/**
* Get the {@link LdapRdn} with the specified key. If there are several
* {@link Rdn}s with the same key, the first one found (in order of
* significance) will be returned.
*
* @param key Attribute name of the {@link LdapRdn} to retrieve.
* @return the {@link LdapRdn} with the requested key.
* @throws IllegalArgumentException if no Rdn matches the given key.
*/
public LdapRdn getLdapRdn(String key) {
for (Iterator iter = names.iterator(); iter.hasNext();) {
LdapRdn rdn = (LdapRdn) iter.next();
if (StringUtils.equals(rdn.getKey(), key)) {
return rdn;
}
}
throw new IllegalArgumentException("No Rdn with the requested key: '" + key + "'");
}
/**
* Get the value of the {@link LdapRdnComponent} with the specified key
* (Attribute value). If there are several Rdns with the same key, the value
* of the first one found (in order of significance) will be returned.
*
* @param key Attribute name of the {@link LdapRdn} to retrieve.
* @return the value.
* @throws IllegalArgumentException if no Rdn matches the given key.
*/
public String getValue(String key) {
return getLdapRdn(key).getValue();
}
/**
* Get the name List.
*
* @return the list of {@link LdapRdn}s that this
* DistinguishedName consists of.
*/
public List getNames() {
return names;
}
/**
* Get the String representation of this DistinguishedName.
* Depending on the setting of property
* org.springframework.ldap.core.spacedDnFormat a space will be
* added after each comma, to make the result more readable. Default is
* compact representation, i.e. without any spaces.
*
* @return a syntactically correct, properly escaped String representation
* of the DistinguishedName.
* @see #SPACED_DN_FORMAT_PROPERTY
*/
public String toString() {
String spacedFormatting = System.getProperty(SPACED_DN_FORMAT_PROPERTY);
if (StringUtils.isBlank(spacedFormatting)) {
return format(COMPACT);
}
else {
return format(NON_COMPACT);
}
}
/**
* Get the compact String representation of this
* DistinguishedName. Add no space after each comma, to make it
* compact.
*
* @return a syntactically correct, properly escaped String representation
* of the DistinguishedName.
*/
public String toCompactString() {
return format(COMPACT);
}
/**
* Builds a complete LDAP path, ldap encoded, useful as a DN.
*
* Always uses lowercase, always separates with ", " i.e. comma and a space.
*
* @return the LDAP path.
*/
public String encode() {
return format(NON_COMPACT);
}
private String format(boolean compact) {
// empty path
if (names.size() == 0)
return "";
StringBuffer buffer = new StringBuffer(256);
ListIterator i = names.listIterator(names.size());
while (i.hasPrevious()) {
LdapRdn rdn = (LdapRdn) i.previous();
buffer.append(rdn.getLdapEncoded());
// add comma, except in last iteration
if (i.hasPrevious()) {
if (compact) {
buffer.append(",");
}
else {
buffer.append(", ");
}
}
}
return buffer.toString();
}
/**
* Builds a complete LDAP path, ldap and url encoded. Separates only with
* ",".
*
* @return the LDAP path, for use in an url.
*/
public String toUrl() {
StringBuffer buffer = new StringBuffer(256);
for (int i = names.size() - 1; i >= 0; i--) {
LdapRdn n = (LdapRdn) names.get(i);
buffer.append(n.encodeUrl());
if (i > 0) {
buffer.append(",");
}
}
return buffer.toString();
}
/**
* Determines if this DistinguishedName path contains another
* path.
*
* @param path the path to check.
* @return true if the supplied path is conained in this
* instance, false otherwise.
*/
public boolean contains(DistinguishedName path) {
List shortlist = path.getNames();
// this path must be at least as long
if (getNames().size() < shortlist.size())
return false;
// must have names
if (shortlist.size() == 0)
return false;
Iterator longiter = getNames().iterator();
Iterator shortiter = shortlist.iterator();
LdapRdn longname = (LdapRdn) longiter.next();
LdapRdn shortname = (LdapRdn) shortiter.next();
// find first match
while (!longname.equals(shortname) && longiter.hasNext()) {
longname = (LdapRdn) longiter.next();
}
// Done?
if (!shortiter.hasNext() && longname.equals(shortname))
return true;
if (!longiter.hasNext())
return false;
// compare
while (longname.equals(shortname) && longiter.hasNext() && shortiter.hasNext()) {
longname = (LdapRdn) longiter.next();
shortname = (LdapRdn) shortiter.next();
}
// Done
if (!shortiter.hasNext() && longname.equals(shortname))
return true;
else
return false;
}
/**
* Add an LDAP path last in this DistinguishedName. E.g.:
*
*
* DistinguishedName name1 = new DistinguishedName("c=SE, dc=jayway, dc=se");
* DistinguishedName name2 = new DistinguishedName("ou=people");
* name1.append(name2);
*
*
* will result in ou=people, c=SE, dc=jayway, dc=se
*
* @param path the path to append.
* @return this instance.
*/
public DistinguishedName append(DistinguishedName path) {
getNames().addAll(path.getNames());
return this;
}
/**
* Append a new {@link LdapRdn} using the supplied key and value.
*
* @param key the key of the {@link LdapRdn}.
* @param value the value of the {@link LdapRdn}.
* @return this instance.
*/
public DistinguishedName append(String key, String value) {
add(key, value);
return this;
}
/**
* Add an LDAP path first in this DistinguishedName. E.g.:
*
*
* DistinguishedName name1 = new DistinguishedName("ou=people");
* DistinguishedName name2 = new DistinguishedName("c=SE, dc=jayway, dc=se");
* name1.prepend(name2);
*
*
* will result in ou=people, c=SE, dc=jayway, dc=se
*
* @param path the path to prepend.
*/
public void prepend(DistinguishedName path) {
ListIterator i = path.getNames().listIterator(path.getNames().size());
while (i.hasPrevious()) {
names.add(0, i.previous());
}
}
/**
* Remove the first part of this DistinguishedName.
*
* @return the removed entry.
*/
public LdapRdn removeFirst() {
return (LdapRdn) names.remove(0);
}
/**
* Remove the supplied path from the beginning of this
* DistinguishedName if this instance starts with
* path. Useful for stripping base path suffix from a
* DistinguishedName.
*
* @param path the path to remove from the beginning of this instance.
*/
public void removeFirst(Name path) {
if (path != null && this.startsWith(path)) {
for (int i = 0; i < path.size(); i++)
this.removeFirst();
}
}
/**
* @see java.lang.Object#clone()
*/
public Object clone() {
try {
DistinguishedName result = (DistinguishedName) super.clone();
result.names = new LinkedList(names);
return result;
}
catch (CloneNotSupportedException e) {
log.fatal("CloneNotSupported thrown from superclass - this should not happen");
throw new RuntimeException("Fatal error in clone", e);
}
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
// A subclass with identical values should NOT be considered equal.
// EqualsBuilder in commons-lang cannot handle subclasses correctly.
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
DistinguishedName name = (DistinguishedName) obj;
// compare the lists
return getNames().equals(name.getNames());
}
/**
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return this.getClass().hashCode() ^ getNames().hashCode();
}
/**
* Compare this instance to another object. Note that the comparison is done
* in order of significance, so the most significant Rdn is compared first,
* then the second and so on.
*
* @see javax.naming.Name#compareTo(java.lang.Object)
*/
public int compareTo(Object obj) {
DistinguishedName that = (DistinguishedName) obj;
ListComparator comparator = new ListComparator();
return comparator.compare(this.names, that.names);
}
public int size() {
return names.size();
}
public boolean isEmpty() {
return names.size() == 0;
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#getAll()
*/
public Enumeration getAll() {
LinkedList strings = new LinkedList();
for (Iterator iter = names.iterator(); iter.hasNext();) {
LdapRdn rdn = (LdapRdn) iter.next();
strings.add(rdn.getLdapEncoded());
}
return Collections.enumeration(strings);
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#get(int)
*/
public String get(int index) {
LdapRdn rdn = (LdapRdn) names.get(index);
return rdn.getLdapEncoded();
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#getPrefix(int)
*/
public Name getPrefix(int index) {
LinkedList newNames = new LinkedList();
for (int i = 0; i < index; i++) {
newNames.add(names.get(i));
}
return new DistinguishedName(newNames);
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#getSuffix(int)
*/
public Name getSuffix(int index) {
if (index > names.size()) {
throw new ArrayIndexOutOfBoundsException();
}
LinkedList newNames = new LinkedList();
for (int i = index; i < names.size(); i++) {
newNames.add(names.get(i));
}
return new DistinguishedName(newNames);
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#startsWith(javax.naming.Name)
*/
public boolean startsWith(Name name) {
if (name.size() == 0) {
return false;
}
DistinguishedName start = null;
if (name instanceof DistinguishedName) {
start = (DistinguishedName) name;
}
else {
return false;
}
if (start.size() > this.size()) {
return false;
}
Iterator longiter = names.iterator();
Iterator shortiter = start.getNames().iterator();
while (shortiter.hasNext()) {
Object longname = longiter.next();
Object shortname = shortiter.next();
if (!longname.equals(shortname)) {
return false;
}
}
// All names in shortiter matched.
return true;
}
/**
* Determines if this DistinguishedName ends with a certian
* path.
*
* If the argument path is empty (no names in path) this method will return
* false.
*
* @param name The suffix to check for.
*
*/
public boolean endsWith(Name name) {
DistinguishedName path = null;
if (name instanceof DistinguishedName) {
path = (DistinguishedName) name;
}
else {
return false;
}
List shortlist = path.getNames();
// this path must be at least as long
if (getNames().size() < shortlist.size())
return false;
// must have names
if (shortlist.size() == 0)
return false;
ListIterator longiter = getNames().listIterator(getNames().size());
ListIterator shortiter = shortlist.listIterator(shortlist.size());
while (shortiter.hasPrevious()) {
LdapRdn longname = (LdapRdn) longiter.previous();
LdapRdn shortname = (LdapRdn) shortiter.previous();
if (!longname.equals(shortname))
return false;
}
// if short list ended, all were equal
return true;
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#addAll(javax.naming.Name)
*/
public Name addAll(Name name) throws InvalidNameException {
return addAll(names.size(), name);
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#addAll(int, javax.naming.Name)
*/
public Name addAll(int arg0, Name name) throws InvalidNameException {
DistinguishedName distinguishedName = null;
try {
distinguishedName = (DistinguishedName) name;
}
catch (ClassCastException e) {
throw new InvalidNameException("Invalid name type");
}
names.addAll(arg0, distinguishedName.getNames());
return this;
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#add(java.lang.String)
*/
public Name add(String string) throws InvalidNameException {
return add(names.size(), string);
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#add(int, java.lang.String)
*/
public Name add(int index, String string) throws InvalidNameException {
try {
names.add(index, new LdapRdn(string));
}
catch (BadLdapGrammarException e) {
throw new InvalidNameException("Failed to parse rdn '" + string + "'");
}
return this;
}
/*
* (non-Javadoc)
*
* @see javax.naming.Name#remove(int)
*/
public Object remove(int arg0) throws InvalidNameException {
LdapRdn rdn = (LdapRdn) names.remove(arg0);
return rdn.getLdapEncoded();
}
/**
* Remove the last part of this DistinguishedName.
*
* @return the removed {@link LdapRdn}.
*/
public LdapRdn removeLast() {
return (LdapRdn) names.remove(names.size() - 1);
}
/**
* Add a new {@link LdapRdn} using the supplied key and value.
*
* @param key the key of the {@link LdapRdn}.
* @param value the value of the {@link LdapRdn}.
*/
public void add(String key, String value) {
names.add(new LdapRdn(key, value));
}
/**
* Add the supplied {@link LdapRdn} last in the list of Rdns.
*
* @param rdn the {@link LdapRdn} to add.
*/
public void add(LdapRdn rdn) {
names.add(rdn);
}
/**
* Add the supplied {@link LdapRdn} att the specified index.
*
* @param idx the index at which to add the LdapRdn.
* @param rdn the LdapRdn to add.
*/
public void add(int idx, LdapRdn rdn) {
names.add(idx, rdn);
}
/**
* Return an immutable copy of this instance. It will not be possible to add
* or remove any Rdns to or from the returned instance, and the respective
* Rdns will also be immutable in turn.
*
* @return a copy of this instance backed by an immutable list.
* @since 1.2
*/
public DistinguishedName immutableDistinguishedName() {
List listWithImmutableRdns = new ArrayList(names.size());
for (Iterator iterator = names.iterator(); iterator.hasNext();) {
LdapRdn rdn = (LdapRdn) iterator.next();
listWithImmutableRdns.add(rdn.immutableLdapRdn());
}
return new DistinguishedName(Collections.unmodifiableList(listWithImmutableRdns));
}
/**
* Create an immutable DistinguishedName instance, suitable as a constant.
*
* @param dnString the DN string to parse.
* @return an immutable DistinguishedName corresponding to the supplied DN
* string.
* @since 1.3
*/
public static final DistinguishedName immutableDistinguishedName(String dnString) {
return new DistinguishedName(dnString).immutableDistinguishedName();
}
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003413 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NamingException;
import javax.naming.directory.DirContext;
/**
* Interface to be called in search by {@link LdapTemplate} before and after the
* actual search and enumeration traversal. Implementations may be used to apply
* search controls on the Context and retrieve the results of
* such controls afterwards.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public interface DirContextProcessor {
/**
* Perform pre-processing on the supplied DirContext.
*
* @param ctx
* the DirContext instance.
* @throws NamingException
* if thrown by the underlying operation.
*/
void preProcess(DirContext ctx) throws NamingException;
/**
* Perform post-processing on the supplied DirContext.
*
* @param ctx
* the DirContext instance.
* @throws NamingException
* if thrown by the underlying operation.
*/
void postProcess(DirContext ctx) throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000204 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DirContextOperations.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000020160 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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.SortedSet;
import javax.naming.Name;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
/**
* Interface for DirContextAdapter.
*
* @author Mattias Hellborg Arthursson
* @see DirContextAdapter
*/
public interface DirContextOperations extends DirContext,
AttributeModificationsAware {
/**
* Gets the update mode. An entry in update mode will keep track of its
* modifications so that they can be retrieved using
* {@link AttributeModificationsAware#getModificationItems()}. The update
* mode should be true for a new entry and true
* for an existing entry that is being updated.
*
* @return update mode.
*/
boolean isUpdateMode();
/**
* Creates a String array of the names of the attributes which have been
* changed.
*
* If this is a new entry, all set entries will be in the list. If this is
* an updated entry, only changed and removed entries will be in the array.
*
* @return Array of String
*/
String[] getNamesOfModifiedAttributes();
/**
* Get the value of a String attribute. If more than one attribute value
* exists for the specified attribute, only the first one will be returned.
* If an attribute has no value, null will be returned.
*
* @param name name of the attribute.
* @return the value of the attribute if it exists, or null if
* the attribute doesn't exist or if it exists but with no value.
* @throws ClassCastException if the value of the entry is not a String.
*/
String getStringAttribute(String name);
/**
* Get the value of an Object attribute. If more than one attribute value
* exists for the specified attribute, only the first one will be returned.
* If an attribute has no value, null will be returned.
*
* @param name name of the attribute.
* @return the attribute value as an object if it exists, or
* null if the attribute doesn't exist or if it exists but with
* no value.
*/
Object getObjectAttribute(String name);
/**
* Check if an Object attribute exists, regardless of whether it has a value
* or not.
*
* @param name name of the attribute
* @return true if the attribute exists, false
* otherwise
*/
boolean attributeExists(String name);
/**
* Set the with the name name to the value.
*
* @param name name of the attribute.
* @param value value to set the attribute to.
*/
public void setAttributeValue(String name, Object value);
/**
* Sets a multivalue attribute, disregarding the order of the values.
*
* If value is null or value.length == 0 then the attribute will be removed.
*
* If update mode, changes will be made only if the array has more or less
* objects or if one or more object has changed. Reordering the objects will
* not cause an update.
*
* @param name The id of the attribute.
* @param values Attribute values.
*/
void setAttributeValues(String name, Object[] values);
/**
* Sets a multivalue attribute.
*
* If value is null or value.length == 0 then the attribute will be removed.
*
* If update mode, changes will be made if the array has more or less
* objects or if one or more string has changed.
*
* Reordering the objects will only cause an update if orderMatters is set
* to true.
*
* @param name The id of the attribute.
* @param values Attribute values.
* @param orderMatters If true, it will be changed even if data
* was just reordered.
*/
void setAttributeValues(String name, Object[] values, boolean orderMatters);
/**
* Add a value to the Attribute with the specified name. If the Attribute
* doesn't exist it will be created. This method makes sure that the there
* will be no duplicates of an added value - it the value exists it will not
* be added again.
*
* @param name the name of the Attribute to which the specified value should
* be added.
* @param value the Attribute value to add.
*/
void addAttributeValue(String name, Object value);
/**
* Add a value to the Attribute with the specified name. If the Attribute
* doesn't exist it will be created. The addIfDuplicateExists
* parameter controls the handling of duplicates. It false,
* this method makes sure that the there will be no duplicates of an added
* value - it the value exists it will not be added again.
*
* @param name the name of the Attribute to which the specified value should
* be added.
* @param value the Attribute value to add.
* @param addIfDuplicateExists true will add the value
* regardless of whether there is an identical value already, allowing for
* duplicate attribute values; false will not add the value if
* it already exists.
*/
void addAttributeValue(String name, Object value,
boolean addIfDuplicateExists);
/**
* Remove a value from the Attribute with the specified name. If the
* Attribute doesn't exist, do nothing.
*
* @param name the name of the Attribute from which the specified value
* should be removed.
* @param value the value to remove.
*/
void removeAttributeValue(String name, Object value);
/**
* Update the attributes.This will mean that the getters (
* getStringAttribute methods) will return the updated values,
* and the modifications will be forgotten (i.e.
* {@link AttributeModificationsAware#getModificationItems()} will return an
* empty array.
*/
void update();
/**
* Get all values of a String attribute.
*
* @param name name of the attribute.
* @return a (possibly empty) array containing all registered values of the
* attribute as Strings if the attribute is defined or null
* otherwise.
* @throws ArrayStoreException if any of the attribute values is not a
* String.
*/
String[] getStringAttributes(String name);
/**
* Get all values of an Object attribute.
*
* @param name name of the attribute.
* @return a (possibly empty) array containing all registered values of the
* attribute if the attribute is defined or null otherwise.
* @since 1.3
*/
Object[] getObjectAttributes(String name);
/**
* Get all String values of the attribute as a SortedSet.
*
* @param name name of the attribute.
* @return a SortedSet containing all values of the attribute,
* or null if the attribute does not exist.
*/
SortedSet getAttributeSortedStringSet(String name);
/**
* Returns the DN relative to the base path.
*
* @return The distinguished name of the current context.
*
* @see DirContextAdapter#getNameInNamespace()
*/
Name getDn();
/**
* Set the dn of this entry.
*
* @param dn the dn.
*/
void setDn(Name dn);
/*
* (non-Javadoc)
*
* @see javax.naming.Context#getNameInNamespace()
*/
String getNameInNamespace();
/**
* If this instance results from a referral, this method returns the url of
* the referred server.
*
* @return The url of the referred server, e.g.
* ldap://localhost:389, or the empty string if this is not a
* referral.
* @since 1.3
*/
String getReferralUrl();
/**
* Checks whether this instance results from a referral.
*
* @return true if this instance results from a referral,
* false otherwise.
* @since 1.3
*/
boolean isReferral();
/**
* Get all the Attributes.
*
* @return all the Attributes.
* @since 1.3
*/
Attributes getAttributes();
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AttributesMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004072 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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 javax.naming.Name;
import javax.naming.NamingException;
import javax.naming.directory.Attributes;
/**
* An interface used by LdapTemplate for mapping LDAP Attributes to beans.
* Implementions of this interface perform the actual work of extracting
* results, but need not worry about exception handling. NamingExceptions will
* be caught and handled correctly by the {@link LdapTemplate} class.
*
* Typically used in search methods of {@link LdapTemplate}.
* AttributeMapper objects are normally stateless and thus
* reusable; they are ideal for implementing attribute-mapping logic in one
* place.
*
* Alternatively, consider using a {@link ContextMapper} in stead.
*
* @see LdapTemplate#search(Name, String, AttributesMapper)
* @see LdapTemplate#lookup(Name, AttributesMapper)
* @see ContextMapper
*
* @author Mattias Hellborg Arthursson
*/
public interface AttributesMapper {
/**
* Map Attributes to an object. The supplied attributes are the attributes
* from a single SearchResult.
*
* @param attributes
* attributes from a SearchResult.
* @return an object built from the attributes.
* @throws NamingException
* if any error occurs mapping the attributes
*/
Object mapFromAttributes(Attributes attributes)
throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000214 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/NameClassPairCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003065 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NameClassPair;
/**
* Callback interface used by {@link LdapTemplate} search, list and listBindings
* methods. Implementations of this interface perform the actual work of
* extracting results from a single NameClassPair (a
* NameClassPair, Binding or
* SearchResult depending on the search operation) returned by an
* LDAP seach operation, such as search(), list(), and listBindings().
*
* @author Mattias Hellborg Arthursson
*/
public interface NameClassPairCallbackHandler {
/**
* Handle one entry. This method will be called once for each entry returned
* by a search or list.
*
* @param nameClassPair
* the NameClassPair returned from the
* NamingEnumeration.
*/
void handleNameClassPair(NameClassPair nameClassPair);
}
././@LongLink 0000000 0000000 0000000 00000000225 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AuthenticatedLdapEntryContextCallback.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002673 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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 javax.naming.directory.DirContext;
/**
* Callback interface to be used in the authentication methods in
* {@link LdapOperations} for performing operations on individually
* authenticated contexts.
*
* @author Mattias Hellborg Arthursson
* @since 1.3
*/
public interface AuthenticatedLdapEntryContextCallback {
/**
* Perform some LDAP operation on the supplied authenticated
* DirContext instance. The target context will be
* automatically closed.
*
* @param ctx the DirContext instance to perform an operation
* on.
* @param ldapEntryIdentification the identification of the LDAP entry used
* to authenticate the supplied DirContext.
*/
void executeWithContext(DirContext ctx, LdapEntryIdentification ldapEntryIdentification);
}
././@LongLink 0000000 0000000 0000000 00000000207 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapEntryIdentification.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006256 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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 javax.naming.directory.DirContext;
import org.springframework.util.Assert;
/**
* Wrapper class to handle the full identification of an LDAP entry. An LDAP
* entry is identified by its Distinguished Name, in Spring LDAP represented by
* the {@link DistinguishedName} class. A Distinguished Name can be absolute -
* i.e. complete including the very root (base) of the LDAP tree - or relative -
* i.e relative to the base LDAP path of the current LDAP connection (specified
* as base to the {@link ContextSource}).
*
* The different representations are needed on different occasions, e.g. the
* relative DN is typically what is needed to perform lookups and searches in
* the LDAP tree, whereas the absolute DN is needed when authenticating and when
* an LDAP entry is referred to in e.g. a group. This wrapper class contains
* both of these representations.
*
* @author Mattias Hellborg Arthursson
*/
public class LdapEntryIdentification {
private final DistinguishedName relativeDn;
private final DistinguishedName absoluteDn;
/**
* Construct an LdapEntryIdentification instance.
* @param absoluteDn the absolute DN of the identified entry, e.g. as
* returned by {@link DirContext#getNameInNamespace()}.
* @param relativeDn the DN of the identified entry relative to the base
* LDAP path, e.g. as returned by {@link DirContextOperations#getDn()}.
*/
public LdapEntryIdentification(DistinguishedName absoluteDn, DistinguishedName relativeDn) {
Assert.notNull(absoluteDn, "Absolute DN must not be null");
Assert.notNull(relativeDn, "Relative DN must not be null");
this.absoluteDn = absoluteDn.immutableDistinguishedName();
this.relativeDn = relativeDn.immutableDistinguishedName();
}
/**
* Get the DN of the identified entry relative to the base LDAP path, e.g.
* as returned by {@link DirContextOperations#getDn()}.
* @return the relative DN.
*/
public DistinguishedName getRelativeDn() {
return relativeDn;
}
/**
* Get the absolute DN of the identified entry, e.g. as returned by
* {@link DirContext#getNameInNamespace()}.
* @return the absolute DN.
*/
public DistinguishedName getAbsoluteDn() {
return absoluteDn;
}
public boolean equals(Object obj) {
if (obj != null && obj.getClass().equals(this.getClass())) {
LdapEntryIdentification that = (LdapEntryIdentification) obj;
return this.absoluteDn.equals(that.absoluteDn) && this.relativeDn.equals(that.relativeDn);
}
return false;
}
public int hashCode() {
return absoluteDn.hashCode() ^ relativeDn.hashCode();
}
}
././@LongLink 0000000 0000000 0000000 00000000163 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000230 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/DirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000010043 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Hashtable;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.springframework.ldap.core.AuthenticationSource;
import org.springframework.ldap.core.ContextSource;
/**
* A strategy to use when authenticating LDAP connections on creation. When
* authenticating LDAP connections different strategies are needed depending on
* the authentication mechanism used. Furthermore, depending on the mechanism
* the work to be done needs to be applied at different stages of the
* DirContext creation process. A
* DirContextAuthenticationStrategy contains the logic to perform a particular
* type of authentication mechanism and will be called by its
* {@link ContextSource} at appropriate stages of the process.
*
* @author Mattias Hellborg Arthursson
*/
public interface DirContextAuthenticationStrategy {
/**
* This method is responsible for preparing the environment to be used when
* creating the DirContext instance. The base environment
* (including URL, ContextFactory etc. will already be set,
* and this method is called just before the actual Context is to be
* created.
*
* @param env The Hashtable to be sent to the
* DirContext instance on initialization. Pre-configured with
* the basic settings; the implementation of this method is responsible for
* manipulating the environment as appropriate for the particular
* authentication mechanism.
* @param userDn the user DN to authenticate, as received from the
* {@link AuthenticationSource} of the {@link ContextSource}.
* @param password the password to authenticate with, as received from the
* {@link AuthenticationSource} of the {@link ContextSource}.
* @throws NamingException if anything goes wrong. This will cause the
* DirContext creation to be aborted and the exception to be
* translated and rethrown.
*/
public void setupEnvironment(Hashtable env, String userDn, String password) throws NamingException;
/**
* This method is responsible for post-processing the
* DirContext instance after it has been created. It will be
* called immediately after the instance has been created. Some
* authentication mechanisms, e.g. TLS, require particular stuff to happen
* before the actual target Context is closed. This method provides the
* possibility to replace or wrap the actual DirContext with a proxy so that
* any calls on it may be intercepted.
*
* @param ctx the freshly created DirContext instance. The
* actual implementation class (e.g. InitialLdapContext)
* depends on the {@link ContextSource} implementation.
* @param userDn the user DN to authenticate, as received from the
* {@link AuthenticationSource} of the {@link ContextSource}.
* @param password the password to authenticate with, as received from the
* {@link AuthenticationSource} of the {@link ContextSource}.
* @return the DirContext, possibly modified, replaced or wrapped.
* @throws NamingException if anything goes wrong. This will cause the
* DirContext creation to be aborted and the exception to be
* translated and rethrown.
*/
public DirContext processContextAfterCreation(DirContext ctx, String userDn, String password)
throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000235 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/CollectingAuthenticationErrorCallback.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003032 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.ldap.core.AuthenticationErrorCallback;
/**
* Convenience implementation of AuthenticationErrorCallback that stores the
* given exception and provides a method for retrieving it. The caller of the
* authenticate method can provide an instance of this class as an error
* callback. If the authentication fails, the caller can ask the callback
* instance for the actual authentication exception.
*
* @author Ulrik Sandberg
* @since 1.3.1
*/
public final class CollectingAuthenticationErrorCallback implements AuthenticationErrorCallback {
private Exception error;
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.AuthenticationErrorCallback#execute(java
* .lang.Exception)
*/
public void execute(Exception e) {
this.error = e;
}
/**
* @return the collected exception
*/
public Exception getError() {
return error;
}
} ././@LongLink 0000000 0000000 0000000 00000000243 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/AbstractTlsDirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000020440 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.support;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Hashtable;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.LdapContext;
import javax.naming.ldap.StartTlsRequest;
import javax.naming.ldap.StartTlsResponse;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSocketFactory;
import org.springframework.ldap.UncategorizedLdapException;
import org.springframework.ldap.core.DirContextProxy;
import org.springframework.ldap.support.LdapUtils;
/**
* Abstract superclass for {@link DirContextAuthenticationStrategy}
* implementations that apply TLS security to the connections. The supported TLS
* behavior differs between servers. E.g., some servers expect the TLS
* connection be shut down gracefully before the actual target context is
* closed, whereas other servers do not support that. The
* shutdownTlsGracefully property controls this behavior; the
* property defaults to false.
*
* The SSLSocketFactory used for TLS negotiation can be customized
* using the sslSocketFactory property. This allows for example a
* socket factory that can load the keystore/truststore using the Spring
* Resource abstraction. This provides a much more Spring-like strategy for
* configuring PKI credentials for authentication, in addition to allowing
* application-specific keystores and truststores running in the same JVM.
*
* In some rare occasions there is a need to supply a
* HostnameVerifier to the TLS processing instructions in order to
* have the returned certificate properly validated. If a
* HostnameVerifier is supplied to
* {@link #setHostnameVerifier(HostnameVerifier)}, that will be applied to the
* processing.
*
* For further information regarding TLS, refer to this * page. *
* NB: TLS negotiation is an expensive process, which is why you will
* most likely want to use connection pooling, to make sure new connections are
* not created for each individual request. It is imperative however, that the
* built-in LDAP connection pooling is not used in combination with the TLS
* AuthenticationStrategy implementations - this will not work. You should use
* the Spring LDAP PoolingContextSource instead.
*
* @author Mattias Hellborg Arthursson
*/
public abstract class AbstractTlsDirContextAuthenticationStrategy implements DirContextAuthenticationStrategy {
/** Hostname verifier to use for cert subject validation */
private HostnameVerifier hostnameVerifier;
/** Flag to cause graceful shutdown required by some LDAP DSAs */
private boolean shutdownTlsGracefully = false;
/** SSL socket factory to use for startTLS negotiation */
private SSLSocketFactory sslSocketFactory;
/**
* Specify whether the TLS should be shut down gracefully before the target
* context is closed. Defaults to
* If a class implements this interface and a
* {@link BaseLdapPathBeanPostProcessor} is defined in the
*
* NB:The
* If the
* Implementing classes need to implement
* {@link #getDirContextInstance(Hashtable)} to create a
* If an {@link AuthenticationSource} is set, this will be used for getting user
* principal and password for each new connection, otherwise a default one will
* be created using the specified
* Note: When using implementations of this class outside of a Spring
* Context it is necessary to call {@link #afterPropertiesSet()} when all
* properties are set, in order to finish up initialization.
*
* @see org.springframework.ldap.core.LdapTemplate
* @see org.springframework.ldap.core.support.DefaultDirObjectFactory
* @see org.springframework.ldap.core.support.LdapContextSource
* @see org.springframework.ldap.core.support.DirContextSource
*
* @author Mattias Hellborg Arthursson
* @author Adam Skogman
* @author Ulrik Sandberg
*/
public abstract class AbstractContextSource implements BaseLdapPathContextSource, InitializingBean {
private static final Class DEFAULT_CONTEXT_FACTORY = com.sun.jndi.ldap.LdapCtxFactory.class;
private static final Class DEFAULT_DIR_OBJECT_FACTORY = DefaultDirObjectFactory.class;
private Class dirObjectFactory = DEFAULT_DIR_OBJECT_FACTORY;
private Class contextFactory = DEFAULT_CONTEXT_FACTORY;
private DistinguishedName base = DistinguishedName.EMPTY_PATH;
protected String userDn = "";
protected String password = "";
private String[] urls;
private boolean pooled = false;
private Hashtable baseEnv = new Hashtable();
private Hashtable anonymousEnv;
private AuthenticationSource authenticationSource;
private boolean cacheEnvironmentProperties = true;
private boolean anonymousReadOnly = false;
private String referral = null;
private static final Log log = LogFactory.getLog(AbstractContextSource.class);
public static final String SUN_LDAP_POOLING_FLAG = "com.sun.jndi.ldap.connect.pool";
private static final String JDK_142 = "1.4.2";
private DirContextAuthenticationStrategy authenticationStrategy = new SimpleDirContextAuthenticationStrategy();
public DirContext getContext(String principal, String credentials) {
DirContext ctx = createContext(getAuthenticatedEnv(principal, credentials));
try {
authenticationStrategy.processContextAfterCreation(ctx, principal, credentials);
return ctx;
}
catch (NamingException e) {
closeContext(ctx);
throw LdapUtils.convertLdapException(e);
}
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.core.ContextSource#getReadOnlyContext()
*/
public DirContext getReadOnlyContext() {
if (!anonymousReadOnly) {
return getContext(authenticationSource.getPrincipal(), authenticationSource.getCredentials());
}
else {
return createContext(getAnonymousEnv());
}
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.core.ContextSource#getReadWriteContext()
*/
public DirContext getReadWriteContext() {
return getContext(authenticationSource.getPrincipal(), authenticationSource.getCredentials());
}
/**
* Default implementation of setting the environment up to be authenticated.
* This method should typically NOT be overridden; any customization to the
* authentication mechanism should be managed by setting a different
* {@link DirContextAuthenticationStrategy} on this instance.
*
* @param env the environment to modify.
* @param principal the principal to authenticate with.
* @param credentials the credentials to authenticate with.
* @see DirContextAuthenticationStrategy
* @see #setAuthenticationStrategy(DirContextAuthenticationStrategy)
*/
protected void setupAuthenticatedEnvironment(Hashtable env, String principal, String credentials) {
try {
authenticationStrategy.setupEnvironment(env, principal, credentials);
}
catch (NamingException e) {
throw LdapUtils.convertLdapException(e);
}
}
/**
* Close the context and swallow any exceptions.
*
* @param ctx the DirContext to close.
*/
private void closeContext(DirContext ctx) {
if (ctx != null) {
try {
ctx.close();
}
catch (Exception e) {
}
}
}
/**
* Assemble a valid url String from all registered urls to add as
*
* Note that since LDAP pooling is system wide, full configuration of this
* needs be done using system parameters as specified in the LDAP/JNDI
* documentation. Also note, that pooling is done on user dn basis, i.e.
* each individually authenticated connection will be pooled separately.
* This means that LDAP pooling will be most efficient using anonymous
* connections or connections authenticated using one single system user.
*
* @param pooled whether Contexts should be pooled.
*/
public void setPooled(boolean pooled) {
this.pooled = pooled;
}
/**
* Get whether the pooling flag should be set.
*
* @return whether Contexts should be pooled.
*/
public boolean isPooled() {
return pooled;
}
/**
* If any custom environment properties are needed, these can be set using
* this method.
*
* @param baseEnvironmentProperties
*/
public void setBaseEnvironmentProperties(Map baseEnvironmentProperties) {
this.baseEnv = new Hashtable(baseEnvironmentProperties);
}
String getJdkVersion() {
return JdkVersion.getJavaVersion();
}
protected Hashtable getAnonymousEnv() {
if (cacheEnvironmentProperties) {
return anonymousEnv;
}
else {
return setupAnonymousEnv();
}
}
protected Hashtable getAuthenticatedEnv(String principal, String credentials) {
// The authenticated environment should always be rebuilt.
Hashtable env = new Hashtable(getAnonymousEnv());
setupAuthenticatedEnvironment(env, principal, credentials);
return env;
}
/**
* Set the authentication source to use when retrieving user principal and
* credentials.
*
* @param authenticationSource the {@link AuthenticationSource} that will
* provide user info.
*/
public void setAuthenticationSource(AuthenticationSource authenticationSource) {
this.authenticationSource = authenticationSource;
}
/**
* Get the authentication source.
*
* @return the {@link AuthenticationSource} that will provide user info.
*/
public AuthenticationSource getAuthenticationSource() {
return authenticationSource;
}
/**
* Set whether environment properties should be cached between requsts for
* anonymous environment. Default is
* Typical use of this method would be as follows:
*
*
* Example:
* Example:
* Example:
* Example:
* ContextMapper implementations are typically stateless and thus reusable; they
* are ideal for implementing mapping logic in one place.
*
* Alternatively, consider using an {@link AttributesMapper} in stead.
*
* @see LdapTemplate#search(Name, String, ContextMapper)
* @see LdapTemplate#listBindings(Name, ContextMapper)
* @see LdapTemplate#lookup(Name, ContextMapper)
* @see AttributesMapper
* @see DefaultDirObjectFactory
* @see DirContextAdapter
* @see AbstractContextMapper
*
* @author Mattias Hellborg Arthursson
*/
public interface ContextMapper {
/**
* Map a single LDAP Context to an object. The supplied Object
*
* Also handles the case where the values have been reset to the original
* values after a previous change. For example, changing
*
* Depending on the value of the "key case fold" System property, the keys
* will be lowercased, uppercased, or preserve their original case. Default
* is to convert them to lowercase.
*
* @param key the Attribute name.
* @param value the Attribute value.
* @param decodeValue if
* Note for Active Directory (AD) users: AD servers are apparently unable
* to handle referrals automatically, which causes a
*
* The actual list is delegated to the {@link SearchExecutor} and each
* {@link NameClassPair} (this might be a NameClassPair or a subclass
* thereof) is passed to the CallbackHandler. Any encountered
* NamingException will be translated using the NamingExceptionTranslator.
*
* @param se the SearchExecutor to use for performing the actual list.
* @param handler the NameClassPairCallbackHandler to which each found entry
* will be passed.
* @param processor DirContextProcessor for custom pre- and post-processing.
* Must not be
* The actual list is delegated to the {@link SearchExecutor} and each
* {@link NameClassPair} (this might be a NameClassPair or a subclass
* thereof) is passed to the CallbackHandler. Any encountered
* NamingException will be translated using the NamingExceptionTranslator.
*
* @param se the SearchExecutor to use for performing the actual list.
* @param handler the NameClassPairCallbackHandler to which each found entry
* will be passed.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is interpreted that
* no entries were found.
*/
public void search(SearchExecutor se, NameClassPairCallbackHandler handler) {
search(se, handler, new NullDirContextProcessor());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(Name base, String filter, NameClassPairCallbackHandler handler) {
SearchControls controls = getDefaultSearchControls(DEFAULT_SEARCH_SCOPE, DONT_RETURN_OBJ_FLAG, ALL_ATTRIBUTES);
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(base, filter, controls, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(String base, String filter, NameClassPairCallbackHandler handler) {
SearchControls controls = getDefaultSearchControls(DEFAULT_SEARCH_SCOPE, DONT_RETURN_OBJ_FLAG, ALL_ATTRIBUTES);
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(base, filter, controls, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, int, java.lang.String[],
* org.springframework.ldap.core.AttributesMapper)
*/
public List search(Name base, String filter, int searchScope, String[] attrs, AttributesMapper mapper) {
return search(base, filter, getDefaultSearchControls(searchScope, DONT_RETURN_OBJ_FLAG, attrs), mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, int, java.lang.String[],
* org.springframework.ldap.core.AttributesMapper)
*/
public List search(String base, String filter, int searchScope, String[] attrs, AttributesMapper mapper) {
return search(base, filter, getDefaultSearchControls(searchScope, DONT_RETURN_OBJ_FLAG, attrs), mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, int, org.springframework.ldap.core.AttributesMapper)
*/
public List search(Name base, String filter, int searchScope, AttributesMapper mapper) {
return search(base, filter, searchScope, ALL_ATTRIBUTES, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, int, org.springframework.ldap.core.AttributesMapper)
*/
public List search(String base, String filter, int searchScope, AttributesMapper mapper) {
return search(base, filter, searchScope, ALL_ATTRIBUTES, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, org.springframework.ldap.core.AttributesMapper)
*/
public List search(Name base, String filter, AttributesMapper mapper) {
return search(base, filter, DEFAULT_SEARCH_SCOPE, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, org.springframework.ldap.core.AttributesMapper)
*/
public List search(String base, String filter, AttributesMapper mapper) {
return search(base, filter, DEFAULT_SEARCH_SCOPE, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, int, java.lang.String[],
* org.springframework.ldap.core.ContextMapper)
*/
public List search(Name base, String filter, int searchScope, String[] attrs, ContextMapper mapper) {
return search(base, filter, getDefaultSearchControls(searchScope, RETURN_OBJ_FLAG, attrs), mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, int, java.lang.String[],
* org.springframework.ldap.core.ContextMapper)
*/
public List search(String base, String filter, int searchScope, String[] attrs, ContextMapper mapper) {
return search(base, filter, getDefaultSearchControls(searchScope, RETURN_OBJ_FLAG, attrs), mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, int, org.springframework.ldap.core.ContextMapper)
*/
public List search(Name base, String filter, int searchScope, ContextMapper mapper) {
return search(base, filter, searchScope, ALL_ATTRIBUTES, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, int, org.springframework.ldap.core.ContextMapper)
*/
public List search(String base, String filter, int searchScope, ContextMapper mapper) {
return search(base, filter, searchScope, ALL_ATTRIBUTES, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, org.springframework.ldap.core.ContextMapper)
*/
public List search(Name base, String filter, ContextMapper mapper) {
return search(base, filter, DEFAULT_SEARCH_SCOPE, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, org.springframework.ldap.core.ContextMapper)
*/
public List search(String base, String filter, ContextMapper mapper) {
return search(base, filter, DEFAULT_SEARCH_SCOPE, mapper);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.ContextMapper)
*/
public List search(String base, String filter, SearchControls controls, ContextMapper mapper) {
return search(base, filter, controls, mapper, new NullDirContextProcessor());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.ContextMapper)
*/
public List search(Name base, String filter, SearchControls controls, ContextMapper mapper) {
return search(base, filter, controls, mapper, new NullDirContextProcessor());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.AttributesMapper)
*/
public List search(Name base, String filter, SearchControls controls, AttributesMapper mapper) {
return search(base, filter, controls, mapper, new NullDirContextProcessor());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.AttributesMapper)
*/
public List search(String base, String filter, SearchControls controls, AttributesMapper mapper) {
return search(base, filter, controls, mapper, new NullDirContextProcessor());
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.AttributesMapper,
* org.springframework.ldap.core.DirContextProcessor)
*/
public List search(String base, String filter, SearchControls controls, AttributesMapper mapper,
DirContextProcessor processor) {
AttributesMapperCallbackHandler handler = new AttributesMapperCallbackHandler(mapper);
search(base, filter, controls, handler, processor);
return handler.getList();
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.AttributesMapper,
* org.springframework.ldap.core.DirContextProcessor)
*/
public List search(Name base, String filter, SearchControls controls, AttributesMapper mapper,
DirContextProcessor processor) {
AttributesMapperCallbackHandler handler = new AttributesMapperCallbackHandler(mapper);
search(base, filter, controls, handler, processor);
return handler.getList();
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.ContextMapper,
* org.springframework.ldap.core.DirContextProcessor)
*/
public List search(String base, String filter, SearchControls controls, ContextMapper mapper,
DirContextProcessor processor) {
assureReturnObjFlagSet(controls);
ContextMapperCallbackHandler handler = new ContextMapperCallbackHandler(mapper);
search(base, filter, controls, handler, processor);
return handler.getList();
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.ContextMapper,
* org.springframework.ldap.core.DirContextProcessor)
*/
public List search(Name base, String filter, SearchControls controls, ContextMapper mapper,
DirContextProcessor processor) {
assureReturnObjFlagSet(controls);
ContextMapperCallbackHandler handler = new ContextMapperCallbackHandler(mapper);
search(base, filter, controls, handler, processor);
return handler.getList();
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(java.lang.String,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void list(final String base, NameClassPairCallbackHandler handler) {
SearchExecutor searchExecutor = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.list(base);
}
};
search(searchExecutor, handler);
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(javax.naming.Name,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void list(final Name base, NameClassPairCallbackHandler handler) {
SearchExecutor searchExecutor = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.list(base);
}
};
search(searchExecutor, handler);
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(java.lang.String,
* org.springframework.ldap.core.NameClassPairMapper)
*/
public List list(String base, NameClassPairMapper mapper) {
CollectingNameClassPairCallbackHandler handler = new MappingCollectingNameClassPairCallbackHandler(mapper);
list(base, handler);
return handler.getList();
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(javax.naming.Name,
* org.springframework.ldap.core.NameClassPairMapper)
*/
public List list(Name base, NameClassPairMapper mapper) {
CollectingNameClassPairCallbackHandler handler = new MappingCollectingNameClassPairCallbackHandler(mapper);
list(base, handler);
return handler.getList();
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(javax.naming.Name)
*/
public List list(final Name base) {
return list(base, new DefaultNameClassPairMapper());
}
/*
* @see org.springframework.ldap.core.LdapOperations#list(java.lang.String)
*/
public List list(final String base) {
return list(base, new DefaultNameClassPairMapper());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(java.lang.String
* , org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void listBindings(final String base, NameClassPairCallbackHandler handler) {
SearchExecutor searchExecutor = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.listBindings(base);
}
};
search(searchExecutor, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(javax.naming
* .Name, org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void listBindings(final Name base, NameClassPairCallbackHandler handler) {
SearchExecutor searchExecutor = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.listBindings(base);
}
};
search(searchExecutor, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(java.lang.String
* , org.springframework.ldap.core.NameClassPairMapper)
*/
public List listBindings(String base, NameClassPairMapper mapper) {
CollectingNameClassPairCallbackHandler handler = new MappingCollectingNameClassPairCallbackHandler(mapper);
listBindings(base, handler);
return handler.getList();
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(javax.naming
* .Name, org.springframework.ldap.core.NameClassPairMapper)
*/
public List listBindings(Name base, NameClassPairMapper mapper) {
CollectingNameClassPairCallbackHandler handler = new MappingCollectingNameClassPairCallbackHandler(mapper);
listBindings(base, handler);
return handler.getList();
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(java.lang.String
* )
*/
public List listBindings(final String base) {
return listBindings(base, new DefaultNameClassPairMapper());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(javax.naming
* .Name)
*/
public List listBindings(final Name base) {
return listBindings(base, new DefaultNameClassPairMapper());
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(java.lang.String
* , org.springframework.ldap.core.ContextMapper)
*/
public List listBindings(String base, ContextMapper mapper) {
ContextMapperCallbackHandler handler = new ContextMapperCallbackHandler(mapper);
listBindings(base, handler);
return handler.getList();
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#listBindings(javax.naming
* .Name, org.springframework.ldap.core.ContextMapper)
*/
public List listBindings(Name base, ContextMapper mapper) {
ContextMapperCallbackHandler handler = new ContextMapperCallbackHandler(mapper);
listBindings(base, handler);
return handler.getList();
}
/*
* @seeorg.springframework.ldap.core.LdapOperations#executeReadOnly(org.
* springframework.ldap.core.DirContextProcessor)
*/
public Object executeReadOnly(ContextExecutor ce) {
DirContext ctx = contextSource.getReadOnlyContext();
return executeWithContext(ce, ctx);
}
/*
* @seeorg.springframework.ldap.core.LdapOperations#executeReadWrite(org.
* springframework.ldap.core.DirContextProcessor)
*/
public Object executeReadWrite(ContextExecutor ce) {
DirContext ctx = contextSource.getReadWriteContext();
return executeWithContext(ce, ctx);
}
private Object executeWithContext(ContextExecutor ce, DirContext ctx) {
try {
return ce.executeWithContext(ctx);
}
catch (javax.naming.NamingException e) {
throw LdapUtils.convertLdapException(e);
}
finally {
closeContext(ctx);
}
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(javax.naming.Name)
*/
public Object lookup(final Name dn) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
return ctx.lookup(dn);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(java.lang.String)
*/
public Object lookup(final String dn) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
return ctx.lookup(dn);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(javax.naming.Name,
* org.springframework.ldap.core.AttributesMapper)
*/
public Object lookup(final Name dn, final AttributesMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes attributes = ctx.getAttributes(dn);
return mapper.mapFromAttributes(attributes);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(java.lang.String,
* org.springframework.ldap.core.AttributesMapper)
*/
public Object lookup(final String dn, final AttributesMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes attributes = ctx.getAttributes(dn);
return mapper.mapFromAttributes(attributes);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(javax.naming.Name,
* org.springframework.ldap.core.ContextMapper)
*/
public Object lookup(final Name dn, final ContextMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Object object = ctx.lookup(dn);
return mapper.mapFromContext(object);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(java.lang.String,
* org.springframework.ldap.core.ContextMapper)
*/
public Object lookup(final String dn, final ContextMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Object object = ctx.lookup(dn);
return mapper.mapFromContext(object);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(javax.naming.Name,
* java.lang.String[], org.springframework.ldap.core.AttributesMapper)
*/
public Object lookup(final Name dn, final String[] attributes, final AttributesMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes filteredAttributes = ctx.getAttributes(dn, attributes);
return mapper.mapFromAttributes(filteredAttributes);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(java.lang.String,
* java.lang.String[], org.springframework.ldap.core.AttributesMapper)
*/
public Object lookup(final String dn, final String[] attributes, final AttributesMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes filteredAttributes = ctx.getAttributes(dn, attributes);
return mapper.mapFromAttributes(filteredAttributes);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(javax.naming.Name,
* java.lang.String[], org.springframework.ldap.core.ContextMapper)
*/
public Object lookup(final Name dn, final String[] attributes, final ContextMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes filteredAttributes = ctx.getAttributes(dn, attributes);
DirContextAdapter contextAdapter = new DirContextAdapter(filteredAttributes, dn);
return mapper.mapFromContext(contextAdapter);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#lookup(java.lang.String,
* java.lang.String[], org.springframework.ldap.core.ContextMapper)
*/
public Object lookup(final String dn, final String[] attributes, final ContextMapper mapper) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
Attributes filteredAttributes = ctx.getAttributes(dn, attributes);
DistinguishedName name = new DistinguishedName(dn);
DirContextAdapter contextAdapter = new DirContextAdapter(filteredAttributes, name);
return mapper.mapFromContext(contextAdapter);
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#modifyAttributes(javax.naming
* .Name, javax.naming.directory.ModificationItem[])
*/
public void modifyAttributes(final Name dn, final ModificationItem[] mods) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.modifyAttributes(dn, mods);
return null;
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#modifyAttributes(java.lang
* .String, javax.naming.directory.ModificationItem[])
*/
public void modifyAttributes(final String dn, final ModificationItem[] mods) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.modifyAttributes(dn, mods);
return null;
}
});
}
/*
* @see org.springframework.ldap.core.LdapOperations#bind(javax.naming.Name,
* java.lang.Object, javax.naming.directory.Attributes)
*/
public void bind(final Name dn, final Object obj, final Attributes attributes) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.bind(dn, obj, attributes);
return null;
}
});
}
/*
* @see org.springframework.ldap.core.LdapOperations#bind(java.lang.String,
* java.lang.Object, javax.naming.directory.Attributes)
*/
public void bind(final String dn, final Object obj, final Attributes attributes) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.bind(dn, obj, attributes);
return null;
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#unbind(javax.naming.Name)
*/
public void unbind(final Name dn) {
doUnbind(dn);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#unbind(java.lang.String)
*/
public void unbind(final String dn) {
doUnbind(dn);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#unbind(javax.naming.Name,
* boolean)
*/
public void unbind(final Name dn, boolean recursive) {
if (!recursive) {
doUnbind(dn);
}
else {
doUnbindRecursively(dn);
}
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#unbind(java.lang.String,
* boolean)
*/
public void unbind(final String dn, boolean recursive) {
if (!recursive) {
doUnbind(dn);
}
else {
doUnbindRecursively(dn);
}
}
private void doUnbind(final Name dn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.unbind(dn);
return null;
}
});
}
private void doUnbind(final String dn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.unbind(dn);
return null;
}
});
}
private void doUnbindRecursively(final Name dn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) {
deleteRecursively(ctx, new DistinguishedName(dn));
return null;
}
});
}
private void doUnbindRecursively(final String dn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
deleteRecursively(ctx, new DistinguishedName(dn));
return null;
}
});
}
/**
* Delete all subcontexts including the current one recursively.
*
* @param ctx The context to use for deleting.
* @param name The starting point to delete recursively.
* @throws NamingException if any error occurs
*/
protected void deleteRecursively(DirContext ctx, DistinguishedName name) {
NamingEnumeration enumeration = null;
try {
enumeration = ctx.listBindings(name);
while (enumeration.hasMore()) {
Binding binding = (Binding) enumeration.next();
DistinguishedName childName = new DistinguishedName(binding.getName());
childName.prepend((DistinguishedName) name);
deleteRecursively(ctx, childName);
}
ctx.unbind(name);
if (log.isDebugEnabled()) {
log.debug("Entry " + name + " deleted");
}
}
catch (javax.naming.NamingException e) {
throw LdapUtils.convertLdapException(e);
}
finally {
try {
enumeration.close();
}
catch (Exception e) {
// Never mind this
}
}
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#rebind(javax.naming.Name,
* java.lang.Object, javax.naming.directory.Attributes)
*/
public void rebind(final Name dn, final Object obj, final Attributes attributes) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.rebind(dn, obj, attributes);
return null;
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#rebind(java.lang.String,
* java.lang.Object, javax.naming.directory.Attributes)
*/
public void rebind(final String dn, final Object obj, final Attributes attributes) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.rebind(dn, obj, attributes);
return null;
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#rename(javax.naming.Name,
* javax.naming.Name)
*/
public void rename(final Name oldDn, final Name newDn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.rename(oldDn, newDn);
return null;
}
});
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#rename(java.lang.String,
* java.lang.String)
*/
public void rename(final String oldDn, final String newDn) {
executeReadWrite(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
ctx.rename(oldDn, newDn);
return null;
}
});
}
/*
* @see
* org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {
if (contextSource == null) {
throw new IllegalArgumentException("Property 'contextSource' must be set.");
}
}
private void closeContextAndNamingEnumeration(DirContext ctx, NamingEnumeration results) {
closeNamingEnumeration(results);
closeContext(ctx);
}
/**
* Close the supplied DirContext if it is not null. Swallow any exceptions,
* as this is only for cleanup.
*
* @param ctx the context to close.
*/
private void closeContext(DirContext ctx) {
if (ctx != null) {
try {
ctx.close();
}
catch (Exception e) {
// Never mind this.
}
}
}
/**
* Close the supplied NamingEnumeration if it is not null. Swallow any
* exceptions, as this is only for cleanup.
*
* @param results the NamingEnumeration to close.
*/
private void closeNamingEnumeration(NamingEnumeration results) {
if (results != null) {
try {
results.close();
}
catch (Exception e) {
// Never mind this.
}
}
}
private SearchControls getDefaultSearchControls(int searchScope, boolean returningObjFlag, String[] attrs) {
SearchControls controls = new SearchControls();
controls.setSearchScope(searchScope);
controls.setReturningObjFlag(returningObjFlag);
controls.setReturningAttributes(attrs);
return controls;
}
/**
* Make sure the returnObjFlag is set in the supplied SearchControls. Set it
* and log if it's not set.
*
* @param controls the SearchControls to check.
*/
private void assureReturnObjFlagSet(SearchControls controls) {
Validate.notNull(controls);
if (!controls.getReturningObjFlag()) {
log.info("The returnObjFlag of supplied SearchControls is not set"
+ " but a ContextMapper is used - setting flag to true");
controls.setReturningObjFlag(true);
}
}
private final static class NullDirContextProcessor implements DirContextProcessor {
public void postProcess(DirContext ctx) throws NamingException {
// Do nothing
}
public void preProcess(DirContext ctx) throws NamingException {
// Do nothing
}
}
/**
* A {@link NameClassPairCallbackHandler} that passes the NameClassPairs
* found to a NameClassPairMapper and collects the results in a list.
*
* @author Mattias Hellborg Arthursson
*/
public final static class MappingCollectingNameClassPairCallbackHandler extends
CollectingNameClassPairCallbackHandler {
private NameClassPairMapper mapper;
public MappingCollectingNameClassPairCallbackHandler(NameClassPairMapper mapper) {
this.mapper = mapper;
}
/*
* @seeorg.springframework.ldap.CollectingNameClassPairCallbackHandler#
* getObjectFromNameClassPair(javax.naming.NameClassPair)
*/
public Object getObjectFromNameClassPair(NameClassPair nameClassPair) {
try {
return mapper.mapFromNameClassPair(nameClassPair);
}
catch (javax.naming.NamingException e) {
throw LdapUtils.convertLdapException(e);
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#lookupContext(javax.naming
* .Name)
*/
public DirContextOperations lookupContext(Name dn) {
return (DirContextOperations) lookup(dn);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#lookupContext(java.lang.
* String)
*/
public DirContextOperations lookupContext(String dn) {
return (DirContextOperations) lookup(dn);
}
/*
* (non-Javadoc)
*
* @seeorg.springframework.ldap.core.LdapOperations#modifyAttributes(org.
* springframework.ldap.core.DirContextOperations)
*/
public void modifyAttributes(DirContextOperations ctx) {
Name dn = ctx.getDn();
if (dn != null && ctx.isUpdateMode()) {
modifyAttributes(dn, ctx.getModificationItems());
}
else {
throw new IllegalStateException("The DirContextOperations instance needs to be properly initialized.");
}
}
/*
* (non-Javadoc)
*
* @seeorg.springframework.ldap.core.LdapOperations#bind(org.
* springframework.ldap.core.DirContextOperations)
*/
public void bind(DirContextOperations ctx) {
Name dn = ctx.getDn();
if (dn != null && !ctx.isUpdateMode()) {
bind(dn, ctx, null);
}
else {
throw new IllegalStateException("The DirContextOperations instance needs to be properly initialized.");
}
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#rebind(org.springframework.
* ldap.core.DirContextOperations)
*/
public void rebind(DirContextOperations ctx) {
Name dn = ctx.getDn();
if (dn != null && !ctx.isUpdateMode()) {
rebind(dn, ctx, null);
}
else {
throw new IllegalStateException(
"The DirContextOperations instance needs to be properly initialized.");
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(javax.naming
* .Name, java.lang.String, java.lang.String)
*/
public boolean authenticate(Name base, String filter, String password) {
return authenticate(base, filter, password,
new NullAuthenticatedLdapEntryContextCallback(),
new NullAuthenticationErrorCallback());
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(java.lang.String
* , java.lang.String, java.lang.String)
*/
public boolean authenticate(String base, String filter, String password) {
return authenticate(new DistinguishedName(base), filter, password,
new NullAuthenticatedLdapEntryContextCallback(),
new NullAuthenticationErrorCallback());
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(java.lang.String
* , java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticatedLdapEntryContextCallback)
*/
public boolean authenticate(String base, String filter, String password,
AuthenticatedLdapEntryContextCallback callback) {
return authenticate(new DistinguishedName(base), filter, password, callback, new NullAuthenticationErrorCallback());
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(javax.naming
* .Name, java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticatedLdapEntryContextCallback)
*/
public boolean authenticate(Name base, String filter, String password,
final AuthenticatedLdapEntryContextCallback callback) {
return authenticate(base, filter, password, callback, new NullAuthenticationErrorCallback());
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(java.lang.String
* , java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticationErrorCallback)
*/
public boolean authenticate(String base, String filter, String password,
AuthenticationErrorCallback errorCallback) {
return authenticate(new DistinguishedName(base), filter, password, new NullAuthenticatedLdapEntryContextCallback(), errorCallback);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(javax.naming
* .Name, java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticationErrorCallback)
*/
public boolean authenticate(Name base, String filter, String password,
final AuthenticationErrorCallback errorCallback) {
return authenticate(base, filter, password, new NullAuthenticatedLdapEntryContextCallback(), errorCallback);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(java.lang.String
* , java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticatedLdapEntryContextCallback,
* org.springframework.ldap.core.AuthenticationErrorCallback)
*/
public boolean authenticate(String base, String filter, String password,
final AuthenticatedLdapEntryContextCallback callback, final AuthenticationErrorCallback errorCallback) {
return authenticate(new DistinguishedName(base), filter, password, callback, errorCallback);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#authenticate(javax.naming
* .Name, java.lang.String, java.lang.String,
* org.springframework.ldap.core.AuthenticatedLdapEntryContextCallback,
* org.springframework.ldap.core.AuthenticationErrorCallback)
*/
public boolean authenticate(Name base, String filter, String password,
final AuthenticatedLdapEntryContextCallback callback, final AuthenticationErrorCallback errorCallback) {
List result = search(base, filter, new LdapEntryIdentificationContextMapper());
if (result.size() == 0) {
String msg = "No results found for search, base: '" + base + "'; filter: '" + filter + "'.";
log.info(msg);
return false;
} else if (result.size() > 1) {
String msg = "base: '" + base + "'; filter: '" + filter + "'.";
throw new IncorrectResultSizeDataAccessException(msg, 1, result.size());
}
final LdapEntryIdentification entryIdentification = (LdapEntryIdentification) result.get(0);
try {
DirContext ctx = contextSource.getContext(entryIdentification.getAbsoluteDn().toString(), password);
executeWithContext(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
callback.executeWithContext(ctx, entryIdentification);
return null;
}
}, ctx);
return true;
}
catch (Exception e) {
log.info("Authentication failed for entry with DN '" + entryIdentification.getAbsoluteDn() + "'", e);
errorCallback.execute(e);
return false;
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#searchForObject(javax.naming
* .Name, java.lang.String, org.springframework.ldap.core.ContextMapper)
*/
public Object searchForObject(Name base, String filter, ContextMapper mapper) {
List result = search(base, filter, mapper);
if (result.size() == 0) {
throw new EmptyResultDataAccessException(1);
}
else if (result.size() != 1) {
throw new IncorrectResultSizeDataAccessException(1, result.size());
}
return result.get(0);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.LdapOperations#searchForObject(java.lang
* .String, java.lang.String, org.springframework.ldap.core.ContextMapper)
*/
public Object searchForObject(String base, String filter, ContextMapper mapper) {
return searchForObject(new DistinguishedName(base), filter, mapper);
}
private static final class NullAuthenticatedLdapEntryContextCallback
implements AuthenticatedLdapEntryContextCallback {
public void executeWithContext(DirContext ctx,
LdapEntryIdentification ldapEntryIdentification) {
// Do nothing
}
}
private static final class NullAuthenticationErrorCallback
implements AuthenticationErrorCallback {
public void execute(Exception e) {
// Do nothing
}
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ContextAssembler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002340 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Helper interface to be used by Dao implementations for assembling to and from
* context. Useful if we have assembler classes responsible for mapping to and
* from a specific entry.
*
* @author Mattias Hellborg Arthursson
*/
public interface ContextAssembler extends ContextMapper {
/**
* Map the supplied object to the specified context.
*
* @param obj
* the object to read data from.
* @param ctx
* the context to map to.
*/
void mapToContext(Object obj, Object ctx);
}
././@LongLink 0000000 0000000 0000000 00000000214 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ContextMapperCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004355 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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 javax.naming.Binding;
import javax.naming.NameClassPair;
import org.apache.commons.lang.Validate;
/**
* A CollectingNameClassPairCallbackHandler to wrap a ContextMapper. That is,
* the found object is extracted from each {@link Binding}, and then passed to
* the specified ContextMapper for translation.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
* @since 1.2
*/
public class ContextMapperCallbackHandler extends
CollectingNameClassPairCallbackHandler {
private ContextMapper mapper;
/**
* Constructs a new instance wrapping the supplied {@link ContextMapper}.
*
* @param mapper
* the mapper to be called for each entry.
*/
public ContextMapperCallbackHandler(ContextMapper mapper) {
Validate.notNull(mapper, "Mapper must not be empty");
this.mapper = mapper;
}
/**
* Cast the NameClassPair to a {@link Binding} and pass its object to
* the ContextMapper.
*
* @param nameClassPair
* a Binding instance.
* @return the Object returned from the mapper.
*/
public Object getObjectFromNameClassPair(NameClassPair nameClassPair) {
if (!(nameClassPair instanceof Binding)) {
throw new IllegalArgumentException("Parameter must be an instance of Binding");
}
Binding binding = (Binding) nameClassPair;
Object object = binding.getObject();
if (object == null) {
throw new ObjectRetrievalException(
"Binding did not contain any object.");
}
return mapper.mapFromContext(object);
}
} ././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AttributeModificationsAware.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002330 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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 javax.naming.directory.ModificationItem;
/**
* Indicates that the implementing class is capable of keeping track of any
* attribute modifications and return them as ModificationItems.
*
* @author Mattias Hellborg Arthursson
*
*/
public interface AttributeModificationsAware {
/**
* Creates an array of which attributes have been changed, added or removed
* since the initialization of this object.
*
* @return an array of modification items.
*/
ModificationItem[] getModificationItems();
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NotContextException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001755 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NotContextException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NotContextException
*/
public class NotContextException extends NamingException {
public NotContextException(javax.naming.NotContextException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/SizeLimitExceededException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002045 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI SizeLimitExceededException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.SizeLimitExceededException
*/
public class SizeLimitExceededException extends LimitExceededException {
public SizeLimitExceededException(
javax.naming.SizeLimitExceededException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/support/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000220 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/support/AttributeValueCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002205 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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.support;
/**
* Callback interface for use when looping through Attribute values.
*
* @author Mattias Hellborg Arthursson
* @since 1.3
*/
public interface AttributeValueCallbackHandler {
/**
* Implement to take handle one of the Attribute values.
*
* @param attributeName the name of the Attribute.
* @param attributeValue the value.
* @param index the index of the value within the Attribute.
*/
void handleAttributeValue(String attributeName, Object attributeValue, int index);
}
././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/support/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000110 11475313376 030201 0 ustar
* The {@link Control} feature is specific for LDAP v3 and thus applies only
* to {@link LdapContext}. However, the generic DirContextProcessor
* mechanism used for calling
* Note: The
* Note 1: If the definition is in XML you will need to properly encode any special characters so that they are valid in an XML file,
* e.g. "&" needs to be encoded as "&", e.g.
*
* Note 2: There will be no validation to ensure that the supplied filter is
* valid. Using this implementation to build filters from user input is strongly
* discouraged.
*
* The actual operations performed by the respective methods of this class might
* not be what would originally be expected. E.g. one would expect that the
* {@link #performOperation()} method of a
* CompensatingTransactionOperationExecutor implementation would actually delete
* the entry, leaving it for the {@link #rollback()} method to recreate it using
* data from the original entry. However, this will not always be possible. In
* an LDAP system, for instance, it might not be possible to retrieve all the
* stored data from the original entry. In that case, the
* {@link #performOperation()} method will instead move the entry to a temporary
* location and leave it for the {@link #commit()} method to actually remove the
* entry.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface CompensatingTransactionOperationExecutor {
/**
* Rollback the operation, restoring state of the target as it was before
* the operation was performed using the information supplied on creation of
* this instance.
*/
void rollback();
/**
* Commit the operation. In many cases, this will not require any work at
* all to be performed. However, in some cases there will be interesting
* stuff to do. See class description for elaboration on this.
*/
void commit();
/**
* Perform the operation. This will most often require performing the
* recorded operation, but in some cases the actual operation performed by
* this method might be something else. See class description for
* elaboration on this.
*/
void performOperation();
}
libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/ 0002755 0000000 0000000 00000000000 11475313400 024241 5 ustar libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/overview.html 0000644 0000000 0000000 00000001012 11475313400 026765 0 ustar
This series of packages provides an LDIF parser utility compliant with
"RFC 2849 : The LDAP Data Interchange Format (LDIF) - Technical Specification".
libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/ 0002755 0000000 0000000 00000000000 11475313400 025030 5 ustar ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0002755 0000000 0000000 00000000000 11475313400 030171 5 ustar ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ldap/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0002755 0000000 0000000 00000000000 11475313400 030171 5 ustar ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ldap/core/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0002755 0000000 0000000 00000000000 11475313400 030171 5 ustar ././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ldap/core/LdapAttribute.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0000644 0000000 0000000 00000015203 11475313400 030172 0 ustar /*
* Copyright 2005-2010 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.
*
* 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
* 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.
*
* 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
Notable classes in this package include:
* 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.
*
* 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;
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000235 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ldap/ldif/support/DefaultAttributeValidationPolicy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0000644 0000000 0000000 00000033362 11475313400 030200 0 ustar /*
* Copyright 2005-2010 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.
*
* Ensures attributes meets one of three prescribed patterns for valid attributes:
*
* 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);
Listfalse.
*
* @param shutdownTlsGracefully true to shut down the TLS
* connection explicitly, false closes the target context
* immediately.
*/
public void setShutdownTlsGracefully(boolean shutdownTlsGracefully) {
this.shutdownTlsGracefully = shutdownTlsGracefully;
}
/**
* Set the optional
* HostnameVerifier to use for verifying incoming certificates. Defaults to null
* , meaning that the default hostname verification will take place.
*
* @param hostnameVerifier The HostnameVerifier to use, if any.
*/
public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {
this.hostnameVerifier = hostnameVerifier;
}
/**
* Sets the optional SSL socket factory used for startTLS negotiation.
* Defaults to null to indicate that the default socket factory
* provided by the underlying JSSE provider should be used.
* @param sslSocketFactory SSL socket factory to use, if any.
*/
public void setSslSocketFactory(final SSLSocketFactory sslSocketFactory) {
this.sslSocketFactory = sslSocketFactory;
}
/* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#setupEnvironment(java.util.Hashtable, java.lang.String, java.lang.String)
*/
public final void setupEnvironment(Hashtable env, String userDn, String password) {
// Nothing to do in this implementation - authentication should take
// place after TLS has been negotiated.
}
/* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#processContextAfterCreation(javax.naming.directory.DirContext, java.lang.String, java.lang.String)
*/
public final DirContext processContextAfterCreation(DirContext ctx, String userDn, String password)
throws NamingException {
if (ctx instanceof LdapContext) {
final LdapContext ldapCtx = (LdapContext) ctx;
final StartTlsResponse tlsResponse = (StartTlsResponse) ldapCtx.extendedOperation(new StartTlsRequest());
try {
if (hostnameVerifier != null) {
tlsResponse.setHostnameVerifier(hostnameVerifier);
}
tlsResponse.negotiate(sslSocketFactory); // If null, the default SSL socket factory is used
applyAuthentication(ldapCtx, userDn, password);
if (shutdownTlsGracefully) {
// Wrap the target context in a proxy to intercept any calls
// to 'close', so that we can shut down the TLS connection
// gracefully first.
return (DirContext) Proxy.newProxyInstance(DirContextProxy.class.getClassLoader(), new Class[] {
LdapContext.class, DirContextProxy.class }, new TlsAwareDirContextProxy(ldapCtx,
tlsResponse));
}
else {
return ctx;
}
}
catch (IOException e) {
LdapUtils.closeContext(ctx);
throw new UncategorizedLdapException("Failed to negotiate TLS session", e);
}
}
else {
throw new IllegalArgumentException(
"Processed Context must be an LDAPv3 context, i.e. an LdapContext implementation");
}
}
/**
* Apply the actual authentication to the specified LdapContext
* . Typically, this will involve adding stuff to the environment.
*
* @param ctx the LdapContext instance.
* @param userDn the user dn of the user to authenticate.
* @param password the password of the user to authenticate.
* @throws NamingException if any error occurs.
*/
protected abstract void applyAuthentication(LdapContext ctx, String userDn, String password) throws NamingException;
private static final class TlsAwareDirContextProxy implements DirContextProxy, InvocationHandler {
private static final String GET_TARGET_CONTEXT_METHOD_NAME = "getTargetContext";
private static final String CLOSE_METHOD_NAME = "close";
private final LdapContext target;
private final StartTlsResponse tlsResponse;
public TlsAwareDirContextProxy(LdapContext target, StartTlsResponse tlsResponse) {
this.target = target;
this.tlsResponse = tlsResponse;
}
public DirContext getTargetContext() {
return target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals(CLOSE_METHOD_NAME)) {
tlsResponse.close();
return method.invoke(target, args);
}
else if (method.getName().equals(GET_TARGET_CONTEXT_METHOD_NAME)) {
return target;
}
else {
return method.invoke(target, args);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/BaseLdapPathAware.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003614 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.ldap.core.DistinguishedName;
/**
* Interface to be implemented by classes that want to have access to the base
* context used in the active ContextSource. There are several
* cases in which services may want to have access to the base context, e.g.
* when working with groups (groupOfNames objectclass), in which
* case the full DN of each group member needs to be specified in the attribute
* value.
* ApplicationContext, the default base path will automatically
* passed to the {@link #setBaseLdapPath(DistinguishedName)} method on
* initialization.
* ContextSource needs to be a subclass of
* {@link AbstractContextSource} for this mechanism to work.
*
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface BaseLdapPathAware {
/**
* Set the base LDAP path specified in the current
* ApplicationContext.
* @param baseLdapPath the base path used in the ContextSource
*/
void setBaseLdapPath(DistinguishedName baseLdapPath);
}
././@LongLink 0000000 0000000 0000000 00000000241 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/DigestMd5DirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003607 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.directory.DirContext;
/**
* Authentication strategy for LDAP DIGEST-MD5 SASL mechanism.
*
* @author Marvin S. Addison
* @since 1.3.1
*/
public class DigestMd5DirContextAuthenticationStrategy implements DirContextAuthenticationStrategy {
/** Authentication type for DIGEST-MD5 auth */
private static final String DIGEST_MD5_AUTHENTICATION = "DIGEST-MD5";
/*
* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#processContextAfterCreation(javax.naming.directory.DirContext,
* java.lang.String, java.lang.String)
*/
public DirContext processContextAfterCreation(DirContext ctx, String userDn, String password) {
return ctx;
}
/*
* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#setupEnvironment(java.util.Hashtable,
* java.lang.String, java.lang.String)
*/
public void setupEnvironment(Hashtable env, String userDn, String password) {
env.put(Context.SECURITY_AUTHENTICATION, DIGEST_MD5_AUTHENTICATION);
// userDn should be a bare username for DIGEST-MD5
env.put(Context.SECURITY_PRINCIPAL, userDn);
env.put(Context.SECURITY_CREDENTIALS, password);
}
}
././@LongLink 0000000 0000000 0000000 00000000215 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/AbstractContextMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004121 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.ldap.core.ContextMapper;
import org.springframework.ldap.core.DirContextOperations;
/**
* Abstract superclass that may be used instead of implementing
* {@link ContextMapper} directly. Subclassing from this superclass, the
* supplied context will be automatically cast to
* DirContextOperations. Note that if you use your own
* DirObjectFactory, this implementation will fail with a
* ClassCastException.
*
* @author Mattias Hellborg Arthursson
*
*/
public abstract class AbstractContextMapper implements ContextMapper {
/**
* {@inheritDoc}
*
* @throws ClassCastException
* if a custom DirObjectFactory implementation is
* used, causing the objects passed in be anything else than
* {@link DirContextOperations} instances.
*/
public final Object mapFromContext(Object ctx) {
return doMapFromContext((DirContextOperations) ctx);
}
/**
* Map a single DirContextOperation to an object. The
* supplied instance is the object supplied to
* {@link #mapFromContext(Object)} cast to a
* DirContextOperations.
*
* @param ctx
* the context to map to an object.
* @return an object built from the data in the context.
*/
protected abstract Object doMapFromContext(DirContextOperations ctx);
}
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000125 11475313376 030207 0 ustar
name is normally a JNDI CompositeName, which
* needs to be handled with particuclar care. Specifically the escaping of a
* CompositeName destroys proper escaping of Distinguished
* Names. Also, the name might contain referral information, in which case
* we need to separate the server information from the actual Distinguished
* Name so that we can create a representing DirContextAdapter.
*
* @param attrs the attributes
* @param name the Name, typically a CompositeName, possibly
* including referral information.
* @param nameInNamespace the Name in namespace.
* @return a {@link DirContextAdapter} representing the specified
* information.
*/
DirContextAdapter constructAdapterFromName(Attributes attrs, Name name, String nameInNamespace) {
String nameString = "";
String referralUrl = "";
if (name instanceof CompositeName) {
// Which it most certainly will be, and therein lies the
// problem. CompositeName.toString() completely screws up the
// formatting
// in some cases, particularly when backslashes are involved.
nameString = LdapUtils
.convertCompositeNameToString((CompositeName) name);
}
else {
log
.warn("Expecting a CompositeName as input to getObjectInstance but received a '"
+ name.getClass().toString()
+ "' - using toString and proceeding with undefined results");
nameString = name.toString();
}
if (nameString.startsWith(LDAP_PROTOCOL_PREFIX) || nameString.startsWith(LDAPS_PROTOCOL_PREFIX)) {
if (log.isDebugEnabled()) {
log.debug("Received name '" + nameString + "' contains protocol delimiter; indicating a referral."
+ "Stripping protocol and address info to enable construction of a proper DistinguishedName");
}
try {
URI url = new URI(nameString);
String pathString = url.getPath();
referralUrl = nameString.substring(0, nameString.length() - pathString.length());
if (StringUtils.hasLength(pathString) && pathString.startsWith("/")) {
// We don't want any slash in the beginning of the
// Distinguished Name.
pathString = pathString.substring(1);
}
nameString = pathString;
}
catch (URISyntaxException e) {
if (JdkVersion.isAtLeastJava15()) {
throw new IllegalArgumentException(
"Supplied name starts with protocol prefix indicating a referral,"
+ " but is not possible to parse to an URI",
e);
} else {
throw new IllegalArgumentException(
"Supplied name starts with protocol prefix indicating a referral,"
+ " but is not possible to parse to an URI: " +
e.getMessage());
}
}
if (log.isDebugEnabled()) {
log.debug("Resulting name after removal of referral information: '" + nameString + "'");
}
}
DirContextAdapter dirContextAdapter = new DirContextAdapter(attrs, new DistinguishedName(nameString),
new DistinguishedName(nameInNamespace), referralUrl);
dirContextAdapter.setUpdateMode(true);
return dirContextAdapter;
}
/*
* (non-Javadoc)
*
* @see javax.naming.spi.ObjectFactory#getObjectInstance(java.lang.Object,
* javax.naming.Name, javax.naming.Context, java.util.Hashtable)
*/
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable environment) throws Exception {
return null;
}
}
././@LongLink 0000000 0000000 0000000 00000000242 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/DefaultTlsDirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003205 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.support;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.ldap.LdapContext;
/**
* Default implementation of TLS authentication. Applies SIMPLE
* authentication on top of the negotiated TLS session. Refer to
* {@link AbstractTlsDirContextAuthenticationStrategy} for configuration
* options.
*
* @author Mattias Hellborg Arthursson
* @see AbstractTlsDirContextAuthenticationStrategy
* @see AbstractContextSource
*/
public class DefaultTlsDirContextAuthenticationStrategy extends AbstractTlsDirContextAuthenticationStrategy {
private static final String SIMPLE_AUTHENTICATION = "simple";
protected void applyAuthentication(LdapContext ctx, String userDn, String password) throws NamingException {
ctx.addToEnvironment(Context.SECURITY_AUTHENTICATION, SIMPLE_AUTHENTICATION);
ctx.addToEnvironment(Context.SECURITY_PRINCIPAL, userDn);
ctx.addToEnvironment(Context.SECURITY_CREDENTIALS, password);
}
}
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/BaseLdapPathContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001722 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.ldap.core.ContextSource;
/**
* Interface to be implemented by ContextSources that are capable
* of providing the base LDAP path.
*
* @author Mattias Hellborg Arthursson
*/
public interface BaseLdapPathContextSource extends ContextSource, BaseLdapPathSource {
}
././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/SingleContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000011571 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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.support;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import javax.naming.directory.DirContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.NamingException;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.DirContextProxy;
import org.springframework.ldap.support.LdapUtils;
import org.springframework.beans.factory.DisposableBean;
/**
* A {@link ContextSource} to be used as a decorator around a target ContextSource
* to make sure the target is never actually closed. Useful when working with e.g. paged results,
* as these require the same target to be used.
*
* @author Mattias Hellborg Arthursson
*/
public class SingleContextSource implements ContextSource, DisposableBean {
private static final Log log = LogFactory.getLog(SingleContextSource.class);
private final DirContext ctx;
/**
* Constructor.
*
* @param ctx the target DirContext.
*/
public SingleContextSource(DirContext ctx) {
this.ctx = ctx;
}
/*
* @see org.springframework.ldap.ContextSource#getReadOnlyContext()
*/
public DirContext getReadOnlyContext() throws NamingException {
return getNonClosingDirContextProxy(ctx);
}
/*
* @see org.springframework.ldap.ContextSource#getReadWriteContext()
*/
public DirContext getReadWriteContext() throws NamingException {
return getNonClosingDirContextProxy(ctx);
}
private DirContext getNonClosingDirContextProxy(DirContext context) {
return (DirContext) Proxy.newProxyInstance(DirContextProxy.class
.getClassLoader(), new Class[]{
LdapUtils.getActualTargetClass(context),
DirContextProxy.class},
new SingleContextSource.NonClosingDirContextInvocationHandler(
context));
}
public DirContext getContext(String principal, String credentials)
throws NamingException {
throw new UnsupportedOperationException(
"Not a valid operation for this type of ContextSource");
}
/**
* Destroy method that allows the target DirContext to be cleaned up when
* the SingleContextSource is not going to be used any more.
*/
public void destroy() {
try {
ctx.close();
}
catch (javax.naming.NamingException e) {
log.warn(e);
}
}
/**
* A proxy for DirContext forwarding all operation to the target DirContext,
* but making sure that no close operations will be performed.
*
* @author Mattias Hellborg Arthursson
*/
public static class NonClosingDirContextInvocationHandler implements
InvocationHandler {
private DirContext target;
public NonClosingDirContextInvocationHandler(DirContext target) {
this.target = target;
}
/*
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,
* java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
String methodName = method.getName();
if (methodName.equals("getTargetContext")) {
return target;
} else if (methodName.equals("equals")) {
// Only consider equal when proxies are identical.
return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
} else if (methodName.equals("hashCode")) {
// Use hashCode of Connection proxy.
return new Integer(proxy.hashCode());
} else if (methodName.equals("close")) {
// Never close the target context, as this class will only be
// used for operations concerning the compensating transactions.
return null;
}
try {
return method.invoke(target, args);
}
catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
}
} ././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/AggregateDirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006031 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.springframework.ldap.core.DirContextProcessor;
/**
* Manages a sequence of {@link DirContextProcessor} instances. Applies
* {@link #preProcess(DirContext)} and {@link #postProcess(DirContext)}
* respectively in sequence on the managed objects.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public class AggregateDirContextProcessor implements DirContextProcessor {
private List dirContextProcessors = new LinkedList();
/**
* Add the supplied DirContextProcessor to the list of managed objects.
*
* @param processor
* the DirContextpProcessor to add.
*/
public void addDirContextProcessor(DirContextProcessor processor) {
dirContextProcessors.add(processor);
}
/**
* Get the list of managed {@link DirContextProcessor} instances.
*
* @return the managed list of {@link DirContextProcessor} instances.
*/
public List getDirContextProcessors() {
return dirContextProcessors;
}
/**
* Set the list of managed {@link DirContextProcessor} instances.
*
* @param dirContextProcessors
* the list of {@link DirContextProcessor} instances to set.
*/
public void setDirContextProcessors(List dirContextProcessors) {
this.dirContextProcessors = dirContextProcessors;
}
/*
* @see org.springframework.ldap.core.DirContextProcessor#preProcess(javax.naming.directory.DirContext)
*/
public void preProcess(DirContext ctx) throws NamingException {
for (Iterator iter = dirContextProcessors.iterator(); iter.hasNext();) {
DirContextProcessor processor = (DirContextProcessor) iter.next();
processor.preProcess(ctx);
}
}
/*
* @see org.springframework.ldap.core.DirContextProcessor#postProcess(javax.naming.directory.DirContext)
*/
public void postProcess(DirContext ctx) throws NamingException {
for (Iterator iter = dirContextProcessors.iterator(); iter.hasNext();) {
DirContextProcessor processor = (DirContextProcessor) iter.next();
processor.postProcess(ctx);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/LdapContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003133 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Hashtable;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.InitialLdapContext;
/**
* ContextSource implementation which creates an InitialLdapContext
* instance. For configuration information, see
* {@link org.springframework.ldap.core.support.AbstractContextSource AbstractContextSource}.
*
* @see org.springframework.ldap.core.support.AbstractContextSource
*
* @author Mattias Hellborg Arthursson
* @author Adam Skogman
* @author Ulrik Sandberg
*/
public class LdapContextSource extends AbstractContextSource {
/*
* @see org.springframework.ldap.support.AbstractContextSource#getDirContextInstance(java.util.Hashtable)
*/
protected DirContext getDirContextInstance(Hashtable environment)
throws NamingException {
return new InitialLdapContext(environment, null);
}
}
././@LongLink 0000000 0000000 0000000 00000000225 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/BaseLdapPathBeanPostProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000012262 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.util.StringUtils;
/**
* This BeanPostProcessor checks each bean if it implements
* {@link BaseLdapPathAware}. If it does, the default context base LDAP path
* will be determined, and that value will be injected to the
* {@link BaseLdapPathAware#setBaseLdapPath(DistinguishedName)} method of the
* processed bean.
* baseLdapPath property of this
* BeanPostProcessor is set, that value will be used. Otherwise, in
* order to determine which base LDAP path to supply to the instance the
* ApplicationContext is searched for any beans that are
* implementations of {@link BaseLdapPathSource}. If one single occurrence is
* found, that instance is queried for its base path, and that is what will be
* injected. If more than one {@link BaseLdapPathSource} instance is configured
* in the ApplicationContext, the name of the one to use will need
* to be specified to the baseLdapPathSourceName property;
* otherwise the post processing will fail. If no {@link BaseLdapPathSource}
* implementing bean is found in the context and the basePath
* property is not set, post processing will also fail.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class BaseLdapPathBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
private ApplicationContext applicationContext;
private DistinguishedName basePath;
private String baseLdapPathSourceName;
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof BaseLdapPathAware) {
BaseLdapPathAware baseLdapPathAware = (BaseLdapPathAware) bean;
if (basePath != null) {
baseLdapPathAware.setBaseLdapPath(basePath);
}
else {
BaseLdapPathSource ldapPathSource = getBaseLdapPathSourceFromApplicationContext();
baseLdapPathAware.setBaseLdapPath(ldapPathSource.getBaseLdapPath().immutableDistinguishedName());
}
}
return bean;
}
BaseLdapPathSource getBaseLdapPathSourceFromApplicationContext() {
if (StringUtils.hasLength(baseLdapPathSourceName)) {
return (BaseLdapPathSource) applicationContext.getBean(baseLdapPathSourceName);
}
String[] definedContextSources = applicationContext.getBeanNamesForType(BaseLdapPathSource.class);
if (definedContextSources.length < 1) {
throw new NoSuchBeanDefinitionException("No BaseLdapPathSource implementation definition found");
}
else if (definedContextSources.length > 1) {
throw new NoSuchBeanDefinitionException(
"More than BaseLdapPathSource implementation definition found in current ApplicationContext");
}
return (BaseLdapPathSource) applicationContext.getBean(definedContextSources[0]);
}
/*
* (non-Javadoc)
*
* @seeorg.springframework.beans.factory.config.BeanPostProcessor#
* postProcessAfterInitialization(java.lang.Object, java.lang.String)
*/
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
// Do nothing for this implementation
return bean;
}
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
/**
* Set the base path to be injected in all {@link BaseLdapPathAware} beans.
* If this property is not set, the default base path will be determined
* from any defined {@link BaseLdapPathSource} instances available in the
* ApplicationContext.
*
* @param basePath the base path.
*/
public void setBasePath(DistinguishedName basePath) {
this.basePath = basePath.immutableDistinguishedName();
}
/**
* Set the name of the ContextSource bean to use for getting
* the base path. This method is typically useful if several ContextSource
* instances have been configured.
*
* @param contextSourceName the name of the ContextSource bean
* to use for determining the base path.
*/
public void setBaseLdapPathSourceName(String contextSourceName) {
this.baseLdapPathSourceName = contextSourceName;
}
}
././@LongLink 0000000 0000000 0000000 00000000243 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/ExternalTlsDirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002076 11475313376 030216 0 ustar package org.springframework.ldap.core.support;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.ldap.LdapContext;
/**
* {@link DirContextAuthenticationStrategy} for using TLS and external (SASL)
* authentication. This implementation requires a client certificate to be
* pointed out using system variables, as described here. Refer to {@link AbstractTlsDirContextAuthenticationStrategy} for
* other configuration options.
*
* @author Mattias Hellborg Arthursson
* @see AbstractTlsDirContextAuthenticationStrategy
* @see AbstractContextSource
*/
public class ExternalTlsDirContextAuthenticationStrategy extends AbstractTlsDirContextAuthenticationStrategy {
private static final String EXTERNAL_AUTHENTICATION = "EXTERNAL";
protected void applyAuthentication(LdapContext ctx, String userDn, String password) throws NamingException {
ctx.addToEnvironment(Context.SECURITY_AUTHENTICATION, EXTERNAL_AUTHENTICATION);
}
}
././@LongLink 0000000 0000000 0000000 00000000236 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/SimpleDirContextAuthenticationStrategy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004120 11475313376 030206 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.directory.DirContext;
/**
* The default {@link DirContextAuthenticationStrategy} implementation, setting
* the DirContext environment up for 'SIMPLE' authentication, and
* specifying the user DN and password as SECURITY_PRINCIPAL and
* SECURITY_CREDENTIALS respectively in the authenticated environment before the
* context is created.
*
* @author Mattias Hellborg Arthursson
*/
public class SimpleDirContextAuthenticationStrategy implements DirContextAuthenticationStrategy {
private static final String SIMPLE_AUTHENTICATION = "simple";
/*
* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#setupEnvironment(java.util.Hashtable,
* java.lang.String, java.lang.String)
*/
public void setupEnvironment(Hashtable env, String userDn, String password) {
env.put(Context.SECURITY_AUTHENTICATION, SIMPLE_AUTHENTICATION);
env.put(Context.SECURITY_PRINCIPAL, userDn);
env.put(Context.SECURITY_CREDENTIALS, password);
}
/*
* (non-Javadoc)
* @see org.springframework.ldap.core.support.DirContextAuthenticationStrategy#processContextAfterCreation(javax.naming.directory.DirContext,
* java.lang.String, java.lang.String)
*/
public DirContext processContextAfterCreation(DirContext ctx, String userDn, String password) {
return ctx;
}
}
././@LongLink 0000000 0000000 0000000 00000000215 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/AbstractContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000044754 11475313376 030227 0 ustar /*
* Copyright 2005-2010 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.support;
import java.util.Hashtable;
import java.util.Map;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.apache.commons.lang.ArrayUtils;
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.JdkVersion;
import org.springframework.ldap.core.AuthenticationSource;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.support.LdapUtils;
/**
* Abstract implementation of the {@link ContextSource} interface. By default,
* returns an authenticated
* DirContext implementation for both read-only and
* read-write operations. To have an anonymous environment created for read-only
* operations, set the anonymousReadOnly property to
* true.
* DirContext
* instance of the desired type.
* userDn and password.
* PROVIDER_URL to the environment.
*
* @param ldapUrls all individual url Strings.
* @return the full url String
*/
protected String assembleProviderUrlString(String[] ldapUrls) {
StringBuffer providerUrlBuffer = new StringBuffer(1024);
for (int i = 0; i < ldapUrls.length; i++) {
providerUrlBuffer.append(ldapUrls[i]);
if (!DistinguishedName.EMPTY_PATH.equals(base)) {
if (!ldapUrls[i].endsWith("/")) {
providerUrlBuffer.append("/");
}
}
providerUrlBuffer.append(base.toUrl());
providerUrlBuffer.append(' ');
}
return providerUrlBuffer.toString().trim();
}
/**
* Set the base suffix from which all operations should origin. If a base
* suffix is set, you will not have to (and, indeed, must not) specify the
* full distinguished names in any operations performed.
*
* @param base the base suffix.
*/
public void setBase(String base) {
this.base = new DistinguishedName(base);
}
/**
* Get the base suffix from which all operations should originate. If a base
* suffix is set, you will not have to (and, indeed, must not) specify the
* full distinguished names in any operations performed.
*
* @return the base suffix
*/
protected DistinguishedName getBase() {
return new DistinguishedName(base);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.support.BaseLdapPathSource#getBaseLdapPath
* ()
*/
public DistinguishedName getBaseLdapPath() {
return getBase().immutableDistinguishedName();
}
/*
* (non-Javadoc)
*
* @seeorg.springframework.ldap.core.support.BaseLdapPathSource#
* getBaseLdapPathAsString()
*/
public String getBaseLdapPathAsString() {
return getBaseLdapPath().toString();
}
/**
* Create a DirContext using the supplied environment.
*
* @param environment the LDAP environment to use when creating the
* DirContext.
* @return a new DirContext implementation initialized with the supplied
* environment.
*/
protected DirContext createContext(Hashtable environment) {
DirContext ctx = null;
try {
ctx = getDirContextInstance(environment);
if (log.isInfoEnabled()) {
Hashtable ctxEnv = ctx.getEnvironment();
String ldapUrl = (String) ctxEnv.get(Context.PROVIDER_URL);
log.debug("Got Ldap context on server '" + ldapUrl + "'");
}
return ctx;
}
catch (NamingException e) {
closeContext(ctx);
throw LdapUtils.convertLdapException(e);
}
}
/**
* Set the context factory. Default is com.sun.jndi.ldap.LdapCtxFactory.
*
* @param contextFactory the context factory used when creating Contexts.
*/
public void setContextFactory(Class contextFactory) {
this.contextFactory = contextFactory;
}
/**
* Get the context factory.
*
* @return the context factory used when creating Contexts.
*/
public Class getContextFactory() {
return contextFactory;
}
/**
* Set the DirObjectFactory to use. Default is
* {@link DefaultDirObjectFactory}. The specified class needs to be an
* implementation of javax.naming.spi.DirObjectFactory. Note: Setting
* this value to null may have cause connection leaks when using
* ContextMapper methods in LdapTemplate.
*
* @param dirObjectFactory the DirObjectFactory to be used. Null means that
* no DirObjectFactory will be used.
*/
public void setDirObjectFactory(Class dirObjectFactory) {
this.dirObjectFactory = dirObjectFactory;
}
/**
* Get the DirObjectFactory to use.
*
* @return the DirObjectFactory to be used. null means that no
* DirObjectFactory will be used.
*/
public Class getDirObjectFactory() {
return dirObjectFactory;
}
/**
* Checks that all necessary data is set and that there is no compatibility
* issues, after which the instance is initialized. Note that you need to
* call this method explicitly after setting all desired properties if using
* the class outside of a Spring Context.
*/
public void afterPropertiesSet() throws Exception {
if (ArrayUtils.isEmpty(urls)) {
throw new IllegalArgumentException("At least one server url must be set");
}
if (!DistinguishedName.EMPTY_PATH.equals(base) && getJdkVersion().compareTo(JDK_142) < 0) {
throw new IllegalArgumentException("Base path is not supported for JDK versions < 1.4.2");
}
if (authenticationSource == null) {
log.debug("AuthenticationSource not set - " + "using default implementation");
if (StringUtils.isBlank(userDn)) {
log.info("Property 'userDn' not set - " + "anonymous context will be used for read-write operations");
}
else if (StringUtils.isBlank(password)) {
log.info("Property 'password' not set - " + "blank password will be used");
}
authenticationSource = new SimpleAuthenticationSource();
}
if (cacheEnvironmentProperties) {
anonymousEnv = setupAnonymousEnv();
}
}
private Hashtable setupAnonymousEnv() {
if (pooled) {
baseEnv.put(SUN_LDAP_POOLING_FLAG, "true");
log.debug("Using LDAP pooling.");
}
else {
baseEnv.remove(SUN_LDAP_POOLING_FLAG);
log.debug("Not using LDAP pooling");
}
Hashtable env = new Hashtable(baseEnv);
env.put(Context.INITIAL_CONTEXT_FACTORY, contextFactory.getName());
env.put(Context.PROVIDER_URL, assembleProviderUrlString(urls));
if (dirObjectFactory != null) {
env.put(Context.OBJECT_FACTORIES, dirObjectFactory.getName());
}
if (!StringUtils.isBlank(referral)) {
env.put(Context.REFERRAL, referral);
}
if (!DistinguishedName.EMPTY_PATH.equals(base)) {
// Save the base path for use in the DefaultDirObjectFactory.
env.put(DefaultDirObjectFactory.JNDI_ENV_BASE_PATH_KEY, base);
}
log.debug("Trying provider Urls: " + assembleProviderUrlString(urls));
return env;
}
/**
* Set the password (credentials) to use for getting authenticated contexts.
*
* @param password the password.
*/
public void setPassword(String password) {
this.password = password;
}
/**
* Set the user distinguished name (principal) to use for getting
* authenticated contexts.
*
* @param userDn the user distinguished name.
*/
public void setUserDn(String userDn) {
this.userDn = userDn;
}
/**
* Set the urls of the LDAP servers. Use this method if several servers are
* required.
*
* @param urls the urls of all servers.
*/
public void setUrls(String[] urls) {
this.urls = (String[]) urls.clone();
}
/**
* Get the urls of the LDAP servers.
*
* @return the urls of all servers.
*/
public String[] getUrls() {
return (String[]) urls.clone();
}
/**
* Set the url of the LDAP server. Utility method if only one server is
* used.
*
* @param url the url of the LDAP server.
*/
public void setUrl(String url) {
this.urls = new String[] { url };
}
/**
* Set whether the pooling flag should be set, enabling the built-in LDAP
* connection pooling. Default is false. The built-in LDAP
* connection pooling suffers from a number of deficiencies, e.g. no
* connection validation. Also, enabling this flag when using TLS
* connections will explicitly not work. Consider using the Spring LDAP
* PoolingContextSource as an alternative instead of enabling
* this flag.
* true; setting this
* property to false causes the environment Hashmap to be
* rebuilt from the current property settings of this instance between each
* request for an anonymous environment.
*
* @param cacheEnvironmentProperties true causes that the
* anonymous environment properties should be cached, false
* causes the Hashmap to be rebuilt for each request.
*/
public void setCacheEnvironmentProperties(boolean cacheEnvironmentProperties) {
this.cacheEnvironmentProperties = cacheEnvironmentProperties;
}
/**
* Set whether an anonymous environment should be used for read-only
* operations. Default is false.
*
* @param anonymousReadOnly true if an anonymous environment
* should be used for read-only operations, false otherwise.
*/
public void setAnonymousReadOnly(boolean anonymousReadOnly) {
this.anonymousReadOnly = anonymousReadOnly;
}
/**
* Get whether an anonymous environment should be used for read-only
* operations.
*
* @return true if an anonymous environment should be used for
* read-only operations, false otherwise.
*/
public boolean isAnonymousReadOnly() {
return anonymousReadOnly;
}
/**
* Set the {@link DirContextAuthenticationStrategy} to use for preparing the
* environment and processing the created DirContext instances.
*
* @param authenticationStrategy the
* {@link DirContextAuthenticationStrategy} to use; default is
* {@link SimpleDirContextAuthenticationStrategy}.
*/
public void setAuthenticationStrategy(DirContextAuthenticationStrategy authenticationStrategy) {
this.authenticationStrategy = authenticationStrategy;
}
/**
* Set the method to handle referrals. Default is 'ignore'; setting this
* flag to 'follow' will enable referrals to be automatically followed. Note
* that this might require particular name server setup in order to work
* (the referred URLs will need to be automatically found using standard DNS
* resolution).
* @param referral the value to set the system property
* Context.REFERRAL to, customizing the way that referrals are
* handled.
*/
public void setReferral(String referral) {
this.referral = referral;
}
/**
* Implement in subclass to create a DirContext of the desired type (e.g.
* InitialDirContext or InitialLdapContext).
*
* @param environment the environment to use when creating the instance.
* @return a new DirContext instance.
* @throws NamingException if one is encountered when creating the instance.
*/
protected abstract DirContext getDirContextInstance(Hashtable environment) throws NamingException;
class SimpleAuthenticationSource implements AuthenticationSource {
public String getPrincipal() {
return userDn;
}
public String getCredentials() {
return password;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000220 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/LookupAttemptingCallback.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002004 11475313376 030205 0 ustar package org.springframework.ldap.core.support;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import org.springframework.ldap.core.AuthenticatedLdapEntryContextCallback;
import org.springframework.ldap.core.LdapEntryIdentification;
import org.springframework.ldap.support.LdapUtils;
/**
* Attempts to perform an LDAP operation in the authenticated context, because
* Active Directory might allow bind with incorrect password (specifically empty
* password), and later refuse operations. We want to fail fast when
* authenticating.
*
* @author Hugo Josefson
* @since 1.3.1
*/
public class LookupAttemptingCallback implements AuthenticatedLdapEntryContextCallback {
public void executeWithContext(DirContext ctx, LdapEntryIdentification ldapEntryIdentification) {
try {
ctx.lookup(ldapEntryIdentification.getRelativeDn());
}
catch (NamingException e) {
// rethrow, because we aren't allowed to throw checked exceptions.
throw LdapUtils.convertLdapException(e);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000231 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/CountNameClassPairCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003025 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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.support;
import javax.naming.NameClassPair;
import org.springframework.ldap.core.NameClassPairCallbackHandler;
/**
* A {@link NameClassPairCallbackHandler} for counting all returned entries.
*
* @author Mattias Hellborg Arthursson
*
*/
public class CountNameClassPairCallbackHandler implements
NameClassPairCallbackHandler {
private int noOfRows = 0;
/**
* Get the number of rows that was returned by the search.
*
* @return the number of entries that have been handled.
*/
public int getNoOfRows() {
return noOfRows;
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.SearchResultCallbackHandler#handleSearchResult(javax.naming.directory.SearchResult)
*/
public void handleNameClassPair(NameClassPair nameClassPair) {
noOfRows++;
}
}
././@LongLink 0000000 0000000 0000000 00000000212 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/support/BaseLdapPathSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002760 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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.support;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.DistinguishedName;
/**
* Implementations of this interface are capable of providing a base LDAP path.
* The base LDAP path is the root path to which all LDAP operations performed on
* a particular context are relative.
*
* @see ContextSource
*
* @author Mattias Hellborg Arthursson
*/
public interface BaseLdapPathSource {
/**
* Get the base LDAP path as a {@link DistinguishedName}.
*
* @return the base LDAP path as a {@link DistinguishedName}. The path will
* be empty if no base path is specified.
*/
DistinguishedName getBaseLdapPath();
/**
* Get the base LDAP path as a String.
*
* @return the base LDAP path as a An empty String will be returned if no
* base path is specified.
*/
String getBaseLdapPathAsString();
}
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ContextExecutor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003356 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NamingException;
import javax.naming.directory.DirContext;
/**
* Interface for delegating an actual operation to be performed on a
* DirContext. For searches, use {@link SearchExecutor} in
* stead. A typical usage of this interface could be e.g.:
*
*
* ContextExecutor executor = new ContextExecutor() {
* public Object executeWithContext(DirContext ctx) throws NamingException {
* return ctx.lookup(dn);
* }
* };
*
*
* @see LdapTemplate#executeReadOnly(ContextExecutor)
* @see LdapTemplate#executeReadWrite(ContextExecutor)
*
* @author Mattias Hellborg Arthursson
*/
public interface ContextExecutor {
/**
* Perform any operation on the context.
*
* @param ctx
* the DirContext to perform the operation on.
* @return any object resulting from the operation - might be null.
* @throws NamingException
* if the operation resulted in one.
*/
Object executeWithContext(DirContext ctx) throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000224 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapEntryIdentificationContextMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002273 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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;
/**
* ContextMapper implementation that maps the found entries to the
* {@link LdapEntryIdentification} of each respective entry.
*
* @author Mattias Hellborg Arthursson
* @since 1.3
*/
public class LdapEntryIdentificationContextMapper implements ContextMapper {
public Object mapFromContext(Object ctx) {
DirContextOperations adapter = (DirContextOperations) ctx;
return new LdapEntryIdentification(new DistinguishedName(adapter.getNameInNamespace()), new DistinguishedName(
adapter.getDn()));
}
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapOperations.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000213254 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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.List;
import javax.naming.Binding;
import javax.naming.Name;
import javax.naming.NameClassPair;
import javax.naming.directory.Attributes;
import javax.naming.directory.ModificationItem;
import javax.naming.directory.SearchControls;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.ldap.ContextNotEmptyException;
import org.springframework.ldap.NamingException;
import org.springframework.ldap.core.support.AbstractContextSource;
import org.springframework.ldap.support.LdapUtils;
/**
* Interface that specifies a basic set of LDAP operations. Implemented by
* LdapTemplate, but it might be a useful option to use this interface in order
* to enhance testability.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public interface LdapOperations {
/**
* Perform a search using a particular {@link SearchExecutor} and context
* processor. Use this method only if especially needed - for the most cases
* there is an overloaded convenience method which calls this one with
* suitable argments. This method handles all the plumbing; getting a
* readonly context; looping through the NamingEnumeration and
* closing the context and enumeration. The actual search is delegated to
* the SearchExecutor and each found NameClassPair is passed to
* the CallbackHandler. Any encountered
* NamingException will be translated using
* {@link LdapUtils#convertLdapException(javax.naming.NamingException)}.
*
* @param se The SearchExecutor to use for performing the
* actual search.
* @param handler The NameClassPairCallbackHandler to which
* each found entry will be passed.
* @param processor DirContextProcessor for custom pre- and
* post-processing.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted as no entries being found.
*/
void search(SearchExecutor se, NameClassPairCallbackHandler handler, DirContextProcessor processor)
throws NamingException;
/**
* Perform a search using a particular {@link SearchExecutor}. Use this
* method only if especially needed - for the most cases there is an
* overloaded convenience method which calls this one with suitable
* argments. This method handles all the plumbing; getting a readonly
* context; looping through the NamingEnumeration and closing
* the context and enumeration. The actual search is delegated to the
* SearchExecutor and each found NameClassPair is
* passed to the CallbackHandler. Any encountered
* NamingException will be translated using the
* {@link LdapUtils#convertLdapException(javax.naming.NamingException)}.
*
* @param se The SearchExecutor to use for performing the
* actual search.
* @param handler The NameClassPairCallbackHandler to which
* each found entry will be passed.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted as no entries being found.
* @see #search(Name, String, AttributesMapper)
* @see #search(Name, String, ContextMapper)
*/
void search(SearchExecutor se, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Perform an operation (or series of operations) on a read-only context.
* This method handles the plumbing - getting a DirContext,
* translating any Exceptions and closing the context afterwards. This
* method is not intended for searches; use
* {@link #search(SearchExecutor, NameClassPairCallbackHandler)} or any of
* the overloaded search methods for this.
*
* @param ce The ContextExecutor to which the actual operation
* on the DirContext will be delegated.
* @return the result from the ContextExecutor's operation.
* @throws NamingException if the operation resulted in a
* NamingException.
*
* @see #search(SearchExecutor, NameClassPairCallbackHandler)
* @see #search(Name, String, AttributesMapper)
* @see #search(Name, String, ContextMapper)
*/
Object executeReadOnly(ContextExecutor ce) throws NamingException;
/**
* Perform an operation (or series of operations) on a read-write context.
* This method handles the plumbing - getting a DirContext,
* translating any exceptions and closing the context afterwards. This
* method is intended only for very particular cases, where there is no
* suitable method in this interface to use.
*
* @param ce The ContextExecutor to which the actual operation
* on the DirContext will be delegated.
* @return the result from the ContextExecutor's operation.
* @throws NamingException if the operation resulted in a
* NamingException.
* @see #bind(Name, Object, Attributes)
* @see #unbind(Name)
* @see #rebind(Name, Object, Attributes)
* @see #rename(Name, Name)
* @see #modifyAttributes(Name, ModificationItem[])
*/
Object executeReadWrite(ContextExecutor ce) throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. The SearchScope
* specified in the supplied SearchControls will be used in the
* search. Note that if you are using a ContextMapper, the
* returningObjFlag needs to be set to true in the
* SearchControls.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResult to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(Name base, String filter, SearchControls controls, NameClassPairCallbackHandler handler)
throws NamingException;
/**
* Search for all objects matching the supplied filter. See
* {@link #search(Name, String, SearchControls, NameClassPairCallbackHandler)}
* for details.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResult to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(String base, String filter, SearchControls controls, NameClassPairCallbackHandler handler)
throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. The SearchScope
* specified in the supplied SearchControls will be used in the
* search. Note that if you are using a ContextMapper, the
* returningObjFlag needs to be set to true in the
* SearchControls. The given DirContextProcessor
* will be called before and after the search.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResult to.
* @param processor The DirContextProcessor to use before and
* after the search.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(Name base, String filter, SearchControls controls, NameClassPairCallbackHandler handler,
DirContextProcessor processor) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper. The SearchScope specified in
* the supplied SearchControls will be used in the search. The
* given DirContextProcessor will be called before and after
* the search.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @param processor The DirContextProcessor to use before and
* after the search.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, SearchControls controls, AttributesMapper mapper,
DirContextProcessor processor) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper. The SearchScope specified in
* the supplied SearchControls will be used in the search. The
* given DirContextProcessor will be called before and after
* the search.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @param processor The DirContextProcessor to use before and
* after the search.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, SearchControls controls, AttributesMapper mapper,
DirContextProcessor processor) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Object returned
* in each SearchResult is supplied to the specified
* ContextMapper. The SearchScope specified in the
* supplied SearchControls will be used in the search. The
* given DirContextProcessor will be called before and after
* the search.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search. If
* the returnObjFlag is not set in the SearchControls, this
* method will set it automatically, as this is required for the
* ContextMapper to work.
* @param mapper The ContextMapper to use for translating each
* entry.
* @param processor The DirContextProcessor to use before and
* after the search.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, SearchControls controls, ContextMapper mapper, DirContextProcessor processor)
throws NamingException;
/**
* Search for all objects matching the supplied filter. The Object returned
* in each SearchResult is supplied to the specified
* ContextMapper. The SearchScope specified in the
* supplied SearchControls will be used in the search. The
* given DirContextProcessor will be called before and after
* the search.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search. If
* the returnObjFlag is not set in the SearchControls, this
* method will set it automatically, as this is required for the
* ContextMapper to work.
* @param mapper The ContextMapper to use for translating each
* entry.
* @param processor The DirContextProcessor to use before and
* after the search.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, SearchControls controls, ContextMapper mapper, DirContextProcessor processor)
throws NamingException;
/**
* Search for all objects matching the supplied filter. See
* {@link #search(Name, String, SearchControls, NameClassPairCallbackHandler, DirContextProcessor)}
* for details.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResults to.
* @param processor The DirContextProcessor to use before and
* after the search.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(String base, String filter, SearchControls controls, NameClassPairCallbackHandler handler,
DirContextProcessor processor) throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. Use the specified values for
* search scope and return objects flag.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param returningObjFlag Whether the bound object should be returned in
* search results. Must be set to true if a
* ContextMapper is used.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResults to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(Name base, String filter, int searchScope, boolean returningObjFlag,
NameClassPairCallbackHandler handler) throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. Use the specified values for
* search scope and return objects flag.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param returningObjFlag Whether the bound object should be returned in
* search results. Must be set to true if a
* ContextMapper is used.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResults to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(String base, String filter, int searchScope, boolean returningObjFlag,
NameClassPairCallbackHandler handler) throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. The default Search scope (
* SearchControls.SUBTREE_SCOPE) will be used and the
* returnObjects flag will be set to false.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResults to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(Name base, String filter, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Search for all objects matching the supplied filter. Each
* SearchResult is supplied to the specified
* NameClassPairCallbackHandler. The default Search scope (
* SearchControls.SUBTREE_SCOPE) will be used and the
* returnObjects flag will be set to false.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param handler The NameClassPairCallbackHandler to supply
* the SearchResults to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void search(String base, String filter, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Search for all objects matching the supplied filter. Only return any
* attributes mathing the specified attribute names. The Attributes in each
* SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param attrs The attributes to return, null means returning
* all attributes.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, int searchScope, String[] attrs, AttributesMapper mapper)
throws NamingException;
/**
* Search for all objects matching the supplied filter. Only return any
* attributes mathing the specified attribute names. The Attributes in each
* SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param attrs The attributes to return, null means returning
* all attributes.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, int searchScope, String[] attrs, AttributesMapper mapper)
throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, int searchScope, AttributesMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, int searchScope, AttributesMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper. The default search scope will be used.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, AttributesMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes in
* each SearchResult is supplied to the specified
* AttributesMapper. The default search scope will be used.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* AttributesMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, AttributesMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper. Only return the
* supplied attributes.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param attrs The attributes to return, null means all
* attributes.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, int searchScope, String[] attrs, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper. Only return the
* supplied attributes.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param attrs The attributes to return, null means all
* attributes.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, int searchScope, String[] attrs, ContextMapper mapper)
throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, int searchScope, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param searchScope The search scope to set in SearchControls
* .
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, int searchScope, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper. The default search
* scope (SearchControls.SUBTREE_SCOPE) will be used.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper. The default search
* scope (SearchControls.SUBTREE_SCOPE) will be used.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The
* Object returned in each SearchResult is
* supplied to the specified ContextMapper. The default search
* scope (SearchControls.SUBTREE_SCOPE) will be used.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, SearchControls controls, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Object returned
* in each SearchResult is supplied to the specified
* ContextMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search. If
* the returnObjFlag is not set in the SearchControls, this
* method will set it automatically, as this is required for the
* ContextMapper to work.
* @param mapper The ContextMapper to use for translating each
* entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, SearchControls controls, ContextMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes
* returned in each SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(String base, String filter, SearchControls controls, AttributesMapper mapper) throws NamingException;
/**
* Search for all objects matching the supplied filter. The Attributes
* returned in each SearchResult is supplied to the specified
* AttributesMapper.
*
* @param base The base DN where the search should begin.
* @param filter The filter to use in the search.
* @param controls The SearchControls to use in the search.
* @param mapper The AttributesMapper to use for translating
* each entry.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List search(Name base, String filter, SearchControls controls, AttributesMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Each resulting NameClassPair is supplied
* to the specified NameClassPairCallbackHandler.
*
* @param base The base DN where the list should be performed.
* @param handler The NameClassPairCallbackHandler to supply
* each {@link NameClassPair} to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void list(String base, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Each resulting NameClassPair is supplied
* to the specified NameClassPairCallbackHandler.
*
* @param base The base DN where the list should be performed.
* @param handler The NameClassPairCallbackHandler to supply
* each {@link NameClassPair} to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void list(Name base, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Pass all the found NameClassPair objects
* to the supplied NameClassPairMapper and return all the
* returned values as a List.
*
* @param base The base DN where the list should be performed.
* @param mapper The NameClassPairMapper to supply each
* {@link NameClassPair} to.
* @return a List containing the Objects returned from the
* Mapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List list(String base, NameClassPairMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Pass all the found NameClassPair objects
* to the supplied NameClassPairMapper and return all the
* returned values as a List.
*
* @param base The base DN where the list should be performed.
* @param mapper The NameClassPairMapper to supply each
* {@link NameClassPair} to.
* @return a List containing the Objects returned from the
* Mapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List list(Name base, NameClassPairMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base.
*
* @param base The base DN where the list should be performed.
* @return a List containing the names of all the contexts bound to
* base.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List list(String base) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base.
*
* @param base The base DN where the list should be performed.
* @return a List containing the names of all the contexts bound to
* base.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List list(Name base) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Each resulting Binding is supplied to the
* specified NameClassPairCallbackHandler.
*
* @param base The base DN where the list should be performed.
* @param handler The NameClassPairCallbackHandler to supply
* each {@link Binding} to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void listBindings(final String base, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Each resulting Binding is supplied to the
* specified NameClassPairCallbackHandler.
*
* @param base The base DN where the list should be performed.
* @param handler The NameClassPairCallbackHandler to supply
* each {@link Binding} to.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
void listBindings(final Name base, NameClassPairCallbackHandler handler) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Pass all the found Binding objects to the
* supplied NameClassPairMapper and return all the returned
* values as a List.
*
* @param base The base DN where the list should be performed.
* @param mapper The NameClassPairMapper to supply each
* {@link Binding} to.
* @return a List containing the Objects returned from the
* Mapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(String base, NameClassPairMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. Pass all the found Binding objects to the
* supplied NameClassPairMapper and return all the returned
* values as a List.
*
* @param base The base DN where the list should be performed.
* @param mapper The NameClassPairMapper to supply each
* {@link Binding} to.
* @return a List containing the Objects returned from the
* Mapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(Name base, NameClassPairMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of children of the given
* base.
*
* @param base The base DN where the list should be performed.
* @return a List containing the names of all the contexts
* bound to base.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(final String base) throws NamingException;
/**
* Perform a non-recursive listing of children of the given
* base.
*
* @param base The base DN where the list should be performed.
* @return a List containing the names of all the contexts
* bound to base.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(final Name base) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. The Object returned in each {@link Binding} is
* supplied to the specified ContextMapper.
*
* @param base The base DN where the list should be performed.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(String base, ContextMapper mapper) throws NamingException;
/**
* Perform a non-recursive listing of the children of the given
* base. The Object returned in each {@link Binding} is
* supplied to the specified ContextMapper.
*
* @param base The base DN where the list should be performed.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return a List containing all entries received from the
* ContextMapper.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is
* interpreted that no entries were found.
*/
List listBindings(Name base, ContextMapper mapper) throws NamingException;
/**
* Lookup the supplied DN and return the found object. This will typically
* be a {@link DirContextAdapter}, unless the DirObjectFactory
* has been modified in the ContextSource.
*
* @param dn The distinguished name of the object to find.
* @return the found object, typically a {@link DirContextAdapter} instance.
* @throws NamingException if any error occurs.
* @see #lookupContext(Name)
* @see AbstractContextSource#setDirObjectFactory(Class)
*/
Object lookup(Name dn) throws NamingException;
/**
* Lookup the supplied DN and return the found object. This will typically
* be a {@link DirContextAdapter}, unless the DirObjectFactory
* has been modified in the ContextSource.
*
* @param dn The distinguished name of the object to find.
* @return the found object, typically a {@link DirContextAdapter} instance.
* @throws NamingException if any error occurs.
* @see #lookupContext(String)
* @see AbstractContextSource#setDirObjectFactory(Class)
*/
Object lookup(String dn) throws NamingException;
/**
* Convenience method to get the attributes of a specified DN and
* automatically pass them to an AttributesMapper.
*
* @param dn The distinguished name to find.
* @param mapper The AttributesMapper to use for mapping the
* found object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(Name dn, AttributesMapper mapper) throws NamingException;
/**
* Convenience method to get the attributes of a specified DN and
* automatically pass them to an AttributesMapper.
*
* @param dn The distinguished name to find.
* @param mapper The AttributesMapper to use for mapping the
* found object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(String dn, AttributesMapper mapper) throws NamingException;
/**
* Convenience method to lookup a specified DN and automatically pass the
* found object to a ContextMapper.
*
* @param dn The distinguished name to find.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(Name dn, ContextMapper mapper) throws NamingException;
/**
* Convenience method to lookup a specified DN and automatically pass the
* found object to a ContextMapper.
*
* @param dn The distinguished name to find.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(String dn, ContextMapper mapper) throws NamingException;
/**
* Convenience method to get the specified attributes of a specified DN and
* automatically pass them to an AttributesMapper.
*
* @param dn The distinguished name to find.
* @param attributes The names of the attributes to pass to the mapper.
* @param mapper The AttributesMapper to use for mapping the
* found object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(Name dn, String[] attributes, AttributesMapper mapper) throws NamingException;
/**
* Convenience method to get the specified attributes of a specified DN and
* automatically pass them to an AttributesMapper.
*
* @param dn The distinguished name to find.
* @param attributes The names of the attributes to pass to the mapper.
* @param mapper The AttributesMapper to use for mapping the
* found object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(String dn, String[] attributes, AttributesMapper mapper) throws NamingException;
/**
* Convenience method to get the specified attributes of a specified DN and
* automatically pass them to a ContextMapper.
*
* @param dn The distinguished name to find.
* @param attributes The names of the attributes to pass to the mapper.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(Name dn, String[] attributes, ContextMapper mapper) throws NamingException;
/**
* Convenience method to get the specified attributes of a specified DN and
* automatically pass them to a ContextMapper.
*
* @param dn The distinguished name to find.
* @param attributes The names of the attributes to pass to the mapper.
* @param mapper The ContextMapper to use for mapping the found
* object.
* @return the object returned from the mapper.
* @throws NamingException if any error occurs.
*/
Object lookup(String dn, String[] attributes, ContextMapper mapper) throws NamingException;
/**
* Modify an entry in the LDAP tree using the supplied
* ModificationItems.
*
* @param dn The distinguished name of the node to modify.
* @param mods The modifications to perform.
* @throws NamingException if any error occurs.
* @see #modifyAttributes(DirContextOperations)
*/
void modifyAttributes(Name dn, ModificationItem[] mods) throws NamingException;
/**
* Modify an entry in the LDAP tree using the supplied
* ModificationItems.
*
* @param dn The distinguished name of the node to modify.
* @param mods The modifications to perform.
* @throws NamingException if any error occurs.
* @see #modifyAttributes(DirContextOperations)
*/
void modifyAttributes(String dn, ModificationItem[] mods) throws NamingException;
/**
* Create an entry in the LDAP tree. The attributes used to create the entry
* are either retrieved from the obj parameter or the
* attributes parameter (or both). One of these parameters may
* be null but not both.
*
* @param dn The distinguished name to bind the object and attributes to.
* @param obj The object to bind, may be null. Typically a
* DirContext implementation.
* @param attributes The attributes to bind, may be null.
* @throws NamingException if any error occurs.
* @see DirContextAdapter
*/
void bind(Name dn, Object obj, Attributes attributes) throws NamingException;
/**
* Create an entry in the LDAP tree. The attributes used to create the entry
* are either retrieved from the obj parameter or the
* attributes parameter (or both). One of these parameters may
* be null but not both.
*
* @param dn The distinguished name to bind the object and attributes to.
* @param obj The object to bind, may be null. Typically a
* DirContext implementation.
* @param attributes The attributes to bind, may be null.
* @throws NamingException if any error occurs.
* @see DirContextAdapter
*/
void bind(String dn, Object obj, Attributes attributes) throws NamingException;
/**
* Remove an entry from the LDAP tree. The entry must not have any children
* - if you suspect that the entry might have descendants, use
* {@link #unbind(Name, boolean)} in stead.
*
* @param dn The distinguished name of the entry to remove.
* @throws NamingException if any error occurs.
*/
void unbind(Name dn) throws NamingException;
/**
* Remove an entry from the LDAP tree. The entry must not have any children
* - if you suspect that the entry might have descendants, use
* {@link #unbind(Name, boolean)} in stead.
*
* @param dn The distinguished name to unbind.
* @throws NamingException if any error occurs.
*/
void unbind(String dn) throws NamingException;
/**
* Remove an entry from the LDAP tree, optionally removing all descendants
* in the process.
*
* @param dn The distinguished name to unbind.
* @param recursive Whether to unbind all subcontexts as well. If this
* parameter is false and the entry has children, the operation
* will fail.
* @throws NamingException if any error occurs.
*/
void unbind(Name dn, boolean recursive) throws NamingException;
/**
* Remove an entry from the LDAP tree, optionally removing all descendants
* in the process.
*
* @param dn The distinguished name to unbind.
* @param recursive Whether to unbind all subcontexts as well. If this
* parameter is false and the entry has children, the operation
* will fail.
* @throws NamingException if any error occurs.
*/
void unbind(String dn, boolean recursive) throws NamingException;
/**
* Remove an entry and replace it with a new one. The attributes used to
* create the entry are either retrieved from the obj parameter
* or the attributes parameter (or both). One of these
* parameters may be null but not both. This method assumes
* that the specified context already exists - if not it will fail.
*
* @param dn The distinguished name to rebind.
* @param obj The object to bind to the DN, may be null.
* Typically a DirContext implementation.
* @param attributes The attributes to bind, may be null.
* @throws NamingException if any error occurs.
* @see DirContextAdapter
*/
void rebind(Name dn, Object obj, Attributes attributes) throws NamingException;
/**
* Remove an entry and replace it with a new one. The attributes used to
* create the entry are either retrieved from the obj parameter
* or the attributes parameter (or both). One of these
* parameters may be null but not both. This method assumes
* that the specified context already exists - if not it will fail.
*
* @param dn The distinguished name to rebind.
* @param obj The object to bind to the DN, may be null.
* Typically a DirContext implementation.
* @param attributes The attributes to bind, may be null.
* @throws NamingException if any error occurs.
* @see DirContextAdapter
*/
void rebind(String dn, Object obj, Attributes attributes) throws NamingException;
/**
* Move an entry in the LDAP tree to a new location.
*
* @param oldDn The distinguished name of the entry to move; may not be
* null or empty.
* @param newDn The distinguished name where the entry should be moved; may
* not be null or empty.
* @throws ContextNotEmptyException if newDn is already bound
* @throws NamingException if any other error occurs.
*/
void rename(final Name oldDn, final Name newDn) throws NamingException;
/**
* Move an entry in the LDAP tree to a new location.
*
* @param oldDn The distinguished name of the entry to move; may not be
* null or empty.
* @param newDn The distinguished name where the entry should be moved; may
* not be null or empty.
* @throws ContextNotEmptyException if newDn is already bound
* @throws NamingException if any other error occurs.
*/
void rename(final String oldDn, final String newDn) throws NamingException;
/**
* Convenience method to lookup the supplied DN and automatically cast it to
* {@link DirContextOperations}.
*
* @param dn The distinguished name of the object to find.
* @return The found object, cast to {@link DirContextOperations}.
* @throws ClassCastException if an alternative
* DirObjectFactory has been registered with the
* ContextSource, causing the actual class of the returned
* object to be something else than {@link DirContextOperations}.
* @throws NamingException if any other error occurs.
* @see #lookup(Name)
* @see #modifyAttributes(DirContextOperations)
* @since 1.2
*/
DirContextOperations lookupContext(Name dn) throws NamingException, ClassCastException;
/**
* Convenience method to lookup the supplied DN and automatically cast it to
* {@link DirContextOperations}.
*
* @param dn The distinguished name of the object to find.
* @return The found object, cast to {@link DirContextOperations}.
* @throws ClassCastException if an alternative
* DirObjectFactory has been registered with the
* ContextSource, causing the actual class of the returned
* object to be something else than {@link DirContextOperations}.
* @throws NamingException if any other error occurs.
* @see #lookup(String)
* @see #modifyAttributes(DirContextOperations)
* @since 1.2
*/
DirContextOperations lookupContext(String dn) throws NamingException, ClassCastException;
/**
* Modify the attributes of the entry referenced by the supplied
* {@link DirContextOperations} instance. The DN to update will be the DN of
* the DirContextOperationsinstance, and the
* ModificationItem array is retrieved from the
* DirContextOperations instance using a call to
* {@link AttributeModificationsAware#getModificationItems()}. NB:
* The supplied instance needs to have been properly initialized; this means
* that if it hasn't been received from a lookup operation, its
* DN needs to be initialized and it must have been put in update mode (
* {@link DirContextAdapter#setUpdateMode(boolean)}).
*
* public void update(Person person) {
* DirContextOperations ctx = ldapOperations.lookupContext(person.getDn());
*
* ctx.setAttributeValue("description", person.getDescription());
* ctx.setAttributeValue("telephoneNumber", person.getPhone());
* // More modifications here
*
* ldapOperations.modifyAttributes(ctx);
* }
*
*
* @param ctx the DirContextOperations instance to use in the update.
* @throws IllegalStateException if the supplied instance is not in update
* mode or has not been properly initialized.
* @throws NamingException if any other error occurs.
* @since 1.2
* @see #lookupContext(Name)
* @see DirContextAdapter
*/
void modifyAttributes(DirContextOperations ctx) throws IllegalStateException, NamingException;
/**
* Bind the data in the supplied context in the tree. All specified
* attributes ctxin will be bound to the DN set on ctx.
*
*
*
* DirContextOperations ctx = new DirContextAdapter(dn);
* ctx.setAttributeValue("cn", "john doe");
* ctx.setAttributeValue("description", "some description");
* //More initialization here.
*
* ldapTemplate.bind(ctx);
*
* @param ctx the context to bind
* @throws IllegalStateException if no DN is set or if the instance is in
* update mode.
* @since 1.3
*/
void bind(DirContextOperations ctx);
/**
* Remove an entry and replace it with a new one. The attributes used to
* create the entry are retrieved from the ctx parameter. This
* method assumes that the specified context already exists - if not it will
* fail. The entry will be bound to the DN set on ctx.
*
*
*
* DirContextOperations ctx = new DirContextAdapter(dn);
* ctx.setAttributeValue("cn", "john doe");
* ctx.setAttributeValue("description", "some description");
* //More initialization here.
*
* ldapTemplate.rebind(ctx);
*
* @param ctx the context to rebind
* @throws IllegalStateException if no DN is set or if the instance is in
* update mode.
* @since 1.3
*/
void rebind(DirContextOperations ctx);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry.
*
*
*
* AndFilter filter = new AndFilter();
* filter.and("objectclass", "person").and("uid", userId);
* boolean authenticated = ldapTemplate.authenticate(DistinguishedName.EMPTY_PATH, filter.toString(), password);
*
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @return true if the authentication was successful,
* false otherwise.
* @since 1.3
*/
boolean authenticate(Name base, String filter, String password);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry.
*
*
*
* AndFilter filter = new AndFilter();
* filter.and("objectclass", "person").and("uid", userId);
* boolean authenticated = ldapTemplate.authenticate(DistinguishedName.EMPTY_PATH, filter.toString(), password);
*
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @return true if the authentication was successful,
* false otherwise.
* @since 1.3
*/
boolean authenticate(String base, String filter, String password);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. The resulting DirContext instance is then used as input to the
* supplied {@link AuthenticatedLdapEntryContextCallback} to perform any
* additional LDAP operations against the authenticated DirContext.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param callback the callback to that will be called to perform operations
* on the DirContext authenticated with the found user.
* @return true if the authentication was successful,
* false otherwise.
* @see #authenticate(Name, String, String)
* @since 1.3
*/
boolean authenticate(Name base, String filter, String password, AuthenticatedLdapEntryContextCallback callback);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. The resulting DirContext instance is then used as input to the
* supplied {@link AuthenticatedLdapEntryContextCallback} to perform any
* additional LDAP operations against the authenticated DirContext.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param callback the callback to that will be called to perform operations
* on the DirContext authenticated with the found user.
* @return true if the authentication was successful,
* false otherwise.
* @see #authenticate(String, String, String)
* @since 1.3
*/
boolean authenticate(String base, String filter, String password, AuthenticatedLdapEntryContextCallback callback);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. The resulting DirContext instance is then used as input to the
* supplied {@link AuthenticatedLdapEntryContextCallback} to perform any
* additional LDAP operations against the authenticated DirContext. If an
* exception is caught, the same exception is passed on to the given
* {@link AuthenticationErrorCallback}. This enables the caller to provide a
* callback that, for example, collects the exception for later processing.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param callback the callback that will be called to perform operations
* on the DirContext authenticated with the found user.
* @param errorCallback the callback that will be called if an exception is caught.
* @return true if the authentication was successful,
* false otherwise.
* @see #authenticate(Name, String, String, AuthenticatedLdapEntryContextCallback)
* @since 1.3.1
*/
boolean authenticate(Name base, String filter, String password,
AuthenticatedLdapEntryContextCallback callback,
AuthenticationErrorCallback errorCallback);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. The resulting DirContext instance is then used as input to the
* supplied {@link AuthenticatedLdapEntryContextCallback} to perform any
* additional LDAP operations against the authenticated DirContext. If an
* exception is caught, the same exception is passed on to the given
* {@link AuthenticationErrorCallback}. This enables the caller to provide a
* callback that, for example, collects the exception for later processing.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param callback the callback that will be called to perform operations
* on the DirContext authenticated with the found user.
* @param errorCallback the callback that will be called if an exception is caught.
* @return true if the authentication was successful,
* false otherwise.
* @see #authenticate(String, String, String, AuthenticatedLdapEntryContextCallback)
* @since 1.3.1
*/
boolean authenticate(String base, String filter, String password,
AuthenticatedLdapEntryContextCallback callback,
AuthenticationErrorCallback errorCallback);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. If an exception is caught, the same exception is passed on to the given
* {@link AuthenticationErrorCallback}. This enables the caller to provide a
* callback that, for example, collects the exception for later processing.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param errorCallback the callback that will be called if an exception is caught.
* @return true if the authentication was successful,
* false otherwise.
* @see #authenticate(Name, String, String, AuthenticatedLdapEntryContextCallback, AuthenticationErrorCallback)
* @since 1.3.1
*/
boolean authenticate(Name base, String filter, String password,
AuthenticationErrorCallback errorCallback);
/**
* Utility method to perform a simple LDAP 'bind' authentication. Search for
* the LDAP entry to authenticate using the supplied base DN and filter; use
* the DN of the found entry together with the password as input to
* {@link ContextSource#getContext(String, String)}, thus authenticating the
* entry. If an exception is caught, the same exception is passed on to the given
* {@link AuthenticationErrorCallback}. This enables the caller to provide a
* callback that, for example, collects the exception for later processing.
*
* @param base the DN to use as the base of the search.
* @param filter the search filter - must result in a unique result.
* @param password the password to use for authentication.
* @param errorCallback the callback that will be called if an exception is caught.
* @return true if the authentication was successful,
* false otherwise.
* @throws IncorrectResultSizeDataAccessException if more than one users were found
* @see #authenticate(String, String, String, AuthenticatedLdapEntryContextCallback, AuthenticationErrorCallback)
* @since 1.3.1
*/
boolean authenticate(String base, String filter, String password,
AuthenticationErrorCallback errorCallback);
/**
* Perform a search for a unique entry matching the specified search
* criteria and return the found object. If no entry is found or if there
* are more than one matching entry, an
* {@link IncorrectResultSizeDataAccessException} is thrown.
* @param base the DN to use as the base of the search.
* @param filter the search filter.
* @param mapper the mapper to use for the search.
* @return the single object returned by the mapper that matches the search
* criteria.
* @throws IncorrectResultSizeDataAccessException if the result is not one unique entry
* @since 1.3
*/
Object searchForObject(Name base, String filter, ContextMapper mapper);
/**
* Perform a search for a unique entry matching the specified search
* criteria and return the found object. If no entry is found or if there
* are more than one matching entry, an
* {@link IncorrectResultSizeDataAccessException} is thrown.
* @param base the DN to use as the base of the search.
* @param filter the search filter.
* @param mapper the mapper to use for the search.
* @return the single object returned by the mapper that matches the search
* criteria.
* @throws IncorrectResultSizeDataAccessException if the result is not one unique entry
* @since 1.3
*/
Object searchForObject(String base, String filter, ContextMapper mapper);
}
././@LongLink 0000000 0000000 0000000 00000000175 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ContextMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000005247 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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 javax.naming.Binding;
import javax.naming.Name;
import javax.naming.directory.SearchResult;
import org.springframework.ldap.core.support.AbstractContextMapper;
import org.springframework.ldap.core.support.DefaultDirObjectFactory;
/**
* An interface used by LdapTemplate to map LDAP Contexts to beans. When a
* DirObjectFactory is set on the ContextSource, the objects returned from
* search and listBindings operations are
* automatically transformed to DirContext objects (when using the
* {@link DefaultDirObjectFactory} - which is typically the case, unless
* something else has been explicitly specified - you get a
* {@link DirContextAdapter} object). This object will then be passed to the
* ContextMapper implementation for transformation to the desired bean.
* ctx is the object from a single {@link SearchResult},
* {@link Binding}, or a lookup operation.
*
* @param ctx
* the context to map to an object. Typically this will be a
* {@link DirContextAdapter} instance, unless a project specific
* DirObjectFactory has been specified on the
* ContextSource.
* @return an object built from the data in the context.
*/
Object mapFromContext(Object ctx);
}
././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000216 11475313376 030210 0 ustar
DistinguishedName corresponding to the parsed
* stream.
*/
public DistinguishedName dn() throws ParseException;
/**
* Parse a Relative Distinguished Name.
*
* @return the next rdn on the stream.
*/
public LdapRdn rdn() throws ParseException;
}
././@LongLink 0000000 0000000 0000000 00000000226 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/CollectingNameClassPairCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003711 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.LinkedList;
import java.util.List;
import javax.naming.NameClassPair;
/**
* A NameClassPairCallbackHandler to collect all results in an internal List.
*
* @see LdapTemplate
*
* @author Mattias Hellborg Arthursson
*/
public abstract class CollectingNameClassPairCallbackHandler implements
NameClassPairCallbackHandler {
private List list = new LinkedList();
/**
* Get the assembled list.
*
* @return the list of all assembled objects.
*/
public List getList() {
return list;
}
/**
* Pass on the supplied NameClassPair to
* {@link #getObjectFromNameClassPair(NameClassPair)} and add the result to
* the internal list.
*/
public void handleNameClassPair(NameClassPair nameClassPair) {
list.add(getObjectFromNameClassPair(nameClassPair));
}
/**
* Handle a NameClassPair and transform it to an Object of the desired type
* and with data from the NameClassPair.
*
* @param nameClassPair
* a NameClassPair from a search operation.
* @return an object constructed from the data in the NameClassPair.
*/
public abstract Object getObjectFromNameClassPair(
NameClassPair nameClassPair);
}
././@LongLink 0000000 0000000 0000000 00000000210 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ObjectRetrievalException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002744 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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 org.springframework.ldap.NamingException;
/**
* Thrown by a {@link ContextMapperCallbackHandler} when it cannot retrieve an
* object from the given Binding.
*
* @author Ulrik Sandberg
* @since 1.2
*/
public class ObjectRetrievalException extends NamingException {
/**
* Create a new ObjectRetrievalException.
*
* @param msg
* the detail message
*
*/
public ObjectRetrievalException(String msg) {
super(msg);
}
/**
* Create a new ObjectRetrievalException.
*
* @param msg
* the detail message
* @param cause
* the root cause (if any)
*/
public ObjectRetrievalException(String msg, Throwable cause) {
super(msg, cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000217 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AttributesMapperCallbackHandler.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004327 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NameClassPair;
import javax.naming.directory.Attributes;
import javax.naming.directory.SearchResult;
import org.springframework.ldap.support.LdapUtils;
/**
* A CollectingNameClassPairCallbackHandler to wrap an {@link AttributesMapper}.
* That is, the found object is extracted from the {@link Attributes} of each
* {@link SearchResult}, and then passed to the specified
* {@link AttributesMapper} for translation.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
* @since 1.2
*/
public class AttributesMapperCallbackHandler extends CollectingNameClassPairCallbackHandler {
private AttributesMapper mapper;
/**
* Constructs a new instance around the specified {@link AttributesMapper}.
*
* @param mapper the target mapper.
*/
public AttributesMapperCallbackHandler(AttributesMapper mapper) {
this.mapper = mapper;
}
/**
* Cast the NameClassPair to a SearchResult and pass its attributes to the
* {@link AttributesMapper}.
*
* @param nameClassPair a SearchResult instance.
* @return the Object returned from the mapper.
*/
public Object getObjectFromNameClassPair(NameClassPair nameClassPair) {
if (!(nameClassPair instanceof SearchResult)) {
throw new IllegalArgumentException("Parameter must be an instance of SearchResult");
}
SearchResult searchResult = (SearchResult) nameClassPair;
Attributes attributes = searchResult.getAttributes();
try {
return mapper.mapFromAttributes(attributes);
}
catch (javax.naming.NamingException e) {
throw LdapUtils.convertLdapException(e);
}
}
} ././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DirContextProxy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002202 11475313376 030205 0 ustar /*
* Copyright 2005-2010 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 javax.naming.directory.DirContext;
/**
* Helper interface to be able to get hold of the target DirContext
* from proxies created by ContextSource proxies.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface DirContextProxy {
/**
* Get the target DirContext of the proxy.
*
* @return the target DirContext.
*/
DirContext getTargetContext();
}
././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapRdn.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000017220 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.springframework.ldap.BadLdapGrammarException;
import org.springframework.ldap.support.ListComparator;
/**
* Datatype for a LDAP name, a part of a path.
*
* The name: uid=adam.skogman Key: uid Value: adam.skogman
*
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class LdapRdn implements Serializable, Comparable {
private static final long serialVersionUID = 5681397547245228750L;
private List components = new LinkedList();
/**
* Default constructor. Create an empty, uninitialized LdapRdn.
*/
public LdapRdn() {
}
/**
* Parse the supplied string and construct this instance accordingly.
*
* @param string the string to parse.
*/
public LdapRdn(String string) {
DnParser parser = DefaultDnParserFactory.createDnParser(string);
LdapRdn rdn;
try {
rdn = parser.rdn();
}
catch (ParseException e) {
throw new BadLdapGrammarException("Failed to parse Rdn", e);
}
catch (TokenMgrError e) {
throw new BadLdapGrammarException("Failed to parse Rdn", e);
}
this.components = rdn.components;
}
/**
* Construct an LdapRdn using the supplied key and value.
*
* @param key the attribute name.
* @param value the attribute value.
*/
public LdapRdn(String key, String value) {
components.add(new LdapRdnComponent(key, value));
}
/**
* Add an LdapRdnComponent to this LdapRdn.
*
* @param rdnComponent the LdapRdnComponent to add.s
*/
public void addComponent(LdapRdnComponent rdnComponent) {
components.add(rdnComponent);
}
/**
* Gets all components in this LdapRdn.
*
* @return the List of all LdapRdnComponents composing this LdapRdn.
*/
public List getComponents() {
return components;
}
/**
* Gets the first LdapRdnComponent of this LdapRdn.
*
* @return The first LdapRdnComponent of this LdapRdn.
* @throws IndexOutOfBoundsException if there are no components in this Rdn.
*/
public LdapRdnComponent getComponent() {
return (LdapRdnComponent) components.get(0);
}
/**
* Get the LdapRdnComponent at index idx.
*
* @param idx the 0-based index of the component to get.
* @return the LdapRdnComponent at index idx.
* @throws IndexOutOfBoundsException if there are no components in this Rdn.
*/
public LdapRdnComponent getComponent(int idx) {
return (LdapRdnComponent) components.get(idx);
}
/**
* Get a properly rfc2253-encoded String representation of this LdapRdn.
*
* @return an escaped String corresponding to this LdapRdn.
* @throws IndexOutOfBoundsException if there are no components in this Rdn.
*/
public String getLdapEncoded() {
if (components.size() == 0) {
throw new IndexOutOfBoundsException("No components in Rdn.");
}
StringBuffer sb = new StringBuffer(100);
for (Iterator iter = components.iterator(); iter.hasNext();) {
LdapRdnComponent component = (LdapRdnComponent) iter.next();
sb.append(component.encodeLdap());
if (iter.hasNext()) {
sb.append("+");
}
}
return sb.toString();
}
/**
* Get a String representation of this LdapRdn for use in urls.
*
* @return a String representation of this LdapRdn for use in urls.
*/
public String encodeUrl() {
StringBuffer sb = new StringBuffer(100);
for (Iterator iter = components.iterator(); iter.hasNext();) {
LdapRdnComponent component = (LdapRdnComponent) iter.next();
sb.append(component.encodeUrl());
if (iter.hasNext()) {
sb.append("+");
}
}
return sb.toString();
}
/**
* Compare this LdapRdn to another object.
*
* @param obj the object to compare to.
* @throws ClassCastException if the supplied object is not an LdapRdn
* instance.
*/
public int compareTo(Object obj) {
LdapRdn that = (LdapRdn) obj;
Comparator comparator = new ListComparator();
return comparator.compare(this.components, that.components);
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
LdapRdn that = (LdapRdn) obj;
return this.getComponents().equals(that.getComponents());
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return this.getClass().hashCode() ^ getComponents().hashCode();
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
return getLdapEncoded();
}
/**
* Get the value of this LdapRdn. Note that if this Rdn is multi-value the
* first value will be returned. E.g. for the Rdn
* cn=john doe+sn=doe, the return value would be
* john doe.
*
* @return the (first) value of this LdapRdn.
* @throws IndexOutOfBoundsException if there are no components in this Rdn.
*/
public String getValue() {
return getComponent().getValue();
}
/**
* Get the key of this LdapRdn. Note that if this Rdn is multi-value the
* first key will be returned. E.g. for the Rdn
* cn=john doe+sn=doe, the return value would be
* cn.
*
* @return the (first) key of this LdapRdn.
* @throws IndexOutOfBoundsException if there are no components in this Rdn.
*/
public String getKey() {
return getComponent().getKey();
}
/**
* Get the value of the LdapComponent with the specified key (Attribute
* name).
*
* @param key the key
* @return the value.
* @throws IllegalArgumentException if there is no component with the
* specified key.
*/
public String getValue(String key) {
for (Iterator iter = components.iterator(); iter.hasNext();) {
LdapRdnComponent component = (LdapRdnComponent) iter.next();
if (StringUtils.equals(component.getKey(), key)) {
return component.getValue();
}
}
throw new IllegalArgumentException("No RdnComponent with the key " + key);
}
/**
* Create an immutable copy of this instance. It will not be possible to add
* or remove components or modify the keys and values of these components.
*
* @return an immutable copy of this instance.
* @since 1.3
*/
public LdapRdn immutableLdapRdn() {
List listWithImmutableRdns = new ArrayList(components.size());
for (Iterator iterator = components.iterator(); iterator.hasNext();) {
LdapRdnComponent rdnComponent = (LdapRdnComponent) iterator.next();
listWithImmutableRdns.add(rdnComponent.immutableLdapRdnComponent());
}
List unmodifiableListOfImmutableRdns = Collections.unmodifiableList(listWithImmutableRdns);
LdapRdn immutableRdn = new LdapRdn();
immutableRdn.components = unmodifiableListOfImmutableRdns;
return immutableRdn;
}
} ././@LongLink 0000000 0000000 0000000 00000000173 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapEncoder.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000016430 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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 org.springframework.ldap.BadLdapGrammarException;
/**
* Helper class to encode and decode ldap names and values.
*
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class LdapEncoder {
private static String[] nameEscapeTable = new String[96];
private static String[] filterEscapeTable = new String['\\' + 1];
static {
// Name encoding table -------------------------------------
// all below 0x20 (control chars)
for (char c = 0; c < ' '; c++) {
nameEscapeTable[c] = "\\" + toTwoCharHex(c);
}
nameEscapeTable['#'] = "\\#";
nameEscapeTable[','] = "\\,";
nameEscapeTable[';'] = "\\;";
nameEscapeTable['='] = "\\=";
nameEscapeTable['+'] = "\\+";
nameEscapeTable['<'] = "\\<";
nameEscapeTable['>'] = "\\>";
nameEscapeTable['\"'] = "\\\"";
nameEscapeTable['\\'] = "\\\\";
// Filter encoding table -------------------------------------
// fill with char itself
for (char c = 0; c < filterEscapeTable.length; c++) {
filterEscapeTable[c] = String.valueOf(c);
}
// escapes (RFC2254)
filterEscapeTable['*'] = "\\2a";
filterEscapeTable['('] = "\\28";
filterEscapeTable[')'] = "\\29";
filterEscapeTable['\\'] = "\\5c";
filterEscapeTable[0] = "\\00";
}
/**
* All static methods - not to be instantiated.
*/
private LdapEncoder() {
}
protected static String toTwoCharHex(char c) {
String raw = Integer.toHexString(c).toUpperCase();
if (raw.length() > 1)
return raw;
else
return "0" + raw;
}
/**
* Escape a value for use in a filter.
*
* @param value
* the value to escape.
* @return a properly escaped representation of the supplied value.
*/
public static String filterEncode(String value) {
if (value == null)
return null;
// make buffer roomy
StringBuffer encodedValue = new StringBuffer(value.length() * 2);
int length = value.length();
for (int i = 0; i < length; i++) {
char c = value.charAt(i);
if (c < filterEscapeTable.length) {
encodedValue.append(filterEscapeTable[c]);
} else {
// default: add the char
encodedValue.append(c);
}
}
return encodedValue.toString();
}
/**
* LDAP Encodes a value for use with a DN. Escapes for LDAP, not JNDI!
*
*
Escapes:
' ' [space] - "\ " [if first or last]
'#'
* [hash] - "\#"
',' [comma] - "\,"
';' [semicolon] - "\;"
'=
* [equals] - "\="
'+' [plus] - "\+"
'<' [less than] -
* "\<"
'>' [greater than] - "\>"
'"' [double quote] -
* "\""
'\' [backslash] - "\\"
*
* @param value
* the value to escape.
* @return The escaped value.
*/
static public String nameEncode(String value) {
if (value == null)
return null;
// make buffer roomy
StringBuffer encodedValue = new StringBuffer(value.length() * 2);
int length = value.length();
int last = length - 1;
for (int i = 0; i < length; i++) {
char c = value.charAt(i);
// space first or last
if (c == ' ' && (i == 0 || i == last)) {
encodedValue.append("\\ ");
continue;
}
if (c < nameEscapeTable.length) {
// check in table for escapes
String esc = nameEscapeTable[c];
if (esc != null) {
encodedValue.append(esc);
continue;
}
}
// default: add the char
encodedValue.append(c);
}
return encodedValue.toString();
}
/**
* Decodes a value. Converts escaped chars to ordinary chars.
*
* @param value
* Trimmed value, so no leading an trailing blanks, except an
* escaped space last.
* @return The decoded value as a string.
* @throws BadLdapGrammarException
*/
static public String nameDecode(String value)
throws BadLdapGrammarException {
if (value == null)
return null;
// make buffer same size
StringBuffer decoded = new StringBuffer(value.length());
int i = 0;
while (i < value.length()) {
char currentChar = value.charAt(i);
if (currentChar == '\\') {
if (value.length() <= i + 1) {
// Ending with a single backslash is not allowed
throw new BadLdapGrammarException(
"Unexpected end of value " + "unterminated '\\'");
} else {
char nextChar = value.charAt(i + 1);
if (nextChar == ',' || nextChar == '=' || nextChar == '+'
|| nextChar == '<' || nextChar == '>'
|| nextChar == '#' || nextChar == ';'
|| nextChar == '\\' || nextChar == '\"'
|| nextChar == ' ') {
// Normal backslash escape
decoded.append(nextChar);
i += 2;
} else {
if (value.length() <= i + 2) {
throw new BadLdapGrammarException(
"Unexpected end of value "
+ "expected special or hex, found '"
+ nextChar + "'");
} else {
// This should be a hex value
String hexString = "" + nextChar
+ value.charAt(i + 2);
decoded.append((char) Integer.parseInt(hexString,
16));
i += 3;
}
}
}
} else {
// This character wasn't escaped - just append it
decoded.append(currentChar);
i++;
}
}
return decoded.toString();
}
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/NameClassPairMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003247 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NameClassPair;
import javax.naming.NamingException;
/**
* Responsible for mapping NameClassPair objects to beans.
*
* @author Mattias Hellborg Arthursson
*/
public interface NameClassPairMapper {
/**
* Map NameClassPair to an Object. The supplied
* NameClassPair is one of the results from a search
* operation (search, list or listBindings). Depending on which search
* operation is being performed, the NameClassPair might be a
* SearchResult, Binding or
* NameClassPair.
*
* @param nameClassPair
* NameClassPair from a search operation.
* @return and Object built from the NameClassPair.
* @throws NamingException
* if one is encountered in the operation.
*/
Object mapFromNameClassPair(NameClassPair nameClassPair)
throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/SearchExecutor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003405 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
/**
* Interface for delegating an actual search operation. The typical
* implementation of executeSearch would be something like:
*
*
* SearchExecutor executor = new SearchExecutor(){
* public NamingEnumeration executeSearch(DirContext ctx) throws NamingException{
* return ctx.search(dn, filter, searchControls);
* }
* }
*
*
* @see org.springframework.ldap.core.LdapTemplate#search(SearchExecutor,
* NameClassPairCallbackHandler)
*
* @author Mattias Hellborg Arthursson
*/
public interface SearchExecutor {
/**
* Execute the actual search.
*
* @param ctx
* the DirContext on which to work.
* @return the NamingEnumeration resulting from the search
* operation.
* @throws NamingException
* if the search results in one.
*/
NamingEnumeration executeSearch(DirContext ctx)
throws NamingException;
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DirContextAdapter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000112031 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.ArrayList;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.BasicAttributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.directory.SearchControls;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.NoSuchAttributeException;
import org.springframework.ldap.support.LdapUtils;
import org.springframework.util.StringUtils;
/**
* Adapter that implements the interesting methods of the DirContext interface.
* In particular it contains utility methods for getting and setting attributes.
* Using the
* {@link org.springframework.ldap.core.support.DefaultDirObjectFactory} in your
* ContextSource (which is the default) you will receive instances
* of this class from searches and lookups. This can be particularly useful when
* updating data, since this class implements
* {@link AttributeModificationsAware}, providing a
* {@link #getModificationItems()} method. When in update mode, an object of
* this class keeps track of the changes made to its attributes, making them
* available as an array of ModificationItem objects, suitable as
* input to {@link LdapTemplate#modifyAttributes(DirContextOperations)}.
*
* Note that this is not a complete implementation of DirContext. Several
* methods are not relevant for the intended usage of this class, so they
* throw UnsupportOperationException.
*
* @see #setAttributeValue(String, Object)
* @see #setAttributeValues(String, Object[])
* @see #getStringAttribute(String)
* @see #getStringAttributes(String)
* @see #getObjectAttribute(String)
* @see #addAttributeValue(String, Object)
* @see #removeAttributeValue(String, Object)
* @see #setUpdateMode(boolean)
* @see #isUpdateMode()
*
* @author Magnus Robertsson
* @author Andreas Ronge
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class DirContextAdapter implements DirContextOperations {
private static final boolean DONT_ADD_IF_DUPLICATE_EXISTS = false;
private static final String EMPTY_STRING = "";
private static final boolean ORDER_DOESNT_MATTER = false;
private static Log log = LogFactory.getLog(DirContextAdapter.class);
private final Attributes originalAttrs;
private DistinguishedName dn;
private DistinguishedName base;
private boolean updateMode = false;
private Attributes updatedAttrs;
private String referralUrl;
/**
* Default constructor.
*/
public DirContextAdapter() {
this(null, null, null);
}
/**
* Create a new DirContextAdapter from the supplied DN String.
* @param dnString the DN string. Must be syntactically correct, or an
* exception will be thrown.
*/
public DirContextAdapter(String dnString) {
this(new DistinguishedName(dnString));
}
/**
* Create a new adapter from the supplied dn.
*
* @param dn the dn.
*/
public DirContextAdapter(Name dn) {
this(null, dn);
}
/**
* Create a new adapter from the supplied attributes and dn.
*
* @param attrs the attributes.
* @param dn the dn.
*/
public DirContextAdapter(Attributes attrs, Name dn) {
this(attrs, dn, null);
}
/**
* Create a new adapter from the supplied attributes, dn, and base.
*
* @param attrs the attributes.
* @param dn the dn.
* @param base the base name.
*/
public DirContextAdapter(Attributes attrs, Name dn, Name base) {
this(attrs, dn, base, null);
}
/**
* Create a new adapter from the supplied attributes, dn, base, and referral
* url.
* @param attrs the attributes.
* @param dn the dn.
* @param base the base.
* @param referralUrl the referral url (if this instance results from a
* referral).
*/
public DirContextAdapter(Attributes attrs, Name dn, Name base,
String referralUrl) {
if (attrs != null) {
this.originalAttrs = attrs;
}
else {
this.originalAttrs = new BasicAttributes(true);
}
if (dn != null) {
this.dn = new DistinguishedName(dn);
}
else {
this.dn = new DistinguishedName();
}
if (base != null) {
this.base = new DistinguishedName(base);
}
else {
this.base = new DistinguishedName();
}
if (referralUrl != null) {
this.referralUrl = referralUrl;
}
else {
this.referralUrl = EMPTY_STRING;
}
}
/**
* Constructor for cloning an existing adapter.
*
* @param master The adapter to be copied.
*/
protected DirContextAdapter(DirContextAdapter master) {
this.originalAttrs = (Attributes) master.originalAttrs.clone();
this.dn = master.dn;
this.updatedAttrs = (Attributes) master.updatedAttrs.clone();
this.updateMode = master.updateMode;
}
/**
* Sets the update mode. The update mode should be false for a
* new entry and true for an existing entry that is being
* updated.
*
* @param mode Update mode.
*/
public void setUpdateMode(boolean mode) {
this.updateMode = mode;
if (updateMode) {
updatedAttrs = new BasicAttributes(true);
}
}
/*
* @see org.springframework.ldap.support.DirContextOperations#isUpdateMode()
*/
public boolean isUpdateMode() {
return updateMode;
}
/*
* @seeorg.springframework.ldap.support.DirContextOperations#
* getNamesOfModifiedAttributes()
*/
public String[] getNamesOfModifiedAttributes() {
List tmpList = new ArrayList();
NamingEnumeration attributesEnumeration;
if (isUpdateMode()) {
attributesEnumeration = updatedAttrs.getAll();
}
else {
attributesEnumeration = originalAttrs.getAll();
}
try {
while (attributesEnumeration.hasMore()) {
Attribute oneAttribute = (Attribute) attributesEnumeration
.next();
tmpList.add(oneAttribute.getID());
}
}
catch (NamingException e) {
throw LdapUtils.convertLdapException(e);
}
finally {
closeNamingEnumeration(attributesEnumeration);
}
return (String[]) tmpList.toArray(new String[0]);
}
private void closeNamingEnumeration(NamingEnumeration enumeration) {
try {
if (enumeration != null) {
enumeration.close();
}
}
catch (NamingException e) {
// Never mind this
}
}
/*
* @seeorg.springframework.ldap.support.AttributeModificationsAware#
* getModificationItems()
*/
public ModificationItem[] getModificationItems() {
if (!updateMode) {
return new ModificationItem[0];
}
List tmpList = new LinkedList();
NamingEnumeration attributesEnumeration = null;
try {
attributesEnumeration = updatedAttrs.getAll();
// find attributes that have been changed, removed or added
while (attributesEnumeration.hasMore()) {
Attribute oneAttr = (Attribute) attributesEnumeration.next();
collectModifications(oneAttr, tmpList);
}
}
catch (NamingException e) {
throw LdapUtils.convertLdapException(e);
}
finally {
closeNamingEnumeration(attributesEnumeration);
}
if (log.isDebugEnabled()) {
log.debug("Number of modifications:" + tmpList.size());
}
return (ModificationItem[]) tmpList
.toArray(new ModificationItem[tmpList.size()]);
}
/**
* Collect all modifications for the changed attribute. If no changes have
* been made, return immediately. If modifications have been made, and the
* original size as well as the updated size of the attribute is 1, replace
* the attribute. If the size of the updated attribute is 0, remove the
* attribute. Otherwise, the attribute is a multi-value attribute; if it's
* an ordered one it should be replaced in its entirety to preserve the new
* ordering, if not all modifications to the original value (removals and
* additions) will be collected individually.
*
* @param changedAttr the value of the changed attribute.
* @param modificationList the list in which to add the modifications.
* @throws NamingException if thrown by called Attribute methods.
*/
private void collectModifications(Attribute changedAttr,
List modificationList) throws NamingException {
Attribute currentAttribute = originalAttrs.get(changedAttr.getID());
if (changedAttr.equals(currentAttribute)) {
// No changes
return;
}
else if (currentAttribute != null && currentAttribute.size() == 1
&& changedAttr.size() == 1) {
// Replace single-vale attribute.
modificationList.add(new ModificationItem(
DirContext.REPLACE_ATTRIBUTE, changedAttr));
}
else if (changedAttr.size() == 0 && currentAttribute != null) {
// Attribute has been removed.
modificationList.add(new ModificationItem(
DirContext.REMOVE_ATTRIBUTE, changedAttr));
}
else if ((currentAttribute == null || currentAttribute.size() == 0)
&& changedAttr.size() > 0) {
// Attribute has been added.
modificationList.add(new ModificationItem(DirContext.ADD_ATTRIBUTE,
changedAttr));
}
else if (changedAttr.size() > 0 && changedAttr.isOrdered()) {
// This is a multivalue attribute and it is ordered - the original
// value should be replaced with the new values so that the ordering
// is preserved.
modificationList.add(new ModificationItem(
DirContext.REPLACE_ATTRIBUTE, changedAttr));
}
else if (changedAttr.size() > 0) {
// Change of multivalue Attribute. Collect additions and removals
// individually.
List myModifications = new LinkedList();
collectModifications(currentAttribute, changedAttr, myModifications);
if (myModifications.isEmpty()) {
// This means that the attributes are not equal, but the
// actual values are the same - thus the order must have
// changed. This should result in a REPLACE_ATTRIBUTE operation.
myModifications.add(new ModificationItem(
DirContext.REPLACE_ATTRIBUTE, changedAttr));
}
modificationList.addAll(myModifications);
}
}
private void collectModifications(Attribute originalAttr,
Attribute changedAttr, List modificationList)
throws NamingException {
Attribute originalClone = (Attribute) originalAttr.clone();
Attribute addedValuesAttribute = new BasicAttribute(originalAttr
.getID());
for (int i = 0; i < changedAttr.size(); i++) {
Object attributeValue = changedAttr.get(i);
if (!originalClone.remove(attributeValue)) {
addedValuesAttribute.add(attributeValue);
}
}
// We have now traversed and removed all values from the original that
// were also present in the new values. The remaining values in the
// original must be the ones that were removed.
if (originalClone.size() > 0) {
modificationList.add(new ModificationItem(
DirContext.REMOVE_ATTRIBUTE, originalClone));
}
if (addedValuesAttribute.size() > 0) {
modificationList.add(new ModificationItem(DirContext.ADD_ATTRIBUTE,
addedValuesAttribute));
}
}
/**
* returns true if the attribute is empty. It is empty if a == null, size ==
* 0 or get() == null or an exception if thrown when accessing the get
* method
*/
private boolean isEmptyAttribute(Attribute a) {
try {
return (a == null || a.size() == 0 || a.get() == null);
}
catch (NamingException e) {
return true;
}
}
/**
* Compare the existing attribute name with the values on the
* array values. The order of the array must be the same order
* as the existing multivalued attribute.
* [a,b,c] to [a,b] and then back to
* [a,b,c] again must result in this method returning
* true so the first change can be overwritten with the latest
* change.
*
* @param name Name of the original multi-valued attribute.
* @param values Array of values to check if they have been changed.
* @return true if there has been a change compared to original attribute,
* or a previous update
*/
private boolean isChanged(String name, Object[] values, boolean orderMatters) {
Attribute orig = originalAttrs.get(name);
Attribute prev = updatedAttrs.get(name);
// values == null and values.length == 0 is treated the same way
boolean emptyNewValue = (values == null || values.length == 0);
// Setting to empty ---------------------
if (emptyNewValue) {
// FALSE: if both are null, it is not changed (both don't exist)
// TRUE: if new value is null and old value exists (should be
// removed)
// TODO Also include prev in null check
// TODO Also check if there is a single null element
if (orig != null) {
return true;
}
return false;
}
// NOT setting to empty -------------------
// TRUE if existing value is null
if (orig == null) {
return true;
}
// TRUE if different length compared to original attributes
if (orig.size() != values.length) {
return true;
}
// TRUE if different length compared to previously updated attributes
if (prev != null && prev.size() != values.length) {
return true;
}
// Check contents of arrays
// Order DOES matter, e.g. first names
try {
for (int i = 0; i < orig.size(); i++) {
Object obj = orig.get(i);
// TRUE if one value is not equal
if (!(obj instanceof String)) {
return true;
}
if (orderMatters) {
// check only the string with same index
if (!values[i].equals(obj)) {
return true;
}
}
else {
// check all strings
if (!ArrayUtils.contains(values, obj)) {
return true;
}
}
}
}
catch (NamingException e) {
// TRUE if we can't access the value
return true;
}
if (prev != null) {
// Also check against updatedAttrs, since there might have been
// a previous update
try {
for (int i = 0; i < prev.size(); i++) {
Object obj = prev.get(i);
// TRUE if one value is not equal
if (!(obj instanceof String)) {
return true;
}
if (orderMatters) {
// check only the string with same index
if (!values[i].equals(obj)) {
return true;
}
}
else {
// check all strings
if (!ArrayUtils.contains(values, obj)) {
return true;
}
}
}
}
catch (NamingException e) {
// TRUE if we can't access the value
return true;
}
}
// FALSE since we have compared all values
return false;
}
/**
* Checks if an entry has a specific attribute.
*
* This method simply calls exists(String) with the attribute name.
*
* @param attr the attribute to check.
* @return true if attribute exists in entry.
*/
protected final boolean exists(Attribute attr) {
return exists(attr.getID());
}
/**
* Checks if the attribute exists in this entry, either it was read or it
* has been added and update() has been called.
*
* @param attrId id of the attribute to check.
* @return true if the attribute exists in the entry.
*/
protected final boolean exists(String attrId) {
return originalAttrs.get(attrId) != null;
}
/*
* @see
* org.springframework.ldap.support.DirContextOperations#getStringAttribute
* (java.lang.String)
*/
public String getStringAttribute(String name) {
return (String) getObjectAttribute(name);
}
/*
* @see org.springframework.ldap.support.DirContextOperations#getObjectAttribute
* (java.lang.String)
*/
public Object getObjectAttribute(String name) {
Attribute oneAttr = originalAttrs.get(name);
if (oneAttr == null || oneAttr.size() == 0) { // LDAP-215
return null;
}
try {
return oneAttr.get();
}
catch (NamingException e) {
throw LdapUtils.convertLdapException(e);
}
}
// LDAP-215
/* (non-Javadoc)
* @see org.springframework.ldap.core.DirContextOperations#attributeExists(java.lang.String)
*/
public boolean attributeExists(String name) {
Attribute oneAttr = originalAttrs.get(name);
if (oneAttr == null) {
return false;
} else {
return true;
}
}
/*
* @see
* org.springframework.ldap.support.DirContextOperations#setAttributeValue
* (java.lang.String, java.lang.Object)
*/
public void setAttributeValue(String name, Object value) {
// new entry
if (!updateMode && value != null) {
originalAttrs.put(name, value);
}
// updating entry
if (updateMode) {
BasicAttribute attribute = new BasicAttribute(name);
if (value != null) {
attribute.add(value);
}
updatedAttrs.put(attribute);
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.DirContextOperations#addAttributeValue(
* java.lang.String, java.lang.Object)
*/
public void addAttributeValue(String name, Object value) {
addAttributeValue(name, value, DONT_ADD_IF_DUPLICATE_EXISTS);
}
public void addAttributeValue(String name, Object value,
boolean addIfDuplicateExists) {
if (!updateMode && value != null) {
Attribute attr = originalAttrs.get(name);
if (attr == null) {
originalAttrs.put(name, value);
}
else {
attr.add(value);
}
}
else if (updateMode) {
Attribute attr = updatedAttrs.get(name);
if (attr == null) {
if (originalAttrs.get(name) == null) {
// No match in the original attributes -
// add a new Attribute to updatedAttrs
updatedAttrs.put(name, value);
}
else {
// The attribute exists in the original attributes - clone
// that and add the new entry to it
attr = (Attribute) originalAttrs.get(name).clone();
if (addIfDuplicateExists || !attr.contains(value)) {
attr.add(value);
}
updatedAttrs.put(attr);
}
}
else {
attr.add(value);
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.DirContextOperations#removeAttributeValue
* (java.lang.String, java.lang.Object)
*/
public void removeAttributeValue(String name, Object value) {
if (!updateMode && value != null) {
Attribute attr = originalAttrs.get(name);
if (attr != null) {
attr.remove(value);
if (attr.size() == 0) {
originalAttrs.remove(name);
}
}
}
else if (updateMode) {
Attribute attr = updatedAttrs.get(name);
if (attr == null) {
if (originalAttrs.get(name) != null) {
attr = (Attribute) originalAttrs.get(name).clone();
attr.remove(value);
updatedAttrs.put(attr);
}
}
else {
attr.remove(value);
}
}
}
/*
* @see
* org.springframework.ldap.support.DirContextOperations#setAttributeValues
* (java.lang.String, java.lang.Object[])
*/
public void setAttributeValues(String name, Object[] values) {
setAttributeValues(name, values, ORDER_DOESNT_MATTER);
}
/*
* @see
* org.springframework.ldap.support.DirContextOperations#setAttributeValues
* (java.lang.String, java.lang.Object[], boolean)
*/
public void setAttributeValues(String name, Object[] values,
boolean orderMatters) {
Attribute a = new BasicAttribute(name, orderMatters);
for (int i = 0; values != null && i < values.length; i++) {
a.add(values[i]);
}
// only change the original attribute if not in update mode
if (!updateMode && values != null && values.length > 0) {
// don't save empty arrays
originalAttrs.put(a);
}
// possible to set an already existing attribute to an empty array
if (updateMode && isChanged(name, values, orderMatters)) {
updatedAttrs.put(a);
}
}
/*
* @see org.springframework.ldap.support.DirContextOperations#update()
*/
public void update() {
NamingEnumeration attributesEnumeration = null;
try {
attributesEnumeration = updatedAttrs.getAll();
// find what to update
while (attributesEnumeration.hasMore()) {
Attribute a = (Attribute) attributesEnumeration.next();
// if it does not exist it should be added
if (isEmptyAttribute(a)) {
originalAttrs.remove(a.getID());
}
else {
// Otherwise it should be set.
originalAttrs.put(a);
}
}
}
catch (NamingException e) {
throw LdapUtils.convertLdapException(e);
}
finally {
closeNamingEnumeration(attributesEnumeration);
}
// Reset the attributes to be updated
updatedAttrs = new BasicAttributes(true);
}
/*
* @see
* org.springframework.ldap.core.DirContextOperations#getStringAttributes
* (java.lang.String)
*/
public String[] getStringAttributes(String name) {
try {
return (String[]) collectAttributeValuesAsList(name).toArray(
new String[0]);
}
catch (NoSuchAttributeException e) {
// The attribute does not exist - contract says to return null.
return null;
}
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.core.DirContextOperations#getObjectAttributes
* (java.lang.String)
*/
public Object[] getObjectAttributes(String name) {
try {
return collectAttributeValuesAsList(name).toArray(new Object[0]);
}
catch (NoSuchAttributeException e) {
// The attribute does not exist - contract says to return null.
return null;
}
}
private List collectAttributeValuesAsList(String name) {
List list = new LinkedList();
LdapUtils.collectAttributeValues(originalAttrs, name, list);
return list;
}
/*
* @seeorg.springframework.ldap.support.DirContextOperations#
* getAttributeSortedStringSet(java.lang.String)
*/
public SortedSet getAttributeSortedStringSet(String name) {
try {
TreeSet attrSet = new TreeSet();
LdapUtils.collectAttributeValues(originalAttrs, name, attrSet);
return attrSet;
}
catch (NoSuchAttributeException e) {
// The attribute does not exist - contract says to return null.
return null;
}
}
/**
* Set the supplied attribute.
*
* @param attribute the attribute to set.
*/
public void setAttribute(Attribute attribute) {
if (!updateMode) {
originalAttrs.put(attribute);
}
else {
updatedAttrs.put(attribute);
}
}
/**
* Get all attributes.
*
* @return all attributes.
*/
public Attributes getAttributes() {
return originalAttrs;
}
/**
* @see javax.naming.directory.DirContext#getAttributes(Name)
*/
public Attributes getAttributes(Name name) throws NamingException {
return getAttributes(name.toString());
}
/**
* @see javax.naming.directory.DirContext#getAttributes(String)
*/
public Attributes getAttributes(String name) throws NamingException {
if (StringUtils.hasLength(name)) {
throw new NameNotFoundException();
}
return (Attributes) originalAttrs.clone();
}
/**
* @see javax.naming.directory.DirContext#getAttributes(Name, String[])
*/
public Attributes getAttributes(Name name, String[] attrIds)
throws NamingException {
return getAttributes(name.toString(), attrIds);
}
/**
* @see javax.naming.directory.DirContext#getAttributes(String, String[])
*/
public Attributes getAttributes(String name, String[] attrIds)
throws NamingException {
if (StringUtils.hasLength(name)) {
throw new NameNotFoundException();
}
Attributes a = new BasicAttributes(true);
Attribute target;
for (int i = 0; i < attrIds.length; i++) {
target = originalAttrs.get(attrIds[i]);
if (target != null) {
a.put(target);
}
}
return a;
}
/**
* @see javax.naming.directory.DirContext#modifyAttributes(javax.naming.Name,
* int, javax.naming.directory.Attributes)
*/
public void modifyAttributes(Name name, int modOp, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#modifyAttributes(String, int,
* Attributes)
*/
public void modifyAttributes(String name, int modOp, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#modifyAttributes(Name,
* ModificationItem[])
*/
public void modifyAttributes(Name name, ModificationItem[] mods)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#modifyAttributes(String,
* ModificationItem[])
*/
public void modifyAttributes(String name, ModificationItem[] mods)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#bind(Name, Object, Attributes)
*/
public void bind(Name name, Object obj, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#bind(String, Object, Attributes)
*/
public void bind(String name, Object obj, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#rebind(Name, Object, Attributes)
*/
public void rebind(Name name, Object obj, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#rebind(String, Object, Attributes)
*/
public void rebind(String name, Object obj, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#createSubcontext(Name, Attributes)
*/
public DirContext createSubcontext(Name name, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#createSubcontext(String,
* Attributes)
*/
public DirContext createSubcontext(String name, Attributes attrs)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#getSchema(Name)
*/
public DirContext getSchema(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#getSchema(String)
*/
public DirContext getSchema(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#getSchemaClassDefinition(Name)
*/
public DirContext getSchemaClassDefinition(Name name)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#getSchemaClassDefinition(String)
*/
public DirContext getSchemaClassDefinition(String name)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(Name, Attributes, String[])
*/
public NamingEnumeration search(Name name, Attributes matchingAttributes,
String[] attributesToReturn) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(String, Attributes,
* String[])
*/
public NamingEnumeration search(String name, Attributes matchingAttributes,
String[] attributesToReturn) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(Name, Attributes)
*/
public NamingEnumeration search(Name name, Attributes matchingAttributes)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(String, Attributes)
*/
public NamingEnumeration search(String name, Attributes matchingAttributes)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(Name, String,
* SearchControls)
*/
public NamingEnumeration search(Name name, String filter,
SearchControls cons) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(String, String,
* SearchControls)
*/
public NamingEnumeration search(String name, String filter,
SearchControls cons) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(Name, String, Object[],
* SearchControls)
*/
public NamingEnumeration search(Name name, String filterExpr,
Object[] filterArgs, SearchControls cons) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.directory.DirContext#search(String, String, Object[],
* SearchControls)
*/
public NamingEnumeration search(String name, String filterExpr,
Object[] filterArgs, SearchControls cons) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#lookup(Name)
*/
public Object lookup(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#lookup(String)
*/
public Object lookup(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#bind(Name, Object)
*/
public void bind(Name name, Object obj) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#bind(String, Object)
*/
public void bind(String name, Object obj) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#rebind(Name, Object)
*/
public void rebind(Name name, Object obj) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#rebind(String, Object)
*/
public void rebind(String name, Object obj) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#unbind(Name)
*/
public void unbind(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#unbind(String)
*/
public void unbind(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#rename(Name, Name)
*/
public void rename(Name oldName, Name newName) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#rename(String, String)
*/
public void rename(String oldName, String newName) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#list(Name)
*/
public NamingEnumeration list(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#list(String)
*/
public NamingEnumeration list(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#listBindings(Name)
*/
public NamingEnumeration listBindings(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#listBindings(String)
*/
public NamingEnumeration listBindings(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#destroySubcontext(Name)
*/
public void destroySubcontext(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#destroySubcontext(String)
*/
public void destroySubcontext(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#createSubcontext(Name)
*/
public Context createSubcontext(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#createSubcontext(String)
*/
public Context createSubcontext(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#lookupLink(Name)
*/
public Object lookupLink(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#lookupLink(String)
*/
public Object lookupLink(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#getNameParser(Name)
*/
public NameParser getNameParser(Name name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#getNameParser(String)
*/
public NameParser getNameParser(String name) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#composeName(Name, Name)
*/
public Name composeName(Name name, Name prefix) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#composeName(String, String)
*/
public String composeName(String name, String prefix)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#addToEnvironment(String, Object)
*/
public Object addToEnvironment(String propName, Object propVal)
throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#removeFromEnvironment(String)
*/
public Object removeFromEnvironment(String propName) throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#getEnvironment()
*/
public Hashtable getEnvironment() throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#close()
*/
public void close() throws NamingException {
throw new UnsupportedOperationException("Not implemented.");
}
/**
* @see javax.naming.Context#getNameInNamespace()
*/
public String getNameInNamespace() {
DistinguishedName result = new DistinguishedName(dn);
result.prepend(base);
return result.toString();
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.support.DirContextOperations#getDn()
*/
public Name getDn() {
return new DistinguishedName(dn);
}
/*
* (non-Javadoc)
*
* @see
* org.springframework.ldap.support.DirContextOperations#setDn(javax.naming
* .Name)
*/
public final void setDn(Name dn) {
if (!updateMode) {
this.dn = new DistinguishedName(dn.toString());
}
else {
throw new IllegalStateException(
"Not possible to call setDn() on a DirContextAdapter in update mode");
}
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
// A subclass with identical values should NOT be considered equal.
// EqualsBuilder in commons-lang cannot handle subclasses correctly.
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
return EqualsBuilder.reflectionEquals(this, obj);
}
/**
* @see Object#hashCode()
*/
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
/**
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append(getClass().getName());
buf.append(":");
if (dn != null) {
buf.append(" dn=" + dn);
}
buf.append(" {");
try {
for (NamingEnumeration i = originalAttrs.getAll(); i.hasMore();) {
Attribute attribute = (Attribute) i.next();
if (attribute.size() == 1) {
buf.append(attribute.getID());
buf.append('=');
buf.append(attribute.get());
}
else {
for (int j = 0; j < attribute.size(); j++) {
if (j > 0) {
buf.append(", ");
}
buf.append(attribute.getID());
buf.append('[');
buf.append(j);
buf.append("]=");
buf.append(attribute.get(j));
}
}
if (i.hasMore()) {
buf.append(", ");
}
}
}
catch (NamingException e) {
log.warn("Error in toString()");
}
buf.append('}');
return buf.toString();
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.core.DirContextOperations#getReferralUrl()
*/
public String getReferralUrl() {
return referralUrl;
}
/*
* (non-Javadoc)
*
* @see org.springframework.ldap.core.DirContextOperations#isReferral()
*/
public boolean isReferral() {
return StringUtils.hasLength(referralUrl);
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapRdnComponent.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000016313 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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.io.Serializable;
import java.net.URI;
import java.net.URISyntaxException;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Represents part of an LdapRdn. As specified in RFC2253 an LdapRdn may be
* composed of several attributes, separated by "+". An
* LdapRdnComponent represents one of these attributes.
*
* @author Mattias Hellborg Arthursson
*
*/
public class LdapRdnComponent implements Comparable, Serializable {
private static final long serialVersionUID = -3296747972616243038L;
private static final Log log = LogFactory.getLog(LdapRdnComponent.class);
public static final boolean DONT_DECODE_VALUE = false;
private String key;
private String value;
/**
* Constructs an LdapRdnComponent without decoding the value.
*
* @param key the Attribute name.
* @param value the Attribute value.
*/
public LdapRdnComponent(String key, String value) {
this(key, value, DONT_DECODE_VALUE);
}
/**
* Constructs an LdapRdnComponent, optionally decoding the value.
* true the value is decoded (typically
* used when a DN is parsed from a String), otherwise the value is used as
* specified.
* @see DistinguishedName#KEY_CASE_FOLD_PROPERTY
*/
public LdapRdnComponent(String key, String value, boolean decodeValue) {
Validate.notEmpty(key, "Key must not be empty");
Validate.notEmpty(value, "Value must not be empty");
String caseFold = System.getProperty(DistinguishedName.KEY_CASE_FOLD_PROPERTY);
if (StringUtils.isBlank(caseFold) || caseFold.equals(DistinguishedName.KEY_CASE_FOLD_LOWER)) {
this.key = StringUtils.lowerCase(key);
} else if (caseFold.equals(DistinguishedName.KEY_CASE_FOLD_UPPER)) {
this.key = StringUtils.upperCase(key);
} else if (caseFold.equals(DistinguishedName.KEY_CASE_FOLD_NONE)) {
this.key = key;
} else {
log
.warn("\"" + caseFold + "\" invalid property value for " + DistinguishedName.KEY_CASE_FOLD_PROPERTY
+ "; expected \"" + DistinguishedName.KEY_CASE_FOLD_LOWER + "\", \""
+ DistinguishedName.KEY_CASE_FOLD_UPPER + "\", or \""
+ DistinguishedName.KEY_CASE_FOLD_NONE + "\"");
this.key = StringUtils.lowerCase(key);
}
if (decodeValue) {
this.value = LdapEncoder.nameDecode(value);
}
else {
this.value = value;
}
}
/**
* Get the key (Attribute name) of this component.
*
* @return the key.
*/
public String getKey() {
return key;
}
/**
* Set the key (Attribute name) of this component.
*
* @param key the key.
* @deprecated Using this method changes the internal state of surrounding
* DistinguishedName instance. This should be avoided.
*/
public void setKey(String key) {
this.key = key;
}
/**
* Get the (Attribute) value of this component.
*
* @return the value.
*/
public String getValue() {
return value;
}
/**
* Set the (Attribute) value of this component.
*
* @param value the value.
* @deprecated Using this method changes the internal state of surrounding
* DistinguishedName instance. This should be avoided.
*/
public void setValue(String value) {
this.value = value;
}
/**
* Encode key and value to ldap.
*
* @return Properly ldap escaped rdn.
*/
protected String encodeLdap() {
StringBuffer buff = new StringBuffer(key.length() + value.length() * 2);
buff.append(key);
buff.append('=');
buff.append(LdapEncoder.nameEncode(value));
return buff.toString();
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
return getLdapEncoded();
}
/**
* @return The LdapRdn as a string where the value is LDAP-encoded.
*/
public String getLdapEncoded() {
return encodeLdap();
}
/**
* Get a String representation of this instance for use in URLs.
*
* @return a properly URL encoded representation of this instancs.
*/
public String encodeUrl() {
// Use the URI class to properly URL encode the value.
try {
URI valueUri = new URI(null, null, value, null);
return key + "=" + valueUri.toString();
}
catch (URISyntaxException e) {
// This should really never happen...
return key + "=" + "value";
}
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return key.toUpperCase().hashCode() ^ value.toUpperCase().hashCode();
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
// Slightly more lenient equals comparison here to enable immutable
// instances to equal mutable ones.
if (obj != null && obj instanceof LdapRdnComponent) {
LdapRdnComponent that = (LdapRdnComponent) obj;
return StringUtils.equalsIgnoreCase(this.key, that.key)
&& StringUtils.equalsIgnoreCase(this.value, that.value);
}
else {
return false;
}
}
/**
* Compare this instance to the supplied object.
*
* @param obj the object to compare to.
* @throws ClassCastException if the object is not possible to cast to an
* LdapRdnComponent.
*/
public int compareTo(Object obj) {
LdapRdnComponent that = (LdapRdnComponent) obj;
return this.toString().compareTo(that.toString());
}
/**
* Create an immutable copy of this instance. It will not be possible to
* modify the key or the value of the returned instance.
*
* @return an immutable copy of this instance.
* @since 1.3
*/
public LdapRdnComponent immutableLdapRdnComponent() {
return new ImmutableLdapRdnComponent(key, value);
}
private static class ImmutableLdapRdnComponent extends LdapRdnComponent {
private static final long serialVersionUID = -7099970046426346567L;
public ImmutableLdapRdnComponent(String key, String value) {
super(key, value);
}
public void setKey(String key) {
throw new UnsupportedOperationException("SetValue not supported for this immutable LdapRdnComponent");
}
public void setValue(String value) {
throw new UnsupportedOperationException("SetKey not supported for this immutable LdapRdnComponent");
}
}
}
././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DefaultDnParserFactory.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002520 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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.io.StringReader;
import org.springframework.ldap.core.DnParserImpl;
/**
* A factory for creating DnParser instances. The actual implementation of
* DnParser is generated using javacc and should not be constructed directly.
*
* @author Mattias Hellborg Arthursson
*
*/
public class DefaultDnParserFactory {
/**
* Create a new DnParser instance.
*
* @param string
* the DN String to be parsed.
* @return a new DnParser instance for parsing the supplied DN string.
*/
public static DnParser createDnParser(String string) {
return new DnParserImpl(new StringReader(string));
}
}
././@LongLink 0000000 0000000 0000000 00000000175 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/ContextSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004530 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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 javax.naming.directory.DirContext;
import org.springframework.ldap.NamingException;
/**
* A ContextSource is responsible for configuring and creating
* DirContext instances. It is typically used from
* {@link LdapTemplate} to acquiring contexts for LDAP operations, but may be
* used standalone to perform LDAP authentication.
*
* @see org.springframework.ldap.core.LdapTemplate
*
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public interface ContextSource {
/**
* Gets a read-only DirContext. The returned
* DirContext must be possible to perform read-only operations
* on.
*
* @return A DirContext instance, never null.
* @throws NamingException if some error occurs creating an DirContext.
*/
DirContext getReadOnlyContext() throws NamingException;
/**
* Gets a read-write DirContext instance.
*
* @return A DirContext instance, never null.
* @throws NamingException if some error occurs creating an
* DirContext.
*/
DirContext getReadWriteContext() throws NamingException;
/**
* Gets a DirContext instance authenticated using the supplied
* principal and credentials.
*
* @param principal The principal (typically a distinguished name of a user
* in the LDAP tree) to use for authentication.
* @param credentials The credentials to use for authentication.
* @return an authenticated DirContext instance, never
* null.
* @since 1.3
*/
DirContext getContext(String principal, String credentials) throws NamingException;
} ././@LongLink 0000000 0000000 0000000 00000000204 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AuthenticationSource.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002404 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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;
/**
* An AuthenticationSource is responsible for providing the
* principal (user DN) and credentials to be used when creating a new context.
*
* @author Mattias Hellborg Arthursson
*
*/
public interface AuthenticationSource {
/**
* Get the principal to use when creating an authenticated context.
*
* @return the principal (userDn).
*/
String getPrincipal();
/**
* Get the credentials to use when creating an authenticated context.
*
* @return the credentials (password).
*/
String getCredentials();
}
././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/AuthenticationErrorCallback.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001202 11475313376 030204 0 ustar package org.springframework.ldap.core;
/**
* Callback interface to be used in the authentication methods in
* {@link LdapOperations} for performing operations when there
* are authentication errors. Can be useful when the cause of the
* authentication failure needs to be retrieved.
*
* @author Ulrik Sandberg
* @since 1.3.1
*/
public interface AuthenticationErrorCallback {
/**
* This method will be called with the authentication exception in
* case there is a problem with the authentication.
*
* @param e the exception that was caught in the authentication method
*/
void execute(Exception e);
}
././@LongLink 0000000 0000000 0000000 00000000212 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/DefaultNameClassPairMapper.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002704 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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 javax.naming.NameClassPair;
import javax.naming.NamingException;
/**
* The default NameClassPairMapper implementation. This implementation simply
* takes the Name string from the supplied NameClassPair and returns it as
* result.
*
* @author Mattias Hellborg Arthursson
*
*/
public class DefaultNameClassPairMapper implements NameClassPairMapper {
/**
* Gets the Name from the supplied NameClassPair and returns it as the
* result.
*
* @param nameClassPair
* the NameClassPair to transform.
* @return the Name string from the NameClassPair.
*/
public Object mapFromNameClassPair(NameClassPair nameClassPair)
throws NamingException {
return nameClassPair.getName();
}
}
././@LongLink 0000000 0000000 0000000 00000000174 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/core/LdapTemplate.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000145100 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.List;
import javax.naming.Binding;
import javax.naming.Name;
import javax.naming.NameClassPair;
import javax.naming.NameNotFoundException;
import javax.naming.NamingEnumeration;
import javax.naming.PartialResultException;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.directory.SearchControls;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.ldap.NamingException;
import org.springframework.ldap.support.LdapUtils;
/**
* Executes core LDAP functionality and helps to avoid common errors, relieving
* the user of the burden of looking up contexts, looping through
* NamingEnumerations and closing contexts.
* PartialResultException to be thrown whenever a referral is
* encountered in a search. To avoid this, set the
* ignorePartialResultException property to true.
* There is currently no way of manually handling these referrals in the form of
* ReferralException, i.e. either you get the exception (and your
* results are lost) or all referrals are ignored (if the server is unable to
* handle them properly. Neither is there any simple way to get notified that a
* PartialResultException has been ignored (other than in the log).
*
* @see org.springframework.ldap.core.ContextSource
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public class LdapTemplate implements LdapOperations, InitializingBean {
private static final Log log = LogFactory.getLog(LdapTemplate.class);
private static final int DEFAULT_SEARCH_SCOPE = SearchControls.SUBTREE_SCOPE;
private static final boolean DONT_RETURN_OBJ_FLAG = false;
private static final boolean RETURN_OBJ_FLAG = true;
private static final String[] ALL_ATTRIBUTES = null;
private ContextSource contextSource;
private boolean ignorePartialResultException = false;
private boolean ignoreNameNotFoundException = false;
/**
* Constructor for bean usage.
*/
public LdapTemplate() {
}
/**
* Constructor to setup instance directly.
*
* @param contextSource the ContextSource to use.
*/
public LdapTemplate(ContextSource contextSource) {
this.contextSource = contextSource;
}
/**
* Set the ContextSource. Call this method when the default constructor has
* been used.
*
* @param contextSource the ContextSource.
*/
public void setContextSource(ContextSource contextSource) {
this.contextSource = contextSource;
}
/**
* Get the ContextSource.
*
* @return the ContextSource.
*/
public ContextSource getContextSource() {
return contextSource;
}
/**
* Specify whether NameNotFoundException should be ignored in
* searches. In previous version, NameNotFoundException caused
* by the search base not being found was silently ignored. The default
* behavior is now to treat this as an error (as it should), and to convert
* and re-throw the exception. The ability to revert to the previous
* behavior still exists. The only difference is that the incident is in
* that case no longer silently ignored, but logged as a warning.
*
* @param ignore true if NameNotFoundException
* should be ignored in searches, false otherwise. Default is
* false.
*
* @since 1.3
*/
public void setIgnoreNameNotFoundException(boolean ignore) {
this.ignoreNameNotFoundException = ignore;
}
/**
* Specify whether PartialResultException should be ignored in
* searches. AD servers typically have a problem with referrals. Normally a
* referral should be followed automatically, but this does not seem to work
* with AD servers. The problem manifests itself with a a
* PartialResultException being thrown when a referral is
* encountered by the server. Setting this property to true
* presents a workaround to this problem by causing
* PartialResultException to be ignored, so that the search
* method returns normally. Default value of this parameter is
* false.
*
* @param ignore true if PartialResultException
* should be ignored in searches, false otherwise. Default is
* false.
*/
public void setIgnorePartialResultException(boolean ignore) {
this.ignorePartialResultException = ignore;
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, int, boolean,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(Name base, String filter, int searchScope, boolean returningObjFlag,
NameClassPairCallbackHandler handler) {
search(base, filter, getDefaultSearchControls(searchScope, returningObjFlag, ALL_ATTRIBUTES), handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, int, boolean,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(String base, String filter, int searchScope, boolean returningObjFlag,
NameClassPairCallbackHandler handler) {
search(base, filter, getDefaultSearchControls(searchScope, returningObjFlag, ALL_ATTRIBUTES), handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(final Name base, final String filter, final SearchControls controls,
NameClassPairCallbackHandler handler) {
// Create a SearchExecutor to perform the search.
SearchExecutor se = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.search(base, filter, controls);
}
};
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(se, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.NameClassPairCallbackHandler)
*/
public void search(final String base, final String filter, final SearchControls controls,
NameClassPairCallbackHandler handler) {
// Create a SearchExecutor to perform the search.
SearchExecutor se = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.search(base, filter, controls);
}
};
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(se, handler);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(javax.naming.Name,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.NameClassPairCallbackHandler,
* org.springframework.ldap.core.DirContextProcessor)
*/
public void search(final Name base, final String filter, final SearchControls controls,
NameClassPairCallbackHandler handler, DirContextProcessor processor) {
// Create a SearchExecutor to perform the search.
SearchExecutor se = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.search(base, filter, controls);
}
};
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(se, handler, processor);
}
/*
* @see
* org.springframework.ldap.core.LdapOperations#search(java.lang.String,
* java.lang.String, javax.naming.directory.SearchControls,
* org.springframework.ldap.core.NameClassPairCallbackHandler,
* org.springframework.ldap.core.DirContextProcessor)
*/
public void search(final String base, final String filter, final SearchControls controls,
NameClassPairCallbackHandler handler, DirContextProcessor processor) {
// Create a SearchExecutor to perform the search.
SearchExecutor se = new SearchExecutor() {
public NamingEnumeration executeSearch(DirContext ctx) throws javax.naming.NamingException {
return ctx.search(base, filter, controls);
}
};
if (handler instanceof ContextMapperCallbackHandler) {
assureReturnObjFlagSet(controls);
}
search(se, handler, processor);
}
/**
* Perform a search operation, such as a search(), list() or listBindings().
* This method handles all the plumbing; getting a readonly context; looping
* through the NamingEnumeration and closing the context and enumeration. It
* also calls the supplied DirContextProcessor before and after the search,
* respectively. This enables custom pre-processing and post-processing,
* like for example when handling paged results or other search controls.
* null. If no custom processing should take place,
* please use e.g.
* {@link #search(SearchExecutor, NameClassPairCallbackHandler)}.
* @throws NamingException if any error occurs. Note that a
* NameNotFoundException will be ignored. Instead this is interpreted that
* no entries were found.
*/
public void search(SearchExecutor se, NameClassPairCallbackHandler handler, DirContextProcessor processor) {
DirContext ctx = contextSource.getReadOnlyContext();
NamingEnumeration results = null;
RuntimeException ex = null;
try {
processor.preProcess(ctx);
results = se.executeSearch(ctx);
while (results.hasMore()) {
NameClassPair result = (NameClassPair) results.next();
handler.handleNameClassPair(result);
}
}
catch (NameNotFoundException e) {
// It is possible to ignore errors caused by base not found
if (ignoreNameNotFoundException) {
log.warn("Base context not found, ignoring: " + e.getMessage());
}
else {
ex = LdapUtils.convertLdapException(e);
}
}
catch (PartialResultException e) {
// Workaround for AD servers not handling referrals correctly.
if (ignorePartialResultException) {
log.debug("PartialResultException encountered and ignored", e);
}
else {
ex = LdapUtils.convertLdapException(e);
}
}
catch (javax.naming.NamingException e) {
ex = LdapUtils.convertLdapException(e);
}
finally {
try {
processor.postProcess(ctx);
}
catch (javax.naming.NamingException e) {
if (ex == null) {
ex = LdapUtils.convertLdapException(e);
}
else {
// We already had an exception from above and should ignore
// this one.
log.debug("Ignoring Exception from postProcess, " + "main exception thrown instead", e);
}
}
closeContextAndNamingEnumeration(ctx, results);
// If we got an exception it should be thrown.
if (ex != null) {
throw ex;
}
}
}
/**
* Perform a search operation, such as a search(), list() or listBindings().
* This method handles all the plumbing; getting a readonly context; looping
* through the NamingEnumeration and closing the context and enumeration.
* finally blocks in JNDI code.
*
* @param context the JNDI Context to close (may be null)
*/
public static void closeContext(DirContext context) {
if (context != null) {
try {
context.close();
}
catch (NamingException ex) {
logger.debug("Could not close JNDI DirContext", ex);
}
catch (Throwable ex) {
// We don't trust the JNDI provider: It might throw
// RuntimeException or Error.
logger.debug("Unexpected exception on closing JNDI DirContext", ex);
}
}
}
/**
* Convert the specified checked {@link javax.naming.NamingException
* NamingException} to a Spring LDAP runtime
* {@link org.springframework.ldap.NamingException NamingException}
* equivalent.
*
* @param ex the original checked NamingException to convert
* @return the Spring LDAP runtime NamingException wrapping the given
* exception
*/
public static NamingException convertLdapException(javax.naming.NamingException ex) {
Assert.notNull(ex, "NamingException must not be null");
if (ex.getClass().equals(javax.naming.directory.AttributeInUseException.class)) {
return new org.springframework.ldap.AttributeInUseException(
(javax.naming.directory.AttributeInUseException) ex);
}
if (ex.getClass().equals(javax.naming.directory.AttributeModificationException.class)) {
return new org.springframework.ldap.AttributeModificationException(
(javax.naming.directory.AttributeModificationException) ex);
}
if (ex.getClass().equals(javax.naming.CannotProceedException.class)) {
return new org.springframework.ldap.CannotProceedException((javax.naming.CannotProceedException) ex);
}
if (ex.getClass().equals(javax.naming.CommunicationException.class)) {
return new org.springframework.ldap.CommunicationException((javax.naming.CommunicationException) ex);
}
if (ex.getClass().equals(javax.naming.ConfigurationException.class)) {
return new org.springframework.ldap.ConfigurationException((javax.naming.ConfigurationException) ex);
}
if (ex.getClass().equals(javax.naming.ContextNotEmptyException.class)) {
return new org.springframework.ldap.ContextNotEmptyException((javax.naming.ContextNotEmptyException) ex);
}
if (ex.getClass().equals(javax.naming.InsufficientResourcesException.class)) {
return new org.springframework.ldap.InsufficientResourcesException(
(javax.naming.InsufficientResourcesException) ex);
}
if (ex.getClass().equals(javax.naming.InterruptedNamingException.class)) {
return new org.springframework.ldap.InterruptedNamingException((javax.naming.InterruptedNamingException) ex);
}
if (ex.getClass().equals(javax.naming.directory.InvalidAttributeIdentifierException.class)) {
return new org.springframework.ldap.InvalidAttributeIdentifierException(
(javax.naming.directory.InvalidAttributeIdentifierException) ex);
}
if (ex.getClass().equals(javax.naming.directory.InvalidAttributesException.class)) {
return new org.springframework.ldap.InvalidAttributesException(
(javax.naming.directory.InvalidAttributesException) ex);
}
if (ex.getClass().equals(javax.naming.directory.InvalidAttributeValueException.class)) {
return new org.springframework.ldap.InvalidAttributeValueException(
(javax.naming.directory.InvalidAttributeValueException) ex);
}
if (ex.getClass().equals(javax.naming.InvalidNameException.class)) {
return new org.springframework.ldap.InvalidNameException((javax.naming.InvalidNameException) ex);
}
if (ex.getClass().equals(javax.naming.directory.InvalidSearchControlsException.class)) {
return new org.springframework.ldap.InvalidSearchControlsException(
(javax.naming.directory.InvalidSearchControlsException) ex);
}
if (ex.getClass().equals(javax.naming.directory.InvalidSearchFilterException.class)) {
return new org.springframework.ldap.InvalidSearchFilterException(
(javax.naming.directory.InvalidSearchFilterException) ex);
}
// this class is abstract, so it can never be of exactly this class;
// using instanceof
if (ex instanceof javax.naming.ldap.LdapReferralException) {
return new org.springframework.ldap.LdapReferralException((javax.naming.ldap.LdapReferralException) ex);
}
// Skipping the abstract superclass javax.naming.ReferralException
// LimitExceededException hierarchy
if (ex.getClass().equals(javax.naming.SizeLimitExceededException.class)) {
return new org.springframework.ldap.SizeLimitExceededException((javax.naming.SizeLimitExceededException) ex);
}
if (ex.getClass().equals(javax.naming.TimeLimitExceededException.class)) {
return new org.springframework.ldap.TimeLimitExceededException((javax.naming.TimeLimitExceededException) ex);
}
// this class is the superclass of the two above
if (ex.getClass().equals(javax.naming.LimitExceededException.class)) {
return new org.springframework.ldap.LimitExceededException((javax.naming.LimitExceededException) ex);
}
// LinkException hierarchy
if (ex.getClass().equals(javax.naming.LinkLoopException.class)) {
return new org.springframework.ldap.LinkLoopException((javax.naming.LinkLoopException) ex);
}
if (ex.getClass().equals(javax.naming.MalformedLinkException.class)) {
return new org.springframework.ldap.MalformedLinkException((javax.naming.MalformedLinkException) ex);
}
// this class is the superclass of the two above
if (ex.getClass().equals(javax.naming.LinkException.class)) {
return new org.springframework.ldap.LinkException((javax.naming.LinkException) ex);
}
if (ex.getClass().equals(javax.naming.NameAlreadyBoundException.class)) {
return new org.springframework.ldap.NameAlreadyBoundException((javax.naming.NameAlreadyBoundException) ex);
}
if (ex.getClass().equals(javax.naming.NameNotFoundException.class)) {
return new org.springframework.ldap.NameNotFoundException((javax.naming.NameNotFoundException) ex);
}
// NamingSecurityException hierarchy
if (ex.getClass().equals(javax.naming.NoPermissionException.class)) {
return new org.springframework.ldap.NoPermissionException((javax.naming.NoPermissionException) ex);
}
if (ex.getClass().equals(javax.naming.AuthenticationException.class)) {
return new org.springframework.ldap.AuthenticationException((javax.naming.AuthenticationException) ex);
}
if (ex.getClass().equals(javax.naming.AuthenticationNotSupportedException.class)) {
return new org.springframework.ldap.AuthenticationNotSupportedException(
(javax.naming.AuthenticationNotSupportedException) ex);
}
// Skipping the abstract superclass javax.naming.NamingSecurityException
if (ex.getClass().equals(javax.naming.NoInitialContextException.class)) {
return new org.springframework.ldap.NoInitialContextException((javax.naming.NoInitialContextException) ex);
}
if (ex.getClass().equals(javax.naming.directory.NoSuchAttributeException.class)) {
return new org.springframework.ldap.NoSuchAttributeException(
(javax.naming.directory.NoSuchAttributeException) ex);
}
if (ex.getClass().equals(javax.naming.NotContextException.class)) {
return new org.springframework.ldap.NotContextException((javax.naming.NotContextException) ex);
}
if (ex.getClass().equals(javax.naming.OperationNotSupportedException.class)) {
return new org.springframework.ldap.OperationNotSupportedException(
(javax.naming.OperationNotSupportedException) ex);
}
if (ex.getClass().equals(javax.naming.PartialResultException.class)) {
return new org.springframework.ldap.PartialResultException((javax.naming.PartialResultException) ex);
}
if (ex.getClass().equals(javax.naming.directory.SchemaViolationException.class)) {
return new org.springframework.ldap.SchemaViolationException(
(javax.naming.directory.SchemaViolationException) ex);
}
if (ex.getClass().equals(javax.naming.ServiceUnavailableException.class)) {
return new org.springframework.ldap.ServiceUnavailableException(
(javax.naming.ServiceUnavailableException) ex);
}
// fallback
return new org.springframework.ldap.UncategorizedLdapException(ex);
}
/**
* Get the actual class of the supplied DirContext instance; LdapContext or
* DirContext.
*
* @param context the DirContext instance to check.
* @return LdapContext.class if context is an LdapContext, DirContext.class
* otherwise.
*/
public static Class getActualTargetClass(DirContext context) {
if (context instanceof LdapContext) {
return LdapContext.class;
}
return DirContext.class;
}
/**
* Collect all the values of a the specified attribute from the supplied
* Attributes.
*
* @param attributes The Attributes; not null.
* @param name The name of the Attribute to get values for.
* @param collection the collection to collect the values in.
* @throws NoSuchAttributeException if no attribute with the specified name
* exists.
* @since 1.3
*/
public static void collectAttributeValues(Attributes attributes, String name, Collection collection) {
Assert.notNull(attributes, "Attributes must not be null");
Attribute attribute = attributes.get(name);
if (attribute == null) {
throw new NoSuchAttributeException("No attribute with name '" + name + "'");
}
iterateAttributeValues(attribute, new CollectingAttributeValueCallbackHandler(collection));
}
/**
* Iterate through all the values of the specified Attribute calling back to
* the specified callbackHandler.
* @param attribute the Attribute to work with; not null.
* @param callbackHandler the callbackHandler; not null.
* @since 1.3
*/
public static void iterateAttributeValues(Attribute attribute, AttributeValueCallbackHandler callbackHandler) {
Assert.notNull(attribute, "Attribute must not be null");
Assert.notNull(callbackHandler, "callbackHandler must not be null");
for (int i = 0; i < attribute.size(); i++) {
try {
callbackHandler.handleAttributeValue(attribute.getID(), attribute.get(i), i);
}
catch (javax.naming.NamingException e) {
throw LdapUtils.convertLdapException(e);
}
}
}
/**
* An {@link AttributeValueCallbackHandler} to collect values in a supplied
* collection.
*
* @author Mattias Hellborg Arthursson
*/
private final static class CollectingAttributeValueCallbackHandler implements AttributeValueCallbackHandler {
private final Collection collection;
public CollectingAttributeValueCallbackHandler(Collection collection) {
Assert.notNull(collection, "Collection must not be null");
this.collection = collection;
}
public final void handleAttributeValue(String attributeName, Object attributeValue, int index) {
collection.add(attributeValue);
}
}
/**
* Converts a CompositeName to a String in a way that avoids escaping
* problems, such as the dreaded "triple backslash" problem.
*
* @param compositeName The CompositeName to convert
* @return String containing the String representation of name
*/
public static String convertCompositeNameToString(
CompositeName compositeName) {
if (compositeName.size() > 0) {
// A lookup with an empty String seems to produce an empty
// compositeName here; need to take this into account.
return compositeName.get(0);
}
else {
return "";
}
}
/**
* Converts a binary SID to its String representation, according to the
* algorithm described here. Thanks to Eyal
* Lupu for algorithmic inspiration.
*
*
* If you have a SID like S-a-b-c-d-e-f-g-...
*
* Then the bytes are
* a (revision)
* N (number of dashes minus two)
* bbbbbb (six bytes of "b" treated as a 48-bit number in big-endian format)
* cccc (four bytes of "c" treated as a 32-bit number in little-endian format)
* dddd (four bytes of "d" treated as a 32-bit number in little-endian format)
* eeee (four bytes of "e" treated as a 32-bit number in little-endian format)
* ffff (four bytes of "f" treated as a 32-bit number in little-endian format)
* etc.
*
* So for example, if your SID is S-1-5-21-2127521184-1604012920-1887927527-72713, then your raw hex SID is
*
* 010500000000000515000000A065CF7E784B9B5FE77C8770091C0100
*
* This breaks down as follows:
* 01 S-1
* 05 (seven dashes, seven minus two = 5)
* 000000000005 (5 = 0x000000000005, big-endian)
* 15000000 (21 = 0x00000015, little-endian)
* A065CF7E (2127521184 = 0x7ECF65A0, little-endian)
* 784B9B5F (1604012920 = 0x5F9B4B78, little-endian)
* E77C8770 (1887927527 = 0X70877CE7, little-endian)
* 091C0100 (72713 = 0x00011c09, little-endian)
*
* S-1- version number (SID_REVISION)
* -5- SECURITY_NT_AUTHORITY
* -21- SECURITY_NT_NON_UNIQUE
* -...-...-...- these identify the machine that issued the SID
* 72713 unique user id on the machine
*
*
* @param sid binary SID in byte array format
* @return String version of the given sid
* @since 1.3.1
*/
public static String convertBinarySidToString(byte[] sid) {
// Add the 'S' prefix
StringBuffer sidAsString = new StringBuffer("S-");
// bytes[0] : in the array is the version (must be 1 but might
// change in the future)
sidAsString.append(sid[0]).append('-');
// bytes[2..7] : the Authority
StringBuffer sb = new StringBuffer();
for (int t = 2; t <= 7; t++) {
String hexString = Integer.toHexString(sid[t] & 0xFF);
sb.append(hexString);
}
sidAsString.append(Long.parseLong(sb.toString(), 16));
// bytes[1] : the sub authorities count
int count = sid[1];
// bytes[8..end] : the sub authorities (these are Integers - notice
// the endian)
for (int i = 0; i < count; i++) {
int currSubAuthOffset = i * 4;
sb.setLength(0);
sb.append(toHexString((byte) (sid[11 + currSubAuthOffset] & 0xFF)));
sb.append(toHexString((byte) (sid[10 + currSubAuthOffset] & 0xFF)));
sb.append(toHexString((byte) (sid[9 + currSubAuthOffset] & 0xFF)));
sb.append(toHexString((byte) (sid[8 + currSubAuthOffset] & 0xFF)));
sidAsString.append('-').append(Long.parseLong(sb.toString(), 16));
}
// That's it - we have the SID
return sidAsString.toString();
}
/**
* Converts a String SID to its binary representation, according to the
* algorithm described here.
*
* @param string SID in readable format
* @return Binary version of the given sid
* @see LdapUtils#convertBinarySidToString(byte[])
* @since 1.3.1
*/
public static byte[] convertStringSidToBinary(String string) {
String[] parts = string.split("-");
byte sidRevision = (byte) Integer.parseInt(parts[1]);
int subAuthCount = parts.length - 3;
byte[] sid = new byte[] {sidRevision, (byte) subAuthCount};
sid = ArrayUtils.addAll(sid, numberToBytes(parts[2], 6, true));
for (int i = 0; i < subAuthCount; i++) {
sid = ArrayUtils.addAll(sid, numberToBytes(parts[3 + i], 4, false));
}
return sid;
}
/**
* Converts the given number to a binary representation of the specified
* length and "endian-ness".
*
* @param number String with number to convert
* @param length How long the resulting binary array should be
* @param bigEndian true if big endian (5=0005), or
* false if little endian (5=5000)
* @return byte array containing the binary result in the given order
*/
static byte[] numberToBytes(String number, int length, boolean bigEndian) {
BigInteger bi = new BigInteger(number);
byte[] bytes = bi.toByteArray();
int remaining = length - bytes.length;
if (remaining < 0) {
bytes = ArrayUtils.subarray(bytes, -remaining, bytes.length);
} else {
byte[] fill = new byte[remaining];
bytes = ArrayUtils.addAll(fill, bytes);
}
if (!bigEndian) {
ArrayUtils.reverse(bytes);
}
return bytes;
}
/**
* Converts a byte into its hexadecimal representation, padding with a
* leading zero to get an even number of characters.
*
* @param b value to convert
* @return hex string, possibly padded with a zero
*/
static String toHexString(final byte b) {
String hexString = Integer.toHexString(b & 0xFF);
if (hexString.length() % 2 != 0) {
// Pad with 0
hexString = "0" + hexString;
}
return hexString;
}
/**
* Converts a byte array into its hexadecimal representation, padding each
* with a leading zero to get an even number of characters.
*
* @param b values to convert
* @return hex string, possibly with elements padded with a zero
*/
static String toHexString(final byte[] b) {
StringBuffer sb = new StringBuffer("{");
for (int i = 0; i < b.length; i++) {
sb.append(toHexString(b[i]));
if (i < b.length - 1) {
sb.append(",");
}
}
sb.append("}");
return sb.toString();
}
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/SchemaViolationException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002050 11475313376 030206 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI SchemaViolationException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.SchemaViolationException
*/
public class SchemaViolationException extends NamingException {
public SchemaViolationException(
javax.naming.directory.SchemaViolationException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/LdapReferralException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002272 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI LdapReferralException.
*
* This class is not abstract. We need to be able to instantiate it, should the
* caught exception be a provider-specific subclass of
* {@link javax.naming.ldap.LdapReferralException}.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.ldap.LdapReferralException
*/
public class LdapReferralException extends ReferralException {
public LdapReferralException(javax.naming.ldap.LdapReferralException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000216 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidAttributeIdentifierException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002137 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidAttributeIdentifierException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.InvalidAttributeIdentifierException
*/
public class InvalidAttributeIdentifierException extends NamingException {
public InvalidAttributeIdentifierException(
javax.naming.directory.InvalidAttributeIdentifierException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/AuthenticationException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002011 11475313376 030203 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI AuthenticationException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.AuthenticationException
*/
public class AuthenticationException extends NamingSecurityException {
public AuthenticationException(javax.naming.AuthenticationException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000212 11475313376 030204 0 ustar
Base package of Spring LDAP, containing an unchecked mirror of the JNDI NamingException hierarchy.
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/UncategorizedLdapException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002277 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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;
/**
* NamingException to be thrown when no other matching subclass is found.
*
* @author Ulrik Sandberg
* @since 1.2
*/
public class UncategorizedLdapException extends NamingException {
public UncategorizedLdapException(String msg) {
super(msg);
}
public UncategorizedLdapException(String msg, Throwable cause) {
super(msg, cause);
}
public UncategorizedLdapException(Throwable cause) {
super("Uncategorized exception occured during LDAP processing", cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/AttributeInUseException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002043 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI AttributeInUseException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.AttributeInUseException
*/
public class AttributeInUseException extends NamingException {
public AttributeInUseException(
javax.naming.directory.AttributeInUseException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/CannotProceedException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001774 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI CannotProceedException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.CannotProceedException
*/
public class CannotProceedException extends NamingException {
public CannotProceedException(javax.naming.CannotProceedException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/PagedResult.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000005011 11475313376 030206 0 ustar /*
* Copyright 2005-2010 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.control;
import java.util.List;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
/**
* Bean to encapsulate a result List and a {@link PagedResultsCookie} to use for
* returning the results when using {@link PagedResultsRequestControl}.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public class PagedResult {
private List resultList;
private PagedResultsCookie cookie;
/**
* Constructs a PagedResults using the supplied List and
* {@link PagedResultsCookie}.
*
* @param resultList
* the result list.
* @param cookie
* the cookie.
*/
public PagedResult(List resultList, PagedResultsCookie cookie) {
this.resultList = resultList;
this.cookie = cookie;
}
/**
* Get the cookie.
*
* @return the cookie.
*/
public PagedResultsCookie getCookie() {
return cookie;
}
/**
* Get the result list.
*
* @return the result list.
*/
public List getResultList() {
return resultList;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj != null && this.getClass().equals(obj.getClass())) {
PagedResult that = (PagedResult) obj;
return new EqualsBuilder().append(this.resultList, that.resultList)
.append(this.cookie, that.cookie).isEquals();
}
return false;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return new HashCodeBuilder().append(this.resultList)
.append(this.cookie).toHashCode();
}
}
././@LongLink 0000000 0000000 0000000 00000000221 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/SortControlDirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006740 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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.control;
import javax.naming.ldap.Control;
/**
* DirContextProcessor implementation for managing the SortControl. Note that
* this class is stateful, so a new instance needs to be instantiated for each
* new search.
*
* @author Ulrik Sandberg
*/
public class SortControlDirContextProcessor extends AbstractFallbackRequestAndResponseControlDirContextProcessor {
private static final String DEFAULT_REQUEST_CONTROL = "javax.naming.ldap.SortControl";
private static final String FALLBACK_REQUEST_CONTROL = "com.sun.jndi.ldap.ctl.SortControl";
private static final String DEFAULT_RESPONSE_CONTROL = "javax.naming.ldap.SortResponseControl";
private static final String FALLBACK_RESPONSE_CONTROL = "com.sun.jndi.ldap.ctl.SortResponseControl";
/**
* What key to sort on.
*/
String sortKey;
/**
* Whether the search result actually was sorted.
*/
private boolean sorted;
/**
* The result code of the supposedly sorted search.
*/
private int resultCode;
/**
* Constructs a new instance using the supplied sort key.
*
* @param sortKey the sort key, i.e. the attribute name to sort on.
*/
public SortControlDirContextProcessor(String sortKey) {
this.sortKey = sortKey;
this.sorted = false;
this.resultCode = -1;
defaultRequestControl = DEFAULT_REQUEST_CONTROL;
defaultResponseControl = DEFAULT_RESPONSE_CONTROL;
fallbackRequestControl = FALLBACK_REQUEST_CONTROL;
fallbackResponseControl = FALLBACK_RESPONSE_CONTROL;
loadControlClasses();
}
/**
* Check whether the returned values were actually sorted by the server.
*
* @return true if the result was sorted, false
* otherwise.
*/
public boolean isSorted() {
return sorted;
}
/**
* Get the result code returned by the control.
*
* @return result code.
*/
public int getResultCode() {
return resultCode;
}
/**
* Get the sort key.
*
* @return the sort key.
*/
public String getSortKey() {
return sortKey;
}
/*
* @see
* org.springframework.ldap.control.AbstractRequestControlDirContextProcessor
* #createRequestControl()
*/
public Control createRequestControl() {
return super.createRequestControl(new Class[] { String[].class, boolean.class }, new Object[] {
new String[] { sortKey }, Boolean.valueOf(critical) });
}
/*
* @see org.springframework.ldap.control.
* AbstractFallbackRequestAndResponseControlDirContextProcessor
* #handleResponse(java.lang.Object)
*/
protected void handleResponse(Object control) {
Boolean result = (Boolean) invokeMethod("isSorted", responseControlClass, control);
this.sorted = result.booleanValue();
Integer code = (Integer) invokeMethod("getResultCode", responseControlClass, control);
this.resultCode = code.intValue();
}
}
././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000146 11475313376 030212 0 ustar
Support classes for custom request control context processors.
././@LongLink 0000000 0000000 0000000 00000000257 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/AbstractFallbackRequestAndResponseControlDirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000014646 11475313376 030224 0 ustar package org.springframework.ldap.control;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.Control;
import javax.naming.ldap.LdapContext;
import org.springframework.ldap.UncategorizedLdapException;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
/**
* Convenient base class useful when implementing a standard DirContextProcessor
* which has a request control and a response control. It handles the loading of
* the control classes, using fallback implementations specified by the subclass
* if necessary. It handles the request control constructor invocation; it only
* needs the constructor arguments to be provided. It also handles most of the
* work in the post processing of the response control, only delegating to a
* template method for the actual value retrieval. In short, it makes it easy to
* implement a custom DirContextProcessor.
* public class SortControlDirContextProcessor extends AbstractFallbackRequestAndResponseControlDirContextProcessor {
* String sortKey;
*
* private boolean sorted = false;
*
* private int resultCode = -1;
*
* public SortControlDirContextProcessor(String sortKey) {
* this.sortKey = sortKey;
*
* defaultRequestControl = "javax.naming.ldap.SortControl";
* defaultResponseControl = "com.sun.jndi.ldap.ctl.SortControl";
* fallbackRequestControl = "javax.naming.ldap.SortResponseControl";
* fallbackResponseControl = "com.sun.jndi.ldap.ctl.SortResponseControl";
*
* loadControlClasses();
* }
*
* public boolean isSorted() {
* return sorted;
* }
*
* public int getResultCode() {
* return resultCode;
* }
*
* public Control createRequestControl() {
* return super.createRequestControl(new Class[] { String[].class, boolean.class }, new Object[] {
* new String[] { sortKey }, Boolean.valueOf(critical) });
* }
*
* protected void handleResponse(Object control) {
* Boolean result = (Boolean) invokeMethod("isSorted", responseControlClass, control);
* this.sorted = result.booleanValue();
* Integer code = (Integer) invokeMethod("getResultCode", responseControlClass, control);
* resultCode = code.intValue();
* }
* }
*
*
* @author Ulrik Sandberg
*/
public abstract class AbstractFallbackRequestAndResponseControlDirContextProcessor extends
AbstractRequestControlDirContextProcessor {
private static final boolean CRITICAL_CONTROL = true;
protected Class responseControlClass;
protected Class requestControlClass;
protected boolean critical = CRITICAL_CONTROL;
protected String defaultRequestControl;
protected String defaultResponseControl;
protected String fallbackRequestControl;
protected String fallbackResponseControl;
protected void loadControlClasses() {
Assert.notNull(defaultRequestControl, "defaultRequestControl must not be null");
Assert.notNull(defaultResponseControl, "defaultResponseControl must not be null");
Assert.notNull(fallbackRequestControl, "fallbackRequestControl must not be null");
Assert.notNull(fallbackResponseControl, "fallbackReponseControl must not be null");
try {
requestControlClass = Class.forName(defaultRequestControl);
responseControlClass = Class.forName(defaultResponseControl);
}
catch (ClassNotFoundException e) {
log.debug("Default control classes not found - falling back to LdapBP classes", e);
try {
requestControlClass = Class.forName(fallbackRequestControl);
responseControlClass = Class.forName(fallbackResponseControl);
}
catch (ClassNotFoundException e1) {
throw new UncategorizedLdapException(
"Neither default nor fallback classes are available - unable to proceed", e);
}
}
}
/**
* Set the class of the expected ResponseControl for the sorted result
* response.
*
* @param responseControlClass Class of the expected response control.
*/
public void setResponseControlClass(Class responseControlClass) {
this.responseControlClass = responseControlClass;
}
public void setRequestControlClass(Class requestControlClass) {
this.requestControlClass = requestControlClass;
}
/**
* Utility method for invoking a method on a Control.
* @param method name of method to invoke
* @param clazz Class of the object that the method should be invoked on
* @param control Instance that the method should be invoked on
* @return the invocation result, if any
*/
protected Object invokeMethod(String method, Class clazz, Object control) {
Method actualMethod = ReflectionUtils.findMethod(clazz, method);
return ReflectionUtils.invokeMethod(actualMethod, control);
}
/**
* Creates a request control using the constructor parameters given in
* params.
* @param paramTypes Types of the constructor parameters
* @param params Actual constructor parameters
* @return Control to be used by the DirContextProcessor
*/
public Control createRequestControl(Class[] paramTypes, Object[] params) {
Constructor constructor = ClassUtils.getConstructorIfAvailable(requestControlClass, paramTypes);
if (constructor == null) {
throw new IllegalArgumentException("Failed to find an appropriate RequestControl constructor");
}
Control result = null;
try {
result = (Control) constructor.newInstance(params);
}
catch (Exception e) {
ReflectionUtils.handleReflectionException(e);
}
return result;
}
/*
* @see
* org.springframework.ldap.core.DirContextProcessor#postProcess(javax.naming
* .directory.DirContext)
*/
public void postProcess(DirContext ctx) throws NamingException {
LdapContext ldapContext = (LdapContext) ctx;
Control[] responseControls = ldapContext.getResponseControls();
if (responseControls == null) {
responseControls = new Control[0];
}
// Go through response controls and get info, regardless of class
for (int i = 0; i < responseControls.length; i++) {
Control responseControl = responseControls[i];
// check for match, try fallback otherwise
if (responseControl.getClass().isAssignableFrom(responseControlClass)) {
Object control = responseControl;
handleResponse(control);
return;
}
}
log.fatal("No matching response control found for paged results - looking for '" + responseControlClass);
}
protected abstract void handleResponse(Object control);
}
././@LongLink 0000000 0000000 0000000 00000000215 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/PagedResultsRequestControl.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000016260 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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.control;
import org.springframework.ldap.UncategorizedLdapException;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.Control;
import javax.naming.ldap.LdapContext;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
* DirContextProcessor implementation for managing the paged results control.
* Note that due to the internal workings of LdapTemplate, the
* target connection is closed after each LDAP call. The PagedResults control
* require the same connection be used for each call, which means we need to
* make sure the target connection is never actually closed. There's basically
* two ways of making this happen: use the SingleContextSource
* implementation or make sure all calls happen within a single LDAP transaction
* (using ContextSourceTransactionManager).
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
* @deprecated Use PagedResultsDirContextProcessor instead.
*/
public class PagedResultsRequestControl extends AbstractRequestControlDirContextProcessor {
private static final boolean CRITICAL_CONTROL = true;
private static final String DEFAULT_REQUEST_CONTROL = "javax.naming.ldap.PagedResultsControl";
private static final String LDAPBP_REQUEST_CONTROL = "com.sun.jndi.ldap.ctl.PagedResultsControl";
private static final String DEFAULT_RESPONSE_CONTROL = "javax.naming.ldap.PagedResultsResponseControl";
private static final String LDAPBP_RESPONSE_CONTROL = "com.sun.jndi.ldap.ctl.PagedResultsResponseControl";
private int pageSize;
private PagedResultsCookie cookie;
private int resultSize;
private boolean critical = CRITICAL_CONTROL;
private Class responseControlClass;
private Class requestControlClass;
/**
* Constructs a new instance. This constructor should be used when
* performing the first paged search operation, when no other results have
* been retrieved.
*
* @param pageSize the page size.
*/
public PagedResultsRequestControl(int pageSize) {
this(pageSize, null);
}
/**
* Constructs a new instance with the supplied page size and cookie. The
* cookie must be the exact same instance as received from a previous paged
* resullts search, or null if it is the first in an operation
* sequence.
*
* @param pageSize the page size.
* @param cookie the cookie, as received from a previous search.
*/
public PagedResultsRequestControl(int pageSize, PagedResultsCookie cookie) {
this.pageSize = pageSize;
this.cookie = cookie;
loadControlClasses();
}
private void loadControlClasses() {
try {
requestControlClass = Class.forName(DEFAULT_REQUEST_CONTROL);
responseControlClass = Class.forName(DEFAULT_RESPONSE_CONTROL);
}
catch (ClassNotFoundException e) {
log.debug("Default control classes not found - falling back to LdapBP classes", e);
try {
requestControlClass = Class.forName(LDAPBP_REQUEST_CONTROL);
responseControlClass = Class.forName(LDAPBP_RESPONSE_CONTROL);
}
catch (ClassNotFoundException e1) {
throw new UncategorizedLdapException(
"Neither default nor fallback classes are available - unable to proceed", e);
}
}
}
/**
* Get the cookie.
*
* @return the cookie.
*/
public PagedResultsCookie getCookie() {
return cookie;
}
/**
* Get the page size.
*
* @return the page size.
*/
public int getPageSize() {
return pageSize;
}
/**
* Get the total estimated number of entries that matches the issued search.
* Note that this value is optional for the LDAP server to return, so it
* does not always contain any valid data.
*
* @return the estimated result size, if returned from the server.
*/
public int getResultSize() {
return resultSize;
}
/**
* Set the class of the expected ResponseControl for the paged results
* response.
*
* @param responseControlClass Class of the expected response control.
*/
public void setResponseControlClass(Class responseControlClass) {
this.responseControlClass = responseControlClass;
}
public void setRequestControlClass(Class requestControlClass) {
this.requestControlClass = requestControlClass;
}
/*
* @see
* org.springframework.ldap.control.AbstractRequestControlDirContextProcessor
* #createRequestControl()
*/
public Control createRequestControl() {
byte[] actualCookie = null;
if (cookie != null) {
actualCookie = cookie.getCookie();
}
Constructor constructor = ClassUtils.getConstructorIfAvailable(requestControlClass, new Class[] { int.class,
byte[].class, boolean.class });
if (constructor == null) {
throw new IllegalArgumentException("Failed to find an appropriate RequestControl constructor");
}
Control result = null;
try {
result = (Control) constructor.newInstance(new Object[] { new Integer(pageSize), actualCookie,
Boolean.valueOf(critical) });
}
catch (Exception e) {
ReflectionUtils.handleReflectionException(e);
}
return result;
}
/*
* @see
* org.springframework.ldap.core.DirContextProcessor#postProcess(javax.naming
* .directory.DirContext)
*/
public void postProcess(DirContext ctx) throws NamingException {
LdapContext ldapContext = (LdapContext) ctx;
Control[] responseControls = ldapContext.getResponseControls();
if (responseControls == null) {
responseControls = new Control[0];
}
// Go through response controls and get info, regardless of class
for (int i = 0; i < responseControls.length; i++) {
Control responseControl = responseControls[i];
// check for match, try fallback otherwise
if (responseControl.getClass().isAssignableFrom(responseControlClass)) {
Object control = responseControl;
byte[] result = (byte[]) invokeMethod("getCookie", responseControlClass, control);
this.cookie = new PagedResultsCookie(result);
Integer wrapper = (Integer) invokeMethod("getResultSize", responseControlClass, control);
this.resultSize = wrapper.intValue();
return;
}
}
log.fatal("No matching response control found for paged results - looking for '" + responseControlClass);
}
private Object invokeMethod(String method, Class clazz, Object control) {
Method actualMethod = ReflectionUtils.findMethod(clazz, method);
return ReflectionUtils.invokeMethod(actualMethod, control);
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/PagedResultsCookie.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004200 11475313376 030205 0 ustar /*
* Copyright 2005-2010 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.control;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import com.sun.jndi.ldap.ctl.PagedResultsControl;
/**
* Wrapper class for the cookie returned when using the
* {@link PagedResultsControl}.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public class PagedResultsCookie {
private byte[] cookie;
/**
* Constructor.
*
* @param cookie
* the cookie returned by a PagedResultsResponseControl.
*/
public PagedResultsCookie(byte[] cookie) {
this.cookie = ArrayUtils.clone(cookie);
}
/**
* Get the cookie.
*
* @return the cookie.
*/
public byte[] getCookie() {
return ArrayUtils.clone(cookie);
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj != null && this.getClass().equals(obj.getClass())) {
PagedResultsCookie that = (PagedResultsCookie) obj;
return new EqualsBuilder().append(this.cookie, that.cookie)
.isEquals();
}
return false;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return new HashCodeBuilder().append(this.cookie).toHashCode();
}
}
././@LongLink 0000000 0000000 0000000 00000000217 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/CreateControlFailedException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002730 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.control;
import org.springframework.ldap.NamingException;
/**
* Thrown by an AbstractRequestControlDirContextProcessor when it cannot create
* a request control.
*
* @author Ulrik Sandberg
* @since 1.2
*/
public class CreateControlFailedException extends NamingException {
/**
* Create a new CreateControlFailedException.
*
* @param msg
* the detail message
*/
public CreateControlFailedException(String msg) {
super(msg);
}
/**
* Create a new CreateControlFailedException.
*
* @param msg
* the detail message
* @param cause
* the root cause (if any)
*/
public CreateControlFailedException(String msg, Throwable cause) {
super(msg, cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000222 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/PagedResultsDirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000011060 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.control;
import javax.naming.ldap.Control;
/**
* DirContextProcessor implementation for managing the paged results control.
* Note that due to the internal workings of LdapTemplate, the
* target connection is closed after each LDAP call. The PagedResults control
* require the same connection be used for each call, which means we need to
* make sure the target connection is never actually closed. There's basically
* two ways of making this happen: use the SingleContextSource
* implementation or make sure all calls happen within a single LDAP transaction
* (using ContextSourceTransactionManager).
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public class PagedResultsDirContextProcessor extends AbstractFallbackRequestAndResponseControlDirContextProcessor {
private static final String DEFAULT_REQUEST_CONTROL = "javax.naming.ldap.PagedResultsControl";
private static final String FALLBACK_REQUEST_CONTROL = "com.sun.jndi.ldap.ctl.PagedResultsControl";
private static final String DEFAULT_RESPONSE_CONTROL = "javax.naming.ldap.PagedResultsResponseControl";
private static final String FALLBACK_RESPONSE_CONTROL = "com.sun.jndi.ldap.ctl.PagedResultsResponseControl";
private int pageSize;
private PagedResultsCookie cookie;
private int resultSize;
/**
* Constructs a new instance. This constructor should be used when
* performing the first paged search operation, when no other results have
* been retrieved.
*
* @param pageSize the page size.
*/
public PagedResultsDirContextProcessor(int pageSize) {
this(pageSize, null);
}
/**
* Constructs a new instance with the supplied page size and cookie. The
* cookie must be the exact same instance as received from a previous paged
* results search, or null if it is the first in an operation
* sequence.
*
* @param pageSize the page size.
* @param cookie the cookie, as received from a previous search.
*/
public PagedResultsDirContextProcessor(int pageSize, PagedResultsCookie cookie) {
this.pageSize = pageSize;
this.cookie = cookie;
defaultRequestControl = DEFAULT_REQUEST_CONTROL;
defaultResponseControl = DEFAULT_RESPONSE_CONTROL;
fallbackRequestControl = FALLBACK_REQUEST_CONTROL;
fallbackResponseControl = FALLBACK_RESPONSE_CONTROL;
loadControlClasses();
}
/**
* Get the cookie.
*
* @return the cookie.
*/
public PagedResultsCookie getCookie() {
return cookie;
}
/**
* Get the page size.
*
* @return the page size.
*/
public int getPageSize() {
return pageSize;
}
/**
* Get the total estimated number of entries that matches the issued search.
* Note that this value is optional for the LDAP server to return, so it
* does not always contain any valid data.
*
* @return the estimated result size, if returned from the server.
*/
public int getResultSize() {
return resultSize;
}
/*
* @see
* org.springframework.ldap.control.AbstractRequestControlDirContextProcessor
* #createRequestControl()
*/
public Control createRequestControl() {
byte[] actualCookie = null;
if (cookie != null) {
actualCookie = cookie.getCookie();
}
return super.createRequestControl(new Class[] { int.class, byte[].class, boolean.class },
new Object[] {new Integer(pageSize), actualCookie, Boolean.valueOf(critical)});
}
/*
* @seeorg.springframework.ldap.control.
* AbstractFallbackRequestAndResponseControlDirContextProcessor
* #handleResponse(java.lang.Object)
*/
protected void handleResponse(Object control) {
byte[] result = (byte[]) invokeMethod("getCookie", responseControlClass, control);
this.cookie = new PagedResultsCookie(result);
Integer wrapper = (Integer) invokeMethod("getResultSize", responseControlClass, control);
this.resultSize = wrapper.intValue();
}
}
././@LongLink 0000000 0000000 0000000 00000000234 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/control/AbstractRequestControlDirContextProcessor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000011453 11475313376 030215 0 ustar /*
* Copyright 2005-2010 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.control;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.ldap.Control;
import javax.naming.ldap.LdapContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ldap.core.DirContextProcessor;
/**
* Abstract superclass with responsibility to apply a single RequestControl on
* an LdapContext, preserving any existing controls. Subclasses should implement
* {@link DirContextProcessor#postProcess(DirContext)} and template method
* {@link #createRequestControl()}.
*
* @author Mattias Hellborg Arthursson
* @author Ulrik Sandberg
*/
public abstract class AbstractRequestControlDirContextProcessor implements DirContextProcessor {
protected Log log = LogFactory.getLog(AbstractRequestControlDirContextProcessor.class);
private boolean replaceSameControlEnabled = true;
/**
* If there already exists a request control of the same class as the one
* created by {@link #createRequestControl()} in the context, the new
* control can either replace the existing one (default behavior) or be
* added.
*
* @return true if an already existing control will be replaced
*/
public boolean isReplaceSameControlEnabled() {
return replaceSameControlEnabled;
}
/**
* If there already exists a request control of the same class as the one
* created by {@link #createRequestControl()} in the context, the new
* control can either replace the existing one (default behavior) or be
* added.
*
* @param replaceSameControlEnabled true if an already
* existing control should be replaced
*/
public void setReplaceSameControlEnabled(boolean replaceSameControlEnabled) {
this.replaceSameControlEnabled = replaceSameControlEnabled;
}
/**
* Get the existing RequestControls from the LdapContext, call
* {@link #createRequestControl()} to get a new instance, build a new array
* of Controls and set it on the LdapContext.
* preProcess and
* postProcess uses DirContext, since it also works for LDAP
* v2. This is the reason that DirContext has to be cast to a LdapContext.
*
* @param ctx an LdapContext instance.
* @throws NamingException
* @throws IllegalArgumentException if the supplied DirContext is not an
* LdapContext.
*/
public void preProcess(DirContext ctx) throws NamingException {
LdapContext ldapContext;
if (ctx instanceof LdapContext) {
ldapContext = (LdapContext) ctx;
}
else {
throw new IllegalArgumentException("Request Control operations require LDAPv3 - "
+ "Context must be of type LdapContext");
}
Control[] requestControls = ldapContext.getRequestControls();
if (requestControls == null) {
requestControls = new Control[0];
}
Control newControl = createRequestControl();
Control[] newControls = new Control[requestControls.length + 1];
for (int i = 0; i < requestControls.length; i++) {
if (replaceSameControlEnabled && requestControls[i].getClass() == newControl.getClass()) {
log.debug("Replacing already existing control in context: " + newControl);
requestControls[i] = newControl;
ldapContext.setRequestControls(requestControls);
return;
}
newControls[i] = requestControls[i];
}
// Add the new Control at the end of the array.
newControls[newControls.length - 1] = newControl;
ldapContext.setRequestControls(newControls);
}
/**
* Create an instance of the appropriate RequestControl.
*
* @return the new instance.
*/
public abstract Control createRequestControl();
}
././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/LinkException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001717 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI LinkException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.LinkException
*/
public class LinkException extends NamingException {
public LinkException(javax.naming.LinkException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000216 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/AuthenticationNotSupportedException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002134 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI AuthenticationNotSupportedException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.AuthenticationNotSupportedException
*/
public class AuthenticationNotSupportedException extends
NamingSecurityException {
public AuthenticationNotSupportedException(
javax.naming.AuthenticationNotSupportedException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InsufficientResourcesException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002062 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InsufficientResourcesException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.InsufficientResourcesException
*/
public class InsufficientResourcesException extends NamingException {
public InsufficientResourcesException(
javax.naming.InsufficientResourcesException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidAttributeValueException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002106 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidAttributeValueException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.InvalidAttributeValueException
*/
public class InvalidAttributeValueException extends NamingException {
public InvalidAttributeValueException(
javax.naming.directory.InvalidAttributeValueException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/BadLdapGrammarException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002256 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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;
/**
* Thrown to indicate that an invalid value has been supplied to an LDAP
* operation. This could be an invalid filter or dn.
*
* @author Mattias Hellborg Arthursson
*/
public class BadLdapGrammarException extends NamingException {
private static final long serialVersionUID = 961612585331409470L;
public BadLdapGrammarException(String message) {
super(message);
}
public BadLdapGrammarException(String message, Throwable cause) {
super(message, cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/ServiceUnavailableException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002043 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI ServiceUnavailableException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.ServiceUnavailableException
*/
public class ServiceUnavailableException extends NamingException {
public ServiceUnavailableException(
javax.naming.ServiceUnavailableException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidSearchControlsException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002106 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidSearchControlsException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.InvalidSearchControlsException
*/
public class InvalidSearchControlsException extends NamingException {
public InvalidSearchControlsException(
javax.naming.directory.InvalidSearchControlsException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NoPermissionException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001777 11475313376 030225 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NoPermissionException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NoPermissionException
*/
public class NoPermissionException extends NamingSecurityException {
public NoPermissionException(javax.naming.NoPermissionException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidNameException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001762 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidNameException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.InvalidNameException
*/
public class InvalidNameException extends NamingException {
public InvalidNameException(javax.naming.InvalidNameException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NamingSecurityException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002012 11475313376 030204 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NamingSecurityException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NamingSecurityException
*/
public abstract class NamingSecurityException extends NamingException {
public NamingSecurityException(javax.naming.NamingSecurityException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NamingException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000015705 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import javax.naming.Name;
import org.springframework.core.NestedRuntimeException;
/**
* Base class for exception thrown by the framework whenever it encounters a
* problem related to LDAP.
*
* @author Ulrik Sandberg
* @since 1.2
*/
public abstract class NamingException extends NestedRuntimeException {
private Throwable cause;
/**
* Overrides {@link NestedRuntimeException#getCause()} since serialization
* always tries to serialize the base class before the subclass. Our
* cause may have a resolvedObj that is not
* serializable. By storing the cause in this class, we get a chance at
* temporarily nulling the cause before serialization, thus in effect making
* the current instance serializable.
*/
public Throwable getCause() {
// Even if you cannot set the cause of this exception other than through
// the constructor, we check for the cause being "this" here, as the cause
// could still be set to "this" via reflection: for example, by a remoting
// deserializer like Hessian's.
return (this.cause == this ? null : this.cause);
}
/**
* Constructor that takes a message.
*
* @param msg
* the detail message
*/
public NamingException(String msg) {
super(msg);
}
/**
* Constructor that allows a message and a root cause.
*
* @param msg
* the detail message
* @param cause
* the cause of the exception. This argument is generally
* expected to be a proper subclass of
* {@link javax.naming.NamingException}.
*/
public NamingException(String msg, Throwable cause) {
super(msg);
this.cause = cause;
}
/**
* Constructor that allows a plain root cause, intended for subclasses
* mirroring corresponding javax.naming exceptions.
*
* @param cause
* the cause of the exception. This argument is generally
* expected to be a proper subclass of
* {@link javax.naming.NamingException}.
*/
public NamingException(Throwable cause) {
this(cause != null ? cause.getMessage() : null, cause);
}
/**
* Convenience method to get the explanation associated with this exception,
* if the root cause was an instance of {@link javax.naming.NamingException}.
*
* @return a detail string explaining more about this exception if the root
* cause is an instance of javax.naming.NamingException, or
* null if there is no detail message for this
* exception
*/
public String getExplanation() {
if (getCause() instanceof javax.naming.NamingException) {
return ((javax.naming.NamingException) getCause()).getExplanation();
}
return null;
}
/**
* Convenience method to get the unresolved part of the name associated with
* this exception, if the root cause was an instance of
* {@link javax.naming.NamingException}.
*
* @return a composite name describing the part of the name that has not
* been resolved if the root cause is an instance of
* javax.naming.NamingException, or null if the
* remaining name field has not been set
*/
public Name getRemainingName() {
if (getCause() instanceof javax.naming.NamingException) {
return ((javax.naming.NamingException) getCause())
.getRemainingName();
}
return null;
}
/**
* Convenience method to get the leading portion of the resolved name
* associated with this exception, if the root cause was an instance of
* {@link javax.naming.NamingException}.
*
* @return a composite name describing the the leading portion of the name
* that was resolved successfully if the root cause is an instance
* of javax.naming.NamingException, or null if the
* resolved name field has not been set
*/
public Name getResolvedName() {
if (getCause() instanceof javax.naming.NamingException) {
return ((javax.naming.NamingException) getCause())
.getResolvedName();
}
return null;
}
/**
* Convenience method to get the resolved object associated with this
* exception, if the root cause was an instance of
* {@link javax.naming.NamingException}.
*
* @return the object that was resolved so far if the root cause is an
* instance of javax.naming.NamingException, or null
* if the resolved object field has not been set
*/
public Object getResolvedObj() {
if (getCause() instanceof javax.naming.NamingException) {
return ((javax.naming.NamingException) getCause()).getResolvedObj();
}
return null;
}
/**
* Checks if the resolvedObj of the causing exception is
* suspected to be non-serializable, and if so temporarily nulls it before
* calling the default serialization mechanism.
*
* @param stream
* the stream onto which this object is serialized
* @throws IOException
* if there is an error writing this object to the stream
*/
private void writeObject(ObjectOutputStream stream) throws IOException {
Object resolvedObj = getResolvedObj();
boolean serializable = resolvedObj instanceof Serializable;
if (resolvedObj != null && !serializable) {
// the cause is of this type, since resolvedObj is not null
javax.naming.NamingException namingException = (javax.naming.NamingException) getCause();
namingException.setResolvedObj(null);
try {
stream.defaultWriteObject();
} finally {
namingException.setResolvedObj(resolvedObj);
}
} else {
stream.defaultWriteObject();
}
}
}
././@LongLink 0000000 0000000 0000000 00000000204 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NameAlreadyBoundException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002031 11475313376 030205 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NameAlreadyBoundException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NameAlreadyBoundException
*/
public class NameAlreadyBoundException extends NamingException {
public NameAlreadyBoundException(
javax.naming.NameAlreadyBoundException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/AttributeModificationException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002106 11475313376 030210 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI AttributeModificationException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.AttributeModificationException
*/
public class AttributeModificationException extends NamingException {
public AttributeModificationException(
javax.naming.directory.AttributeModificationException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000174 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/LinkLoopException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001741 11475313376 030214 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI LinkLoopException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.LinkLoopException
*/
public class LinkLoopException extends LinkException {
public LinkLoopException(javax.naming.LinkLoopException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000204 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NoInitialContextException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002031 11475313376 030205 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NoInitialContextException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NoInitialContextException
*/
public class NoInitialContextException extends NamingException {
public NoInitialContextException(
javax.naming.NoInitialContextException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/ConfigurationException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001774 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI ConfigurationException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.ConfigurationException
*/
public class ConfigurationException extends NamingException {
public ConfigurationException(javax.naming.ConfigurationException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000203 00000000000 011560 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/ContextNotEmptyException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002006 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI ContextNotEmptyException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.ContextNotEmptyException
*/
public class ContextNotEmptyException extends NamingException {
public ContextNotEmptyException(javax.naming.ContextNotEmptyException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000165 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/authentication/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/authentication/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000000122 11475313376 030204 0 ustar
AcegiAuthenticationSource if users are to be
* allowed to read some information even though they are not logged in.
* defaultUser should be an non-privileged
* user. This is important as this is the one that will be used when no user is
* logged in (i.e. empty principal is returned from the target
* AuthenticationSource).
*
* @author Mattias Hellborg Arthursson
*
*/
public class DefaultValuesAuthenticationSourceDecorator implements
AuthenticationSource, InitializingBean {
private AuthenticationSource target;
private String defaultUser;
private String defaultPassword;
/**
* Constructor for bean usage.
*/
public DefaultValuesAuthenticationSourceDecorator() {
}
/**
* Constructor to setup instance directly.
*
* @param target
* the target AuthenticationSource.
* @param defaultUser
* dn of the user to use when the target returns an empty
* principal.
* @param defaultPassword
* password of the user to use when the target returns an empty
* principal.
*/
public DefaultValuesAuthenticationSourceDecorator(
AuthenticationSource target, String defaultUser,
String defaultPassword) {
this.target = target;
this.defaultUser = defaultUser;
this.defaultPassword = defaultPassword;
}
/**
* Checks if the target's principal is not empty; if not, the credentials
* from the target is returned - otherwise return the
* defaultPassword.
*
* @return the target's password if the target's principal is not empty, the
* defaultPassword otherwise.
*/
public String getCredentials() {
if (StringUtils.isNotEmpty(target.getPrincipal())) {
return target.getCredentials();
} else {
return defaultPassword;
}
}
/**
* Checks if the target's principal is not empty; if not, this is returned -
* otherwise return the defaultPassword.
*
* @return the target's principal if it is not empty, the
* defaultPassword otherwise.
*/
public String getPrincipal() {
String principal = target.getPrincipal();
if (StringUtils.isNotEmpty(principal)) {
return principal;
} else {
return defaultUser;
}
}
/**
* Set the password of the default user.
*
* @param defaultPassword
* the password of the default user.
*/
public void setDefaultPassword(String defaultPassword) {
this.defaultPassword = defaultPassword;
}
/**
* Set the default user DN. This should be a non-privileged user, since it
* will be used when no authentication information is returned from the
* target.
*
* @param defaultUser
* DN of the default user.
*/
public void setDefaultUser(String defaultUser) {
this.defaultUser = defaultUser;
}
/**
* Set the target AuthenticationSource.
*
* @param target
* the target AuthenticationSource.
*/
public void setTarget(AuthenticationSource target) {
this.target = target;
}
/*
* (non-Javadoc)
*
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {
if (target == null) {
throw new IllegalArgumentException(
"Property 'target' must be set.'");
}
if (defaultUser == null) {
throw new IllegalArgumentException(
"Property 'defaultUser' must be set.'");
}
if (defaultPassword == null) {
throw new IllegalArgumentException(
"Property 'defaultPassword' must be set.'");
}
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InvalidAttributesException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002062 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InvalidAttributesException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.directory.InvalidAttributesException
*/
public class InvalidAttributesException extends NamingException {
public InvalidAttributesException(
javax.naming.directory.InvalidAttributesException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/InterruptedNamingException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002036 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI InterruptedNamingException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.InterruptedNamingException
*/
public class InterruptedNamingException extends NamingException {
public InterruptedNamingException(
javax.naming.InterruptedNamingException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/NameNotFoundException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002111 11475313376 030204 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI NameNotFoundException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.NameNotFoundException
*/
public class NameNotFoundException extends NamingException {
public NameNotFoundException(String msg) {
super(msg);
}
public NameNotFoundException(javax.naming.NameNotFoundException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000211 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/OperationNotSupportedException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002062 11475313376 030211 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI OperationNotSupportedException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.OperationNotSupportedException
*/
public class OperationNotSupportedException extends NamingException {
public OperationNotSupportedException(
javax.naming.OperationNotSupportedException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0002755 0000000 0000000 00000000000 11475313376 030211 5 ustar ././@LongLink 0000000 0000000 0000000 00000000173 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/AndFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003306 11475313376 030213 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* A filter for a logical AND. Example:
*
*
* AndFilter filter = new AndFilter();
* filter.and(new EqualsFilter("objectclass", "person");
* filter.and(new EqualsFilter("cn", "Some CN");
* System.out.println(filter.encode());
*
*
* would result in: (&(objectclass=person)(cn=Some CN))
*
* @see org.springframework.ldap.filter.EqualsFilter
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class AndFilter extends BinaryLogicalFilter {
private static final String AMPERSAND = "&";
/*
* @see org.springframework.ldap.filter.BinaryLogicalFilter#getLogicalOperator()
*/
protected String getLogicalOperator() {
return AMPERSAND;
}
/**
* Add a query to the AND expression.
*
* @param query The expression to AND with the rest of the AND:ed
* expressions.
* @return This LdapAndQuery
*/
public AndFilter and(Filter query) {
append(query);
return this;
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/AbstractFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000002531 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* Convenience class that implements most of the methods in the Filter
* interface.
*
* @author Adam Skogman
*/
public abstract class AbstractFilter implements Filter {
protected AbstractFilter() {
super();
}
/*
* @see org.springframework.ldap.filter.Filter#encode(java.lang.StringBuffer)
*/
public abstract StringBuffer encode(StringBuffer buff);
/*
* @see org.springframework.ldap.filter.Filter#encode()
*/
public String encode() {
StringBuffer buf = new StringBuffer(256);
buf = encode(buf);
return buf.toString();
}
/*
* @see java.lang.Object#toString()
*/
public String toString() {
return encode();
}
}
././@LongLink 0000000 0000000 0000000 00000000173 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/NotFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004211 11475313376 030207 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.apache.commons.lang.Validate;
import org.apache.commons.lang.builder.EqualsBuilder;
/**
* A filter for 'not'. The following code:
*
*
* Filter filter = new NotFilter(new EqualsFilter("cn", "foo");
* System.out.println(filter.encode());
*
*
* would result in:
*
*
* (!(cn = foo))
*
*
* @author Adam Skogman
*/
public class NotFilter extends AbstractFilter {
private final Filter filter;
static private final int HASH = "!".hashCode();
/**
* Create a filter that negates the outcome of the given filter.
*
* @param filter The filter that should be negated.
*/
public NotFilter(Filter filter) {
Validate.notNull(filter);
this.filter = filter;
}
/*
* @see org.springframework.ldap.filter.AbstractFilter#encode(java.lang.StringBuffer)
*/
public StringBuffer encode(StringBuffer buff) {
buff.append("(!");
filter.encode(buff);
buff.append(')');
return buff;
}
/*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (o.getClass() != getClass()) {
return false;
}
NotFilter f = (NotFilter) o;
return new EqualsBuilder().append(this.filter, f.filter).isEquals();
}
/*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return HASH ^ filter.hashCode();
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/NotPresentFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004526 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.springframework.ldap.filter.AbstractFilter;
/**
* A convenience class that combines {@code NOT} behavior with {@code present}
* behavior to allow the user to check for the non-existence of a attribute. For
* an attribute to be {@code NOT present} it must not have any values set. To
* filter on attributes at are {@code present} use the {@link PresentFilter}.
*
*
* NotPresentFilter filter = new NotPresentFilter("foo");
* System.out.println(filter.encode());
*
*
* would result in:
*
*
* (!(foo=*))
*
* @author Jordan Hein
*/
public class NotPresentFilter extends AbstractFilter {
private String attribute;
/**
* Creates a new instance of a not present filter for a particular
* attribute.
*
* @param attribute the attribute expected to be not-present (ie, unset, or
* null).
*/
public NotPresentFilter(String attribute) {
this.attribute = attribute;
}
public StringBuffer encode(StringBuffer buff) {
buff.append("(!(");
buff.append(attribute);
buff.append("=*))");
return buff;
}
/*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (o.getClass() != getClass()) {
return false;
}
NotPresentFilter f = (NotPresentFilter) o;
return new EqualsBuilder().append(this.attribute, f.attribute).isEquals();
}
/*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
HashCodeBuilder builder = new HashCodeBuilder().append(attribute);
return builder.toHashCode();
}
} ././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/OrFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003110 11475313376 030204 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* Filter for logical OR.
*
*
* OrFilter filter = new OrFilter();
* filter.or(new EqualsFilter("objectclass", "person");
* filter.or(new EqualsFilter("objectclass", "organizationalUnit");
* System.out.println(filter.encode());
*
*
* would result in:
* (|(objectclass=person)(objectclass=organizationalUnit))
*
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class OrFilter extends BinaryLogicalFilter {
private static final String PIPE_SIGN = "|";
/**
* Add a query to the OR expression
*
* @param query The query to or with the rest of the or:ed queries.
* @return This LdapOrQuery
*/
public OrFilter or(Filter query) {
append(query);
return this;
}
/*
* @see org.springframework.ldap.filter.BinaryLogicalFilter#getLogicalOperator()
*/
protected String getLogicalOperator() {
return PIPE_SIGN;
}
}
././@LongLink 0000000 0000000 0000000 00000000213 00000000000 011561 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/GreaterThanOrEqualsFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003044 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* A filter to compare >=. LDAP RFC does not allow > comparison. The following
* code:
*
*
* GreaterThanOrEqualsFilter filter = new GreaterThanOrEqualsFilter("cn", "Some CN");
* System.out.println(filter.ecode());
*
*
* would result in:
*
*
* (cn>=Some CN)
*
*
* @author Mattias Hellborg Arthursson
*/
public class GreaterThanOrEqualsFilter extends CompareFilter {
private static final String GREATER_THAN_OR_EQUALS = ">=";
public GreaterThanOrEqualsFilter(String attribute, String value) {
super(attribute, value);
}
public GreaterThanOrEqualsFilter(String attribute, int value) {
super(attribute, value);
}
/*
* @see org.springframework.ldap.filter.CompareFilter#getCompareString()
*/
protected String getCompareString() {
return GREATER_THAN_OR_EQUALS;
}
}
././@LongLink 0000000 0000000 0000000 00000000171 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001177 11475313376 030217 0 ustar
Utility classes for dynamically building LDAP
filters. Filters can be nested and wrapped around each other:
AndFilter andFilter = new AndFilter();
andFilter.and(new EqualsFilter("objectclass", "person");
andFilter.and(new EqualsFilter("cn", "Some CN");
OrFilter orFilter = new OrFilter();
orFilter.or(andFilter);
orFilter.or(new EqualsFilter("objectclass", "organizationalUnit));
System.out.println(orFilter.encode());
would result in:
(|(&(objectclass=person)(cn=Some CN))(objectclass=organizationalUnit))
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/PresentFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000004457 11475313376 030223 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
/**
* Filter that allows the user to check for the existence of a attribute. For an
* attribute to be {@code 'present'} it must contain a value. Attributes that do
* not contain a value are {@code 'NOT present'}. To filter on attributes that
* are {@code 'NOT present'} use the {@link NotPresentFilter} or use this filter
* in combination with a {@link NotFilter} .
*
*
* PresentFilter filter = new PresentFilter("foo");
* System.out.println(filter.encode());
*
*
* would result in:
*
*
* (foo=*)
*
* @author Jordan Hein
*/
public class PresentFilter extends AbstractFilter {
private String attribute;
/**
* Creates a new instance of a present filter for a particular attribute.
*
* @param attribute the attribute expected to be present (ie, contains a
* value).
*/
public PresentFilter(String attribute) {
this.attribute = attribute;
}
public StringBuffer encode(StringBuffer buff) {
buff.append("(");
buff.append(attribute);
buff.append("=*)");
return buff;
}
/*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (o.getClass() != getClass()) {
return false;
}
PresentFilter f = (PresentFilter) o;
return new EqualsBuilder().append(this.attribute, f.attribute).isEquals();
}
/*
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
HashCodeBuilder builder = new HashCodeBuilder().append(attribute);
return builder.toHashCode();
}
} ././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/HardcodedFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000005633 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.springframework.util.StringUtils;
/**
* Allows hard coded parts to be included in a search filter. Particularly useful
* if some filters are specified in configuration files and these should be
* combined with other ones.
*
*
* Filter filter = new HardcodedFilter("(&(objectClass=user)(!(objectClass=computer)))");
* System.out.println(filter.toString());
*
*
* would result in:
* (&(objectClass=user)(!(objectClass=computer)))
*
* <bean class="MyClass">
* <property name="filter" value="(&(objectClass=user)(!(objectClass=computer)))" />
* </bean>
*
*
* WhitespaceWildcardsFilter filter = new WhitespaceWildcardsFilter("cn", "Some CN");
* System.out.println(filter.ecode());
*
*
* would result in: (cn=*Some*CN*)
*
* @author Adam Skogman
* @author Mattias Hellborg Arthursson
*/
public class WhitespaceWildcardsFilter extends EqualsFilter {
private static Pattern starReplacePattern = Pattern.compile("\\s+");
public WhitespaceWildcardsFilter(String attribute, String value) {
super(attribute, value);
}
/*
* @see org.springframework.ldap.filter.CompareFilter#encodeValue(java.lang.String)
*/
protected String encodeValue(String value) {
// blank string means just ONE star
if (StringUtils.isBlank(value)) {
return "*";
}
// trim value, we will add in stars first and last anywhay
value = value.trim();
// filter encode so that any stars etc. are preserved
String filterEncoded = LdapEncoder.filterEncode(value);
// Now replace all whitespace with stars
Matcher m = starReplacePattern.matcher(filterEncoded);
// possibly 2 longer (stars at ends)
StringBuffer buff = new StringBuffer(value.length() + 2);
buff.append('*');
while (m.find()) {
m.appendReplacement(buff, "*");
}
m.appendTail(buff);
buff.append('*');
return buff.toString();
}
}
././@LongLink 0000000 0000000 0000000 00000000210 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/LessThanOrEqualsFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003017 11475313376 030212 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* A filter to compare <=. LDAP RFC does not allow < comparison. The following
* code:
*
*
* LessThanOrEqualsFilter filter = new LessThanOrEqualsFilter("cn", "Some CN");
* System.out.println(filter.ecode());
*
*
* would result in:
*
*
* (cn<=Some CN)
*
*
* @author Mattias Hellborg Arthursson
*/
public class LessThanOrEqualsFilter extends CompareFilter {
private static final String LESS_THAN_OR_EQUALS = "<=";
public LessThanOrEqualsFilter(String attribute, String value) {
super(attribute, value);
}
public LessThanOrEqualsFilter(String attribute, int value) {
super(attribute, value);
}
/*
* @see org.springframework.ldap.filter.CompareFilter#getCompareString()
*/
protected String getCompareString() {
return LESS_THAN_OR_EQUALS;
}
}
././@LongLink 0000000 0000000 0000000 00000000177 00000000000 011572 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/CompareFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000006672 11475313376 030224 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.springframework.ldap.core.LdapEncoder;
/**
* Abstract superclass for filters that compare values.
*
* @author Mattias Hellborg Arthursson
*/
public abstract class CompareFilter extends AbstractFilter {
private final String attribute;
private final String value;
private final String encodedValue;
public CompareFilter(String attribute, String value) {
this.attribute = attribute;
this.value = value;
this.encodedValue = encodeValue(value);
}
/**
* For testing purposes.
*
* @return the encoded value.
*/
String getEncodedValue() {
return encodedValue;
}
/**
* Override to perform special encoding in subclass.
*
* @param value the value to encode.
* @return properly escaped value.
*/
protected String encodeValue(String value) {
return LdapEncoder.filterEncode(value);
}
/**
* Convenience constructor for int values.
*
* @param attribute Name of attribute in filter.
* @param value The value of the attribute in the filter.
*/
public CompareFilter(String attribute, int value) {
this.attribute = attribute;
this.value = String.valueOf(value);
this.encodedValue = LdapEncoder.filterEncode(this.value);
}
/*
* @see org.springframework.ldap.filter.AbstractFilter#encode(java.lang.StringBuffer)
*/
public StringBuffer encode(StringBuffer buff) {
buff.append('(');
buff.append(attribute).append(getCompareString()).append(encodedValue);
buff.append(')');
return buff;
}
/**
* Compares key and value before encoding.
*
* @see org.springframework.ldap.filter.Filter#equals(java.lang.Object)
*/
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (o.getClass() != getClass()) {
return false;
}
CompareFilter f = (CompareFilter) o;
EqualsBuilder builder = new EqualsBuilder();
return builder.append(this.attribute, f.attribute).append(this.value, f.value).isEquals();
}
/**
* Calculate the hash code for the attribute and the value.
*
* @see org.springframework.ldap.filter.Filter#hashCode()
*/
public int hashCode() {
HashCodeBuilder builder = new HashCodeBuilder();
builder.append(attribute);
builder.append(value);
return builder.toHashCode();
}
/**
* Implement this method in subclass to return a String representing the
* operator. The {@link EqualsFilter#getCompareString()} would for example
* return an equals sign, "=".
*
* @return the String to use as operator in the comparison for the specific
* subclass.
*/
protected abstract String getCompareString();
}
././@LongLink 0000000 0000000 0000000 00000000176 00000000000 011571 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/EqualsFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003075 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* A filter for 'equals'. The following code:
*
*
* EqualsFilter filter = new EqualsFilter("cn", "Some CN");
* System.out.println(filter.encode());
*
*
* would result in:
*
*
* (cn=Some CN)
*
*
* @author Adam Skogman
*/
public class EqualsFilter extends CompareFilter {
private static final String EQUALS_SIGN = "=";
public EqualsFilter(String attribute, String value) {
super(attribute, value);
}
/**
* Convenience constructor for int values.
*
* @param attribute Name of attribute in filter.
* @param value The value of the attribute in the filter.
*/
public EqualsFilter(String attribute, int value) {
super(attribute, value);
}
/*
* @see org.springframework.ldap.filter.CompareFilter#getCompareString()
*/
protected String getCompareString() {
return EQUALS_SIGN;
}
}
././@LongLink 0000000 0000000 0000000 00000000174 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/LikeFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003672 11475313376 030221 0 ustar /*
* Copyright 2005-2010 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.filter;
import org.springframework.ldap.core.LdapEncoder;
/**
* This filter allows the user to specify wildcards (*) by not escaping them in
* the filter. The following code:
*
*
* LikeFilter filter = new LikeFilter("cn", "foo*");
* System.out.println(filter.ecode());
*
*
* would result in:
*
*
* (cn=foo*)
*
*
* @author Anders Henja
* @author Mattias Hellborg Arthursson
*/
public class LikeFilter extends EqualsFilter {
public LikeFilter(String attribute, String value) {
super(attribute, value);
}
/*
* @see org.springframework.ldap.filter.CompareFilter#encodeValue(java.lang.String)
*/
protected String encodeValue(String value) {
// just return if blank string
if (value == null) {
return "";
}
String[] substrings = value.split("\\*", -2);
if (substrings.length == 1) {
return LdapEncoder.filterEncode(substrings[0]);
}
StringBuffer buff = new StringBuffer();
for (int i = 0; i < substrings.length; i++) {
buff.append(LdapEncoder.filterEncode(substrings[i]));
if (i < substrings.length - 1) {
buff.append("*");
}
else {
if (substrings[i].equals("")) {
continue;
}
}
}
return buff.toString();
}
}
././@LongLink 0000000 0000000 0000000 00000000205 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/BinaryLogicalFilter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000005362 11475313376 030217 0 ustar /*
* Copyright 2005-2010 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.filter;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
/**
* Abstract superclass for binary logical operations, that is "AND"
* and "OR" operations.
*
* @author Mattias Hellborg Arthursson
*/
public abstract class BinaryLogicalFilter extends AbstractFilter {
protected List queryList = new LinkedList();
/*
* @see
* org.springframework.ldap.filter.AbstractFilter#encode(java.lang.StringBuffer
* )
*/
public StringBuffer encode(StringBuffer buff) {
if (queryList.size() <= 0) {
// only output query if contains anything
return buff;
}
else if (queryList.size() == 1) {
// don't add the &
Filter query = (Filter) queryList.get(0);
return query.encode(buff);
}
else {
buff.append("(" + getLogicalOperator());
for (Iterator i = queryList.iterator(); i.hasNext();) {
Filter query = (Filter) i.next();
buff = query.encode(buff);
}
buff.append(")");
return buff;
}
}
/**
* Implement this in subclass to return the logical operator, for example
* &qout;&&qout;.
*
* @return the logical operator.
*/
protected abstract String getLogicalOperator();
/**
* Compares each filter in turn.
*
* @see org.springframework.ldap.filter.Filter#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof BinaryLogicalFilter && this.getClass() == obj.getClass()) {
return EqualsBuilder.reflectionEquals(this, obj);
}
else {
return false;
}
}
/**
* Hashes all contained data.
*
* @see org.springframework.ldap.filter.Filter#hashCode()
*/
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
/**
* Add a query to this logical operation.
*
* @param query the query to add.
* @return This instance.
*/
public final BinaryLogicalFilter append(Filter query) {
queryList.add(query);
return this;
}
}
././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/filter/Filter.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000003057 11475313376 030216 0 ustar /*
* Copyright 2005-2010 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.filter;
/**
* Common interface for LDAP filters.
*
* @author Adam Skogman
* @see RFC 1960: A String
* Representation of LDAP Search Filters< /a>
*/
public interface Filter {
/**
* Encodes the filter to a String.
*
* @return The encoded filter in the standard String format
*/
String encode();
/**
* Encodes the filter to a StringBuffer.
*
* @param buf The StringBuffer to encode the filter to
* @return The same StringBuffer as was given
*/
StringBuffer encode(StringBuffer buf);
/**
* All filters must implement equals.
*
* @param o
* @return true if the objects are equal.
*/
boolean equals(Object o);
/**
* All filters must implement hashCode.
*
* @return the hash code according to the contract in
* {@link Object#hashCode()}
*/
int hashCode();
} ././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/PartialResultException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001774 11475313376 030222 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI PartialResultException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.PartialResultException
*/
public class PartialResultException extends NamingException {
public PartialResultException(javax.naming.PartialResultException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000201 00000000000 011556 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/MalformedLinkException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001772 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI MalformedLinkException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.MalformedLinkException
*/
public class MalformedLinkException extends LinkException {
public MalformedLinkException(javax.naming.MalformedLinkException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000174 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap/ReferralException.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/ldap0000644 0000000 0000000 00000001754 11475313376 030220 0 ustar /*
* Copyright 2005-2010 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;
/**
* Runtime exception mirroring the JNDI ReferralException.
*
* @author Ulrik Sandberg
* @since 1.2
* @see javax.naming.ReferralException
*/
public abstract class ReferralException extends NamingException {
public ReferralException(javax.naming.ReferralException cause) {
super(cause);
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0002755 0000000 0000000 00000000000 11475313376 030235 5 ustar ././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0002755 0000000 0000000 00000000000 11475313376 030235 5 ustar ././@LongLink 0000000 0000000 0000000 00000000247 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/CompensatingTransactionOperationRecorder.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000003303 11475313376 030234 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
/**
* An implementation of this interface is responsible for recording data and
* supplying a {@link CompensatingTransactionOperationExecutor} to be invoked
* for execution and compensating transaction management of the operation.
* Recording of an operation should not fail (throwing an Exception), but
* instead log the result.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface CompensatingTransactionOperationRecorder {
/**
* Record information about the operation performed and return a
* corresponding {@link CompensatingTransactionOperationExecutor} to be used
* if the operation would need to be rolled back.
*
* @param args
* The arguments that have been sent to the operation.
* @return A {@link CompensatingTransactionOperationExecutor} to be used if
* the recorded operation should need to be rolled back.
*/
CompensatingTransactionOperationExecutor recordOperation(
Object[] args);
}
././@LongLink 0000000 0000000 0000000 00000000246 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/CompensatingTransactionOperationManager.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000004034 11475313376 030236 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
/**
* A CompensatingTransactionOperationManager implementation records and performs
* operations that are to be performed within a compensating transaction. It
* keeps track of compensating actions necessary for rolling back each
* individual operation.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public interface CompensatingTransactionOperationManager {
/**
* Indicates that the supplied operation (method name) is to be performed.
* This method is responsible for recording the current state (prior to the
* operation), performing the operation, and storing the necessary
* information to roll back or commit the performed operation.
*
* @param resource
* the target resource to perform the operation on.
* @param operation
* The method to be invoked.
* @param args
* Arguments supplied to the method.
*/
void performOperation(Object resource, String operation,
Object[] args);
/**
* Rollback all recorded operations by performing each of the recorded
* rollback operations.
*/
void rollback();
/**
* Commit all recorded operations. In many cases this means doing nothing,
* but in some cases some temporary data will need to be removed.
*/
void commit();
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/ libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0002755 0000000 0000000 00000000000 11475313376 030235 5 ustar ././@LongLink 0000000 0000000 0000000 00000000253 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/CompensatingTransactionHolderSupport.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000005265 11475313376 030245 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import org.springframework.transaction.compensating.CompensatingTransactionOperationManager;
import org.springframework.transaction.support.ResourceHolderSupport;
/**
* Base class for compensating transaction resource holders.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public abstract class CompensatingTransactionHolderSupport extends
ResourceHolderSupport {
private CompensatingTransactionOperationManager transactionOperationManager;
/**
* Constructor.
*
* @param manager
* The {@link CompensatingTransactionOperationManager} to use for
* creating Compensating operations.
*/
public CompensatingTransactionHolderSupport(
CompensatingTransactionOperationManager manager) {
this.transactionOperationManager = manager;
}
/**
* Get the actual transacted resource.
*
* @return the transaction's target resource
*/
protected abstract Object getTransactedResource();
/*
* @see org.springframework.transaction.support.ResourceHolderSupport#clear()
*/
public void clear() {
super.clear();
transactionOperationManager = null;
}
/**
* Get the CompensatingTransactionOperationManager to handle the data for
* the current transaction.
*
* @return the CompensatingTransactionOperationManager.
*/
public CompensatingTransactionOperationManager getTransactionOperationManager() {
return transactionOperationManager;
}
/**
* Set the CompensatingTransactionOperationManager. For testing purposes
* only.
*
* @param transactionOperationManager
* the CompensatingTransactionOperationManager to use.
*/
public void setTransactionOperationManager(
CompensatingTransactionOperationManager transactionOperationManager) {
this.transactionOperationManager = transactionOperationManager;
}
} ././@LongLink 0000000 0000000 0000000 00000000216 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000000300 11475313376 030226 0 ustar
Support package for general Compensating Transaction Framework.
Contains default implementations of core interfaces as well as useful
helper classes.
././@LongLink 0000000 0000000 0000000 00000000265 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/AbstractCompensatingTransactionManagerDelegate.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000012261 11475313376 030237 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.transaction.CannotCreateTransactionException;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.support.DefaultTransactionStatus;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* Abstract superclass for Compensating TransactionManager delegates. The actual
* transaction work is extracted to a delegate to enable composite Transaction
* Managers.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public abstract class AbstractCompensatingTransactionManagerDelegate {
private static Log log = LogFactory.getLog(AbstractCompensatingTransactionManagerDelegate.class);
/**
* Close the target resource - the implementation specific resource held in
* the specified {@link CompensatingTransactionHolderSupport}.
*
* @param transactionHolderSupport the
* {@link CompensatingTransactionHolderSupport} that holds the transaction
* specific target resource.
*/
protected abstract void closeTargetResource(CompensatingTransactionHolderSupport transactionHolderSupport);
/**
* Get a new implementation specific
* {@link CompensatingTransactionHolderSupport} instance.
*
* @return a new {@link CompensatingTransactionHolderSupport} instance.
*/
protected abstract CompensatingTransactionHolderSupport getNewHolder();
/**
* Get the key (normally, a DataSource or similar) that should be used for
* transaction synchronization.
*
* @return the transaction synchronization key
*/
protected abstract Object getTransactionSynchronizationKey();
/*
* @seeorg.springframework.jdbc.datasource.DataSourceTransactionManager#
* doGetTransaction()
*/
public Object doGetTransaction() throws TransactionException {
CompensatingTransactionHolderSupport holder = (CompensatingTransactionHolderSupport) TransactionSynchronizationManager
.getResource(getTransactionSynchronizationKey());
CompensatingTransactionObject txObject = new CompensatingTransactionObject(holder);
return txObject;
}
/*
* @see
* org.springframework.jdbc.datasource.DataSourceTransactionManager#doBegin
* (java.lang.Object, org.springframework.transaction.TransactionDefinition)
*/
public void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
try {
CompensatingTransactionObject txObject = (CompensatingTransactionObject) transaction;
if (txObject.getHolder() == null) {
CompensatingTransactionHolderSupport contextHolder = getNewHolder();
txObject.setHolder(contextHolder);
TransactionSynchronizationManager.bindResource(getTransactionSynchronizationKey(), contextHolder);
}
}
catch (Exception e) {
throw new CannotCreateTransactionException("Could not create DirContext instance for transaction", e);
}
}
/*
* @see
* org.springframework.jdbc.datasource.DataSourceTransactionManager#doCommit
* (org.springframework.transaction.support.DefaultTransactionStatus)
*/
public void doCommit(DefaultTransactionStatus status) throws TransactionException {
CompensatingTransactionObject txObject = (CompensatingTransactionObject) status.getTransaction();
txObject.getHolder().getTransactionOperationManager().commit();
}
/*
* @see
* org.springframework.jdbc.datasource.DataSourceTransactionManager#doRollback
* (org.springframework.transaction.support.DefaultTransactionStatus)
*/
public void doRollback(DefaultTransactionStatus status) throws TransactionException {
CompensatingTransactionObject txObject = (CompensatingTransactionObject) status.getTransaction();
txObject.getHolder().getTransactionOperationManager().rollback();
}
/*
* @seeorg.springframework.jdbc.datasource.DataSourceTransactionManager#
* doCleanupAfterCompletion(java.lang.Object)
*/
public void doCleanupAfterCompletion(Object transaction) {
log.debug("Cleaning stored transaction synchronization");
TransactionSynchronizationManager.unbindResource(getTransactionSynchronizationKey());
CompensatingTransactionObject txObject = (CompensatingTransactionObject) transaction;
CompensatingTransactionHolderSupport transactionHolderSupport = (CompensatingTransactionHolderSupport) txObject
.getHolder();
closeTargetResource(transactionHolderSupport);
txObject.getHolder().clear();
}
} ././@LongLink 0000000 0000000 0000000 00000000243 00000000000 011564 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/CompensatingTransactionUtils.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000005716 11475313376 030246 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.springframework.transaction.compensating.CompensatingTransactionOperationManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* Common methods for use with compensating transactions.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class CompensatingTransactionUtils {
/**
* Not to be instantiated.
*/
private CompensatingTransactionUtils() {
}
/**
* Perform the specified operation, storing the state prior to the operation
* in order to enable commit/rollback later. If no transaction is currently
* active, proceed with the original call on the target.
*
* @param synchronizationKey
* the transaction synchronization key we are operating on
* (typically something similar to a DataSource).
* @param target
* the actual target resource that should be used for invoking
* the operation on should no transaction be active.
* @param method
* name of the method to be invoked.
* @param args
* arguments with which the operation is invoked.
*/
public static void performOperation(Object synchronizationKey,
Object target, Method method, Object[] args) throws Throwable {
CompensatingTransactionHolderSupport transactionResourceHolder = (CompensatingTransactionHolderSupport) TransactionSynchronizationManager
.getResource(synchronizationKey);
if (transactionResourceHolder != null) {
CompensatingTransactionOperationManager transactionOperationManager = transactionResourceHolder
.getTransactionOperationManager();
transactionOperationManager.performOperation(
transactionResourceHolder.getTransactedResource(), method
.getName(), args);
} else {
// Perform the target operation
try {
method.invoke(target, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000265 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/DefaultCompensatingTransactionOperationManager.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000011535 11475313376 030242 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
import java.util.Iterator;
import java.util.Stack;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.compensating.CompensatingTransactionOperationExecutor;
import org.springframework.transaction.compensating.CompensatingTransactionOperationFactory;
import org.springframework.transaction.compensating.CompensatingTransactionOperationManager;
import org.springframework.transaction.compensating.CompensatingTransactionOperationRecorder;
/**
* Default implementation of {@link CompensatingTransactionOperationManager}.
* Manages a stack of {@link CompensatingTransactionOperationExecutor} objects
* and performs rollback of these in the reverse order.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class DefaultCompensatingTransactionOperationManager implements
CompensatingTransactionOperationManager {
private static Log log = LogFactory
.getLog(DefaultCompensatingTransactionOperationManager.class);
private Stack operationExecutors = new Stack();
private CompensatingTransactionOperationFactory operationFactory;
/**
* Set the {@link CompensatingTransactionOperationFactory} to use.
*
* @param operationFactory
* the {@link CompensatingTransactionOperationFactory}.
*/
public DefaultCompensatingTransactionOperationManager(
CompensatingTransactionOperationFactory operationFactory) {
this.operationFactory = operationFactory;
}
/*
* @see org.springframework.transaction.compensating.CompensatingTransactionOperationManager#performOperation(java.lang.Object,
* java.lang.String, java.lang.Object[])
*/
public void performOperation(Object resource, String operation,
Object[] args) {
CompensatingTransactionOperationRecorder recorder = operationFactory
.createRecordingOperation(resource, operation);
CompensatingTransactionOperationExecutor executor = recorder
.recordOperation(args);
executor.performOperation();
// Don't push the executor until the actual operation passed.
operationExecutors.push(executor);
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationManager#rollback()
*/
public void rollback() {
log.debug("Performing rollback");
while (!operationExecutors.isEmpty()) {
CompensatingTransactionOperationExecutor rollbackOperation = (CompensatingTransactionOperationExecutor) operationExecutors
.pop();
try {
rollbackOperation.rollback();
} catch (Exception e) {
throw new TransactionSystemException(
"Error occurred during rollback", e);
}
}
}
/**
* Get the rollback operations. Used for testing purposes.
*
* @return the rollback operations.
*/
protected Stack getOperationExecutors() {
return operationExecutors;
}
/**
* Set the rollback operations. Package protected - for testing purposes
* only.
*
* @param operationExecutors
* the rollback operations.
*/
void setOperationExecutors(Stack operationExecutors) {
this.operationExecutors = operationExecutors;
}
/*
* @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationManager#commit()
*/
public void commit() {
log.debug("Performing commit");
for (Iterator iter = operationExecutors.iterator(); iter.hasNext();) {
CompensatingTransactionOperationExecutor operationExecutor = (CompensatingTransactionOperationExecutor) iter
.next();
try {
operationExecutor.commit();
} catch (Exception e) {
throw new TransactionSystemException(
"Error occurred during commit", e);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000244 00000000000 011565 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/support/CompensatingTransactionObject.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000003747 11475313376 030250 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating.support;
/**
* Transaction object used by
* {@link AbstractCompensatingTransactionManagerDelegate}. Keeps a reference to
* the {@link CompensatingTransactionHolderSupport} associated with the current
* transaction.
*
* @author Mattias Hellborg Arthursson
* @since 1.2
*/
public class CompensatingTransactionObject {
private CompensatingTransactionHolderSupport holder;
/**
* Constructor.
*
* @param holder
* the {@link CompensatingTransactionHolderSupport} associated
* with the current transaction.
*/
public CompensatingTransactionObject(
CompensatingTransactionHolderSupport holder) {
this.holder = holder;
}
/**
* Get the DirContextHolder.
*
* @return the DirContextHolder.
*/
public CompensatingTransactionHolderSupport getHolder() {
return holder;
}
/**
* Set the {@link CompensatingTransactionHolderSupport} associated with the
* current transaction.
*
* @param holder
* the {@link CompensatingTransactionHolderSupport} associated
* with the current transaction.
*/
public void setHolder(CompensatingTransactionHolderSupport holder) {
this.holder = holder;
}
} ././@LongLink 0000000 0000000 0000000 00000000206 00000000000 011563 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/package.html libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000000224 11475313376 030233 0 ustar
Interface definitions for a general Compensating Transaction framework
based on PlatformTransactionManager.
././@LongLink 0000000 0000000 0000000 00000000246 00000000000 011567 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/CompensatingTransactionOperationFactory.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000003266 11475313376 030244 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
import org.springframework.transaction.compensating.support.DefaultCompensatingTransactionOperationManager;
/**
* Factory interface for creating
* {@link CompensatingTransactionOperationRecorder} objects based on operation
* method names.
*
* @author Mattias Hellborg Arthursson
* @see DefaultCompensatingTransactionOperationManager
* @since 1.2
*/
public interface CompensatingTransactionOperationFactory {
/**
* Create an appropriate {@link CompensatingTransactionOperationRecorder}
* instance corresponding to the supplied method name.
*
* @param resource
* The target transaction resource.
* @param method
* the method name to create a
* {@link CompensatingTransactionOperationRecorder} for.
*
* @return a new {@link CompensatingTransactionOperationRecorder} instance.
*/
CompensatingTransactionOperationRecorder createRecordingOperation(
Object resource, String method);
}
././@LongLink 0000000 0000000 0000000 00000000247 00000000000 011570 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/transaction/compensating/CompensatingTransactionOperationExecutor.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-core/org/springframework/tran0000644 0000000 0000000 00000005245 11475313376 030243 0 ustar /*
* Copyright 2005-2010 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.transaction.compensating;
/**
* Responsible for executing a single recorded operation as well as committing
* or rolling it back, depending on the transaction outcome. Instances of this
* interface are constructed by {@link CompensatingTransactionOperationRecorder}
* objects, supplying them with the information necessary for the respective
* operations.
*
././@LongLink 0000000 0000000 0000000 00000000214 00000000000 011562 L ustar root root libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework/ldap/ldif/support/SeparatorPolicy.java libspring-ldap-java-1.3.1.RELEASE.orig/dist/module-sources/spring-ldap-ldif-core/org/springframework0000644 0000000 0000000 00000006520 11475313400 030174 0 ustar /*
* Copyright 2005-2010 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.
*
*
*