- * 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. In an LDAP system for instance this will not be - * possible, because 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 Arthursson - */ -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. - */ - public 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. - */ - public 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. - */ - public void performOperation(); -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationFactory.java b/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationFactory.java deleted file mode 100644 index 2864776d..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationFactory.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * 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; - -/** - * Factory interface for creating - * {@link CompensatingTransactionOperationRecorder} objects based on operation - * method names. - * - * @author Mattias Arthursson - * @see DefaultCompensatingTransactionOperationManager - */ -public interface CompensatingTransactionOperationFactory { - /** - * Create an appropriate {@link CompensatingTransactionOperationRecorder} - * instance corresponding to the supplied method name. - * - * @param method - * the method name to create a - * {@link CompensatingTransactionOperationRecorder} for. - * @return a new {@link CompensatingTransactionOperationRecorder} instance. - */ - public CompensatingTransactionOperationRecorder createRecordingOperation( - String method); -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationManager.java b/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationManager.java deleted file mode 100644 index 197902e3..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationManager.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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; - -/** - * A CompensatingTransactionOperationManager implementation records and performs - * operations that are to be performed within a compensating transaction and - * keeps track of compensating actions necessary for rolling back each - * individual operation. - * - * @author Mattias Arthursson - * - */ -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 operation - * The method to be invoked. - * @param args - * Arguments supplied to the method. - */ - public void performOperation(String operation, Object[] args); - - /** - * Rollback all recorded operations, by performing each of the recorded - * rollback operations. - */ - public 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. - */ - public void commit(); -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationRecorder.java deleted file mode 100644 index 3c715f39..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/CompensatingTransactionOperationRecorder.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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; - -/** - * 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 rather - * log the result. - * - * @author Mattias Arthursson - */ -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. - */ - public CompensatingTransactionOperationExecutor recordOperation( - Object[] args); -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManager.java b/sandbox/src/main/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManager.java deleted file mode 100644 index 16af2734..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManager.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * 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; - -import java.util.Stack; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -/** - * Default implementation of {@link CompensatingTransactionOperationManager}. - * Manages a stack of {@link CompensatingTransactionOperationExecutor} objects - * and manages rollback of these in the reverse order. - * - * @author Mattias Arthursson - */ -public class DefaultCompensatingTransactionOperationManager implements - CompensatingTransactionOperationManager { - - private static Log log = LogFactory - .getLog(DefaultCompensatingTransactionOperationManager.class); - - private Stack rollbackOperations = new Stack(); - - private CompensatingTransactionOperationFactory operationFactory; - - /** - * Set the {@link CompensatingTransactionOperationFactory} to use. - * - * @param operationFactory - * the {@link CompensatingTransactionOperationFactory}. - */ - public DefaultCompensatingTransactionOperationManager( - CompensatingTransactionOperationFactory operationFactory) { - this.operationFactory = operationFactory; - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationManager#operationPerformed(java.lang.String, - * java.lang.Object[]) - */ - public void performOperation(String operation, Object[] args) { - CompensatingTransactionOperationRecorder recorder = operationFactory - .createRecordingOperation(operation); - CompensatingTransactionOperationExecutor executor = recorder - .recordOperation(args); - - executor.performOperation(); - - // Don't push the executor until the actual operation passed. - rollbackOperations.push(executor); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationManager#rollback() - */ - public void rollback() { - log.debug("Performing rollback"); - while (!rollbackOperations.isEmpty()) { - CompensatingTransactionOperationExecutor rollbackOperation = (CompensatingTransactionOperationExecutor) rollbackOperations - .pop(); - rollbackOperation.rollback(); - } - } - - /** - * Get the rollback operations. Package protected for testing purposes. - * - * @return the rollback operations. - */ - protected Stack getRollbackOperations() { - return rollbackOperations; - } - - /** - * Set the rollback operations. Package protected - for testing purposes - * only. - * - * @param rollbackOperations - * the rollback operations. - */ - void setRollbackOperations(Stack rollbackOperations) { - this.rollbackOperations = rollbackOperations; - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationManager#commit() - */ - public void commit() { - log.debug("Performing rollback"); - // TODO: Should this really be done in reverse order? - while (!rollbackOperations.isEmpty()) { - CompensatingTransactionOperationExecutor rollbackOperation = (CompensatingTransactionOperationExecutor) rollbackOperations - .pop(); - rollbackOperation.commit(); - } - } - -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationExecutor.java deleted file mode 100644 index 43b326fe..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationExecutor.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * 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.core; - -import javax.naming.Name; -import javax.naming.directory.Attributes; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.springframework.ldap.core.LdapOperations; -import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor; - -/** - * A {@link CompensatingTransactionOperationExecutor} to manage a bind - * operation. Performs a bind in {@link #performOperation()}, a corresponding - * unbind in {@link #rollback()}, and nothing in {@link #commit()}. - * - * @author Mattias Arthursson - */ -public class BindOperationExecutor implements - CompensatingTransactionOperationExecutor { - private static Log log = LogFactory.getLog(BindOperationExecutor.class); - - private LdapOperations ldapOperations; - - private Name dn; - - private Object originalObject; - - private Attributes originalAttributes; - - /** - * Constructor. - * - * @param ldapOperations - * {@link LdapOperations} to use for performing the rollback - * operation. - * @param dn - * DN of the entry to be unbound. - * @param originalObject - * original value sent to the 'object' parameter of the bind - * operation. - * @param originalAttributes - * original value sent to the 'attributes' parameter of the bind - * operation. - */ - public BindOperationExecutor(LdapOperations ldapOperations, Name dn, - Object originalObject, Attributes originalAttributes) { - this.ldapOperations = ldapOperations; - this.dn = dn; - this.originalObject = originalObject; - this.originalAttributes = originalAttributes; - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback() - */ - public void rollback() { - try { - ldapOperations.unbind(dn); - } catch (Exception e) { - log.warn("Failed to rollback, dn:" + dn.toString(), e); - } - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit() - */ - public void commit() { - log.debug("Nothing to do in commit for bind operation"); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#performOperation() - */ - public void performOperation() { - log.debug("Performing bind operation"); - ldapOperations.bind(dn, originalObject, originalAttributes); - } - - /** - * Get the DN. Package private for testing purposes. - * - * @return the target DN. - */ - Name getDn() { - return dn; - } - - /** - * Get the LdapOperations. Package private for testing purposes. - * - * @return the LdapOperations. - */ - LdapOperations getLdapOperations() { - return ldapOperations; - } - - Attributes getOriginalAttributes() { - return originalAttributes; - } - - Object getOriginalObject() { - return originalObject; - } - -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationRecorder.java deleted file mode 100644 index f7e52b3e..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/BindOperationRecorder.java +++ /dev/null @@ -1,83 +0,0 @@ -/* - * 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.core; - -import javax.naming.Name; -import javax.naming.directory.Attributes; - -import org.springframework.ldap.core.LdapOperations; -import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor; -import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder; - -/** - * A {@link CompensatingTransactionOperationRecorder} to manage LDAP bind - * operations. The corresponding - * {@link CompensatingTransactionOperationExecutor} is - * {@link BindOperationExecutor}. - * - * @author Mattias Arthursson - */ -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; - } - - /* - * (non-Javadoc) - * - * @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 = LdapUtils.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; - } - -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceAndDataSourceTransactionManager.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceAndDataSourceTransactionManager.java deleted file mode 100644 index 5f1720b4..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceAndDataSourceTransactionManager.java +++ /dev/null @@ -1,205 +0,0 @@ -/* - * 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.core; - -import org.springframework.jdbc.datasource.DataSourceTransactionManager; -import org.springframework.ldap.core.ContextSource; -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 JDBC 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 result in unexpected results. - * - * @author Mattias Arthursson - */ -public class ContextSourceAndDataSourceTransactionManager extends - DataSourceTransactionManager { - - private static final long serialVersionUID = 6832868697460384648L; - - private ContextSourceTransactionManagerDelegate ldapManagerDelegate = new ContextSourceTransactionManagerDelegate(); - - public ContextSourceAndDataSourceTransactionManager() { - super(); - // Override the default behaviour. - setNestedTransactionAllowed(false); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#isExistingTransaction(java.lang.Object) - */ - protected boolean isExistingTransaction(Object transaction) { - ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) transaction; - - return super.isExistingTransaction(actualTransactionObject - .getDataSourceTransactionObject()); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#doGetTransaction() - */ - protected Object doGetTransaction() throws TransactionException { - Object dataSourceTransactionObject = super.doGetTransaction(); - Object contextSourceTransactionObject = ldapManagerDelegate - .doGetTransaction(); - - return new ContextSourceAndDataSourceTransactionObject( - contextSourceTransactionObject, dataSourceTransactionObject); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#doBegin(java.lang.Object, - * org.springframework.transaction.TransactionDefinition) - */ - protected void doBegin(Object transaction, TransactionDefinition definition) - throws TransactionException { - ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) transaction; - - super.doBegin(actualTransactionObject.getDataSourceTransactionObject(), - definition); - ldapManagerDelegate.doBegin(actualTransactionObject - .getLdapTransactionObject(), definition); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#doCleanupAfterCompletion(java.lang.Object) - */ - protected void doCleanupAfterCompletion(Object transaction) { - ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) transaction; - - super.doCleanupAfterCompletion(actualTransactionObject - .getDataSourceTransactionObject()); - ldapManagerDelegate.doCleanupAfterCompletion(actualTransactionObject - .getLdapTransactionObject()); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus) - */ - protected void doCommit(DefaultTransactionStatus status) - throws TransactionException { - - ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) status - .getTransaction(); - - try { - super.doCommit(new DefaultTransactionStatus(actualTransactionObject - .getDataSourceTransactionObject(), 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())); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.jdbc.datasource.DataSourceTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus) - */ - protected void doRollback(DefaultTransactionStatus status) - throws TransactionException { - ContextSourceAndDataSourceTransactionObject actualTransactionObject = (ContextSourceAndDataSourceTransactionObject) status - .getTransaction(); - - super.doRollback(new DefaultTransactionStatus(actualTransactionObject - .getDataSourceTransactionObject(), 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 class ContextSourceAndDataSourceTransactionObject { - private Object ldapTransactionObject; - - private Object dataSourceTransactionObject; - - public ContextSourceAndDataSourceTransactionObject( - Object ldapTransactionObject, Object dataSourceTransactionObject) { - this.ldapTransactionObject = ldapTransactionObject; - this.dataSourceTransactionObject = dataSourceTransactionObject; - } - - public Object getDataSourceTransactionObject() { - return dataSourceTransactionObject; - } - - public Object getLdapTransactionObject() { - return ldapTransactionObject; - } - } - - protected Object doSuspend(Object transaction) throws TransactionException { - throw new TransactionSuspensionNotSupportedException( - "Transaction manager [" + getClass().getName() - + "] does not support transaction suspension"); - } - - protected void doResume(Object transaction, Object suspendedResources) - throws TransactionException { - throw new TransactionSuspensionNotSupportedException( - "Transaction manager [" + getClass().getName() - + "] does not support transaction suspension"); - } -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManager.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManager.java deleted file mode 100644 index 1e179fab..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManager.java +++ /dev/null @@ -1,192 +0,0 @@ -/* - * 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.core; - -import org.springframework.ldap.core.ContextSource; -import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor; -import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder; -import org.springframework.ldap.transaction.DefaultCompensatingTransactionOperationManager; -import org.springframework.transaction.TransactionDefinition; -import org.springframework.transaction.TransactionException; -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 aims to - * provide compensating transactions instead, i.e. should a transaction need to - * be rolled back this TransactionManager will try to restore the original - * original state using information recorded prior to each operation. - *
- * 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, particularly considering the total absence of - * transaction support which is normally the case working against LDAP servers. - *
- *- * 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. E.g. 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. E.g. an unbind operation is - * not possible to roll back by simply binding the entry back with the - * attributes retrieved from the original entry. This is because 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. In the commit() method - * we already know that everything went well, so we're free to unbind the entry, - * but 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. - *
- * - * @author Mattias Arthursson - * - * @see ContextSourceAndDataSourceTransactionManager - * @see ContextSourceTransactionManagerDelegate - * @see DefaultCompensatingTransactionOperationManager - * @see TempEntryRenamingStrategy - * @see TransactionAwareContextSourceProxy - */ -public class ContextSourceTransactionManager extends - AbstractPlatformTransactionManager { - - private static final long serialVersionUID = 7138208218687237856L; - - private ContextSourceTransactionManagerDelegate delegate = new ContextSourceTransactionManagerDelegate(); - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, - * org.springframework.transaction.TransactionDefinition) - */ - protected void doBegin(Object transaction, TransactionDefinition definition) - throws TransactionException { - delegate.doBegin(transaction, definition); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doCleanupAfterCompletion(java.lang.Object) - */ - protected void doCleanupAfterCompletion(Object transaction) { - delegate.doCleanupAfterCompletion(transaction); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus) - */ - protected void doCommit(DefaultTransactionStatus status) - throws TransactionException { - delegate.doCommit(status); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doGetTransaction() - */ - protected Object doGetTransaction() throws TransactionException { - return delegate.doGetTransaction(); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus) - */ - protected void doRollback(DefaultTransactionStatus status) - throws TransactionException { - delegate.doRollback(status); - } - - /** - * Get the ContextSource. - * - * @return the contextSource. - * @see ContextSourceTransactionManagerDelegate#getContextSource() - */ - public ContextSource getContextSource() { - return delegate.getContextSource(); - } - - /** - * Set the ContextSource. - * - * @param contextSource - * the ContextSource. - * @see ContextSourceTransactionManagerDelegate#setContextSource(ContextSource) - */ - public void setContextSource(ContextSource contextSource) { - delegate.setContextSource(contextSource); - } - - /** - * Set the {@link TempEntryRenamingStrategy}. - * - * @param renamingStrategy - * the Renaming Strategy. - * @see ContextSourceTransactionManagerDelegate#setRenamingStrategy(TempEntryRenamingStrategy) - */ - public void setRenamingStrategy(TempEntryRenamingStrategy renamingStrategy) { - delegate.setRenamingStrategy(renamingStrategy); - } -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerDelegate.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerDelegate.java deleted file mode 100644 index c96f436c..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerDelegate.java +++ /dev/null @@ -1,163 +0,0 @@ -/* - * 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.core; - -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.transaction.TransactionDefinition; -import org.springframework.transaction.TransactionException; -import org.springframework.transaction.support.DefaultTransactionStatus; -import org.springframework.transaction.support.TransactionSynchronizationManager; - -/** - * 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 Arthursson - * @see ContextSourceTransactionManager - * @see ContextSourceAndDataSourceTransactionManager - */ -public class ContextSourceTransactionManagerDelegate { - private static Log log = LogFactory - .getLog(ContextSourceTransactionManager.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; - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doGetTransaction() - */ - public Object doGetTransaction() throws TransactionException { - DirContextHolder contextHolder = (DirContextHolder) TransactionSynchronizationManager - .getResource(this.contextSource); - ContextSourceTransactionObject txObject = new ContextSourceTransactionObject( - contextHolder); - return txObject; - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, - * org.springframework.transaction.TransactionDefinition) - */ - public void doBegin(Object transaction, TransactionDefinition definition) - throws TransactionException { - ContextSourceTransactionObject txObject = (ContextSourceTransactionObject) transaction; - - if (txObject.getContextHolder() == null) { - DirContext newCtx = getContextSource().getReadOnlyContext(); - DirContextHolder contextHolder = new DirContextHolder(newCtx, - renamingStrategy); - - txObject.setContextHolder(contextHolder); - TransactionSynchronizationManager.bindResource(getContextSource(), - contextHolder); - } - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus) - */ - public void doCommit(DefaultTransactionStatus status) - throws TransactionException { - ContextSourceTransactionObject txObject = (ContextSourceTransactionObject) status - .getTransaction(); - txObject.getContextHolder().getTransactionDataManager().commit(); - - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus) - */ - public void doRollback(DefaultTransactionStatus status) - throws TransactionException { - ContextSourceTransactionObject txObject = (ContextSourceTransactionObject) status - .getTransaction(); - txObject.getContextHolder().getTransactionDataManager().rollback(); - } - - /* - * (non-Javadoc) - * - * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doCleanupAfterCompletion(java.lang.Object) - */ - public void doCleanupAfterCompletion(Object transaction) { - log.debug("Cleaning stored ContextHolder"); - TransactionSynchronizationManager.unbindResource(contextSource); - - ContextSourceTransactionObject txObject = (ContextSourceTransactionObject) transaction; - DirContext ctx = txObject.getContextHolder().getCtx(); - - try { - log.debug("Closing target context"); - ctx.close(); - } catch (NamingException e) { - e.printStackTrace(); - } - - txObject.getContextHolder().clear(); - } - - /** - * 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; - } - -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionObject.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionObject.java deleted file mode 100644 index 3dac7d5b..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ContextSourceTransactionObject.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * 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.core; - -/** - * Transaction object for ContextSourceTransactionManager. Keeps a reference to - * the {@link DirContextHolder} associated with the current transaction. - * - * @author Mattias Arthursson - */ -public class ContextSourceTransactionObject { - private DirContextHolder contextHolder; - - /** - * Constructor. - * - * @param contextHolder - * the DirContextHolder associated with the current transaction. - */ - public ContextSourceTransactionObject(DirContextHolder contextHolder) { - this.contextHolder = contextHolder; - } - - /** - * Get the DirContextHolder. - * - * @return the DirContextHolder. - */ - public DirContextHolder getContextHolder() { - return contextHolder; - } - - /** - * Set the DirContextHolder associated with the current transaction.s - * - * @param contextHolder - * the DirContextHolder associated with the current transaction. - */ - public void setContextHolder(DirContextHolder contextHolder) { - this.contextHolder = contextHolder; - } -} \ No newline at end of file diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategy.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategy.java deleted file mode 100644 index 5c31e0f8..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategy.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * 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.core; - -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; - -/** - * Default implementation of {@link TempEntryRenamingStrategy}. This - * implementation simply adds "_temp" to the leftmost (least siginificant part) - * of the name, e.g.:
- * cn=john doe, ou=company1, c=SE
- *
- *
- * becomes
- *
- *
- * cn=john doe_temp, ou=company1, c=SE
- * .
- * - * 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 Arthursson - */ -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; - - /* - * (non-Javadoc) - * - * @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; - } - -} diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategy.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategy.java deleted file mode 100644 index 2191b50a..00000000 --- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategy.java +++ /dev/null @@ -1,90 +0,0 @@ -/* - * 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.core; - -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; - -/** - * 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 it is not in place. However, this strategy is preferrable to - * {@link DefaultTempEntryRenamingStrategy}, as it makes it possible to have - * searches have the expected result even though the temporary entry still exits - * until the end of the transaction. - *
- * Example: If the specified 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 Arthursson
- *
- */
-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;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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;
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextHolder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextHolder.java
deleted file mode 100644
index ccf88221..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextHolder.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.directory.DirContext;
-
-import org.springframework.ldap.transaction.CompensatingTransactionOperationFactory;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationManager;
-import org.springframework.ldap.transaction.DefaultCompensatingTransactionOperationManager;
-import org.springframework.transaction.support.ResourceHolderSupport;
-
-/**
- * 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 Arthursson
- *
- */
-public class DirContextHolder extends ResourceHolderSupport {
- private DirContext ctx;
-
- private CompensatingTransactionOperationManager transactionDataManager;
-
- private CompensatingTransactionOperationFactory operationFactory;
-
- private TempEntryRenamingStrategy renamingStrategy;
-
- /**
- * Constructor.
- *
- * @param ctx
- * The DirContext associated with the current transaction.
- */
- public DirContextHolder(DirContext ctx,
- TempEntryRenamingStrategy renamingStrategy) {
- this.ctx = ctx;
- this.renamingStrategy = renamingStrategy;
- this.transactionDataManager = new DefaultCompensatingTransactionOperationManager(
- createOperationFactory());
- }
-
- /**
- * 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;
- this.transactionDataManager = new DefaultCompensatingTransactionOperationManager(
- createOperationFactory());
- }
-
- /**
- * Factory method to create a
- * {@link CompensatingTransactionOperationFactory} using the settings and
- * current state of this object.
- *
- * @return a new {@link LdapCompensatingTransactionOperationFactory}
- * referncing the current transaction context.
- */
- private CompensatingTransactionOperationFactory createOperationFactory() {
- return new LdapCompensatingTransactionOperationFactory(ctx,
- renamingStrategy);
- }
-
- /**
- * Return the DirContext associated with the current transaction.
- */
- public DirContext getCtx() {
- return ctx;
- }
-
- public void clear() {
- super.clear();
- transactionDataManager = null;
- operationFactory = null;
- }
-
- /**
- * Get the CompensatingTransactionOperationManager to handle the data for
- * the current transaction.
- *
- * @return the CompensatingTransactionOperationManager.
- */
- public CompensatingTransactionOperationManager getTransactionDataManager() {
- return transactionDataManager;
- }
-
- /**
- * Set the CompensatingTransactionOperationManager. For testing purposes
- * only.
- *
- * @param transactionDataManager
- * the CompensatingTransactionOperationManager to use.
- */
- void setTransactionDataManager(
- CompensatingTransactionOperationManager transactionDataManager) {
- this.transactionDataManager = transactionDataManager;
- }
-
- public CompensatingTransactionOperationFactory getOperationFactory() {
- return operationFactory;
- }
-
- public TempEntryRenamingStrategy getRenamingStrategy() {
- return renamingStrategy;
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextProxy.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextProxy.java
deleted file mode 100644
index 0ff0d744..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/DirContextProxy.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.directory.DirContext;
-
-/**
- * Helper interface to be able to get hold of the target DirContext from proxies
- * created by {@link TransactionAwareContextSourceProxy}.
- *
- * @author Mattias Arthursson
- */
-public interface DirContextProxy extends DirContext {
- /**
- * Get the target DirContext of the proxy.
- *
- * @return the target DirContext.
- */
- DirContext getTargetContext();
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactory.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactory.java
deleted file mode 100644
index 527bfa3e..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactory.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * 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.core;
-
-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.lang.StringUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.dao.DataAccessException;
-import org.springframework.ldap.core.ContextSource;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.core.LdapTemplate;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationFactory;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-
-/**
- * {@link CompensatingTransactionOperationRecorder} implementation for LDAP
- * operations.
- *
- * @author Mattias Arthursson
- */
-public class LdapCompensatingTransactionOperationFactory implements
- CompensatingTransactionOperationFactory {
- private static Log log = LogFactory
- .getLog(LdapCompensatingTransactionOperationFactory.class);
-
- private LdapOperations ldapOperations;
-
- private TempEntryRenamingStrategy renamingStrategy;
-
- /**
- * Constructor.
- *
- * @param ctx
- * The transactional DirContext.
- */
- public LdapCompensatingTransactionOperationFactory(DirContext ctx,
- TempEntryRenamingStrategy renamingStrategy) {
- this.ldapOperations = new LdapTemplate(new SingleContextSource(ctx));
- this.renamingStrategy = renamingStrategy;
- }
-
- public CompensatingTransactionOperationRecorder createRecordingOperation(
- String operation) {
- if (StringUtils.equals(operation, LdapUtils.BIND_METHOD_NAME)) {
- log.debug("Bind operation recorded");
- return new BindOperationRecorder(ldapOperations);
- } else if (StringUtils.equals(operation, LdapUtils.REBIND_METHOD_NAME)) {
- log.debug("Rebind operation recorded");
- return new RebindOperationRecorder(ldapOperations, renamingStrategy);
- } else if (StringUtils.equals(operation, LdapUtils.RENAME_METHOD_NAME)) {
- log.debug("Rename operation recorded");
- return new RenameOperationRecorder(ldapOperations);
- } else if (StringUtils.equals(operation,
- LdapUtils.MODIFY_ATTRIBUTES_METHOD_NAME)) {
- return new ModifyAttributesOperationRecorder(ldapOperations);
- } else if (StringUtils.equals(operation, LdapUtils.UNBIND_METHOD_NAME)) {
- return new UnbindOperationRecorder(ldapOperations, renamingStrategy);
- }
-
- log
- .warn("No suitable CompensatingTransactionOperationRecorder found for method "
- + operation + ". Operation will not be transacted.");
- return new NullOperationRecorder();
- }
-
- /**
- * A {@link ContextSource} implementation using returning
- * {@link NonClosingDirContextInvocationHandler} proxies on the same
- * DirContext instance for each call.
- *
- * @author Mattias Arthursson
- */
- static class SingleContextSource implements ContextSource {
- private DirContext ctx;
-
- /**
- * Constructor.
- *
- * @param ctx
- * the target DirContext.
- */
- public SingleContextSource(DirContext ctx) {
- this.ctx = ctx;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.ContextSource#getReadOnlyContext()
- */
- public DirContext getReadOnlyContext() throws DataAccessException {
- return getNonClosingDirContextProxy(ctx);
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.ContextSource#getReadWriteContext()
- */
- public DirContext getReadWriteContext() throws DataAccessException {
- return getNonClosingDirContextProxy(ctx);
- }
-
- private DirContext getNonClosingDirContextProxy(DirContext context) {
- return (DirContext) Proxy.newProxyInstance(DirContextProxy.class
- .getClassLoader(), new Class[] { DirContextProxy.class },
- new NonClosingDirContextInvocationHandler(context));
-
- }
- }
-
- /**
- * A proxy for DirContext forwarding all operation to the target DirContext,
- * but making sure that no close operations will be
- * performed.
- *
- * @author Mattias Arthursson
- */
- public static class NonClosingDirContextInvocationHandler implements
- InvocationHandler {
-
- private DirContext target;
-
- public NonClosingDirContextInvocationHandler(DirContext target) {
- this.target = target;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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();
- }
- }
- }
-
- void setLdapOperations(LdapOperations ldapOperations) {
- this.ldapOperations = ldapOperations;
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapUtils.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapUtils.java
deleted file mode 100644
index 8182b3c5..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/LdapUtils.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * 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.core;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import javax.naming.Name;
-import javax.naming.NamingException;
-import javax.naming.directory.DirContext;
-
-import org.apache.commons.lang.StringUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.ldap.core.ContextSource;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationManager;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
-import org.springframework.util.Assert;
-
-/**
- * Common helper methods for Ldap operations.
- *
- * @author Mattias Arthursson
- */
-public class LdapUtils {
- private static Log log = LogFactory.getLog(LdapUtils.class);
-
- public static final String REBIND_METHOD_NAME = "rebind";
-
- public static final String BIND_METHOD_NAME = "bind";
-
- public static final String RENAME_METHOD_NAME = "rename";
-
- public static final String UNBIND_METHOD_NAME = "unbind";
-
- public static final String MODIFY_ATTRIBUTES_METHOD_NAME = "modifyAttributes";
-
- /**
- * Not to be instantiated.
- */
- private LdapUtils() {
- }
-
- /**
- * Get the first parameter in the argument list as a Name.
- *
- * @param args
- * arguments supplied to a ldap operation.
- * @return a Name representation of the first argument, or the Name itself
- * if it is a name.
- */
- public static Name getFirstArgumentAsName(Object[] args) {
- Assert.notEmpty(args);
-
- Object firstArg = args[0];
- return getArgumentAsName(firstArg);
- }
-
- /**
- * Get the argument as a Name.
- *
- * @param arg
- * an argument supplied to an Ldap operation.
- * @return a Name representation of the argument, or the Name itself if it
- * is a Name.
- */
- public static Name getArgumentAsName(Object arg) {
- if (arg instanceof String) {
- return new DistinguishedName((String) arg);
- } else if (arg instanceof Name) {
- return (Name) arg;
- } else {
- throw new IllegalArgumentException(
- "First argument needs to be a Name or a String representation thereof");
- }
- }
-
- /**
- * Close the supplied context, but only if it is not associated with the
- * current transaction.
- *
- * @param context
- * the DirContext to close.
- * @param contextSource
- * the ContextSource bound to the transaction.
- * @throws NamingException
- */
- public static void doCloseConnection(DirContext context,
- ContextSource contextSource) throws NamingException {
- DirContextHolder transactionContextHolder = (DirContextHolder) TransactionSynchronizationManager
- .getResource(contextSource);
- if (transactionContextHolder == null
- || transactionContextHolder.getCtx() != context) {
- log.debug("Closing context");
- // This is not the transactional context or the transaction is
- // no longer active - we should close it.
- context.close();
- } else {
- log.debug("Leaving transactional context open");
- }
- }
-
- /**
- * Check whether the supplied method is a method for which transactions is
- * supported (and which should be recorded for possible rollback later).
- *
- * @param methodName
- * name of the method to check.
- * @return 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));
-
- }
-
- /**
- * Perform the specified operation, storing the state prior to the
- * operation, to enable commit/rollback later.
- *
- * @param contextSource
- * the ContextSource we are operating on.
- * @param method
- * name of the method to be invoked.
- * @param args
- * arguments with which the operation is invoked.
- */
- public static void performOperation(ContextSource contextSource,
- Method method, Object[] args) throws Throwable {
- DirContextHolder transactionContextHolder = (DirContextHolder) TransactionSynchronizationManager
- .getResource(contextSource);
- if (transactionContextHolder != null) {
-
- CompensatingTransactionOperationManager transactionDataManager = transactionContextHolder
- .getTransactionDataManager();
- transactionDataManager.performOperation(method.getName(), args);
- } else {
- // Perform the target operation
- try {
- method.invoke(transactionContextHolder.getCtx(), args);
- } catch (InvocationTargetException e) {
- throw e.getTargetException();
- }
- }
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutor.java
deleted file mode 100644
index f8c4bcdb..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutor.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.Name;
-import javax.naming.directory.ModificationItem;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-
-/**
- * A {@link CompensatingTransactionOperationExecutor} to manage a
- * modifyAttributes operation. Performs a
- * modifyAttributes in {@link #performOperation()}, a negating
- * modifyAttributes in {@link #rollback()}, and nothing in {@link #commit()}.
- *
- * @author Mattias Arthursson
- */
-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 = actualModifications;
- this.compensatingModifications = compensatingModifications;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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);
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
- */
- public void commit() {
- log.debug("Nothing to do in commit for modifyAttributes");
- }
-
- /*
- * (non-Javadoc)
- *
- * @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;
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorder.java
deleted file mode 100644
index 24209663..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorder.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * 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.core;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import javax.naming.Name;
-import javax.naming.NamingException;
-import javax.naming.directory.Attribute;
-import javax.naming.directory.Attributes;
-import javax.naming.directory.BasicAttribute;
-import javax.naming.directory.DirContext;
-import javax.naming.directory.ModificationItem;
-
-import org.springframework.ldap.core.AttributesMapper;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-import org.springframework.util.Assert;
-
-/**
- * A {@link CompensatingTransactionOperationRecorder} keeping track of
- * modifyAttributes operations, creating corresponding
- * {@link ModifyAttributesOperationExecutor} instances for rollback.
- *
- * @author Mattias Arthursson
- */
-public class ModifyAttributesOperationRecorder implements
- CompensatingTransactionOperationRecorder {
-
- private LdapOperations ldapOperations;
-
- public ModifyAttributesOperationRecorder(LdapOperations ldapOperations) {
- this.ldapOperations = ldapOperations;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
- */
- public CompensatingTransactionOperationExecutor recordOperation(
- Object[] args) {
- Assert.notNull(args);
- Name dn = LdapUtils.getFirstArgumentAsName(args);
- if (args.length != 2 || !(args[1] instanceof ModificationItem[])) {
- throw new IllegalArgumentException(
- "Unexpected arguments to ModifyAttributes operation");
- }
-
- ModificationItem[] incomingModifications = (ModificationItem[]) args[1];
-
- Set set = new HashSet();
- for (int i = 0; i < incomingModifications.length; i++) {
- set.add(incomingModifications[i].getAttribute().getID());
- }
-
- // Get the current values of all referred Attributes.
- String[] attributeNameArray = (String[]) set.toArray(new String[set
- .size()]);
- Attributes currentAttributes = (Attributes) ldapOperations.lookup(dn,
- attributeNameArray, getAttributesMapper());
-
- // Get a compensating ModificationItem for each of the incoming
- // modification.
- ModificationItem[] rollbackItems = new ModificationItem[incomingModifications.length];
- for (int i = 0; i < incomingModifications.length; i++) {
- rollbackItems[i] = getCompensatingModificationItem(
- currentAttributes, incomingModifications[i]);
- }
-
- return new ModifyAttributesOperationExecutor(ldapOperations, dn,
- incomingModifications, rollbackItems);
- }
-
- /**
- * Get an {@link AttributesMapper} that just returns the supplied
- * Attributes.
- *
- * @return the {@link AttributesMapper} to use for getting the current
- * Attributes of the target DN.
- */
- AttributesMapper getAttributesMapper() {
- return new AttributesMapper() {
- public Object mapFromAttributes(Attributes attributes)
- throws NamingException {
- return attributes;
- }
- };
- }
-
- /**
- * Get a ModificationItem to use for rollback of the supplied modification.
- *
- * @param originalAttributes
- * All Attributes of the target DN that are affected of any of
- * the ModificationItems.
- * @param modificationItem
- * the ModificationItem to create a rollback item for.
- * @return A ModificationItem to use for rollback of the supplied
- * ModificationItem.
- */
- protected ModificationItem getCompensatingModificationItem(
- Attributes originalAttributes, ModificationItem modificationItem) {
- Attribute modificationAttribute = modificationItem.getAttribute();
- Attribute originalAttribute = originalAttributes
- .get(modificationAttribute.getID());
-
- if (modificationItem.getModificationOp() == DirContext.REMOVE_ATTRIBUTE) {
- if (modificationAttribute.size() == 0) {
- // If the modification attribute size it means that the
- // Attribute should be removed entirely - we should store a
- // ModificationItem to restore all present values for rollback.
- return new ModificationItem(DirContext.ADD_ATTRIBUTE,
- (Attribute) originalAttribute.clone());
- } else {
- // The rollback modification will be to re-add the removed
- // attribute values.
- return new ModificationItem(DirContext.ADD_ATTRIBUTE,
- (Attribute) modificationAttribute.clone());
- }
- } else if (modificationItem.getModificationOp() == DirContext.REPLACE_ATTRIBUTE) {
- if (originalAttribute != null) {
- return new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
- (Attribute) originalAttribute.clone());
- } else {
- // The attribute doesn't previously exist - the rollback
- // operation will be to remove the attribute.
- return new ModificationItem(DirContext.REMOVE_ATTRIBUTE,
- new BasicAttribute(modificationAttribute.getID()));
- }
- } else {
- // An ADD_ATTRIBUTE operation
- if (originalAttribute == null) {
- // The attribute doesn't previously exist - the rollback
- // operation will be to remove the attribute.
- return new ModificationItem(DirContext.REMOVE_ATTRIBUTE,
- new BasicAttribute(modificationAttribute.getID()));
- } else {
- // The attribute does exist before - we should store the
- // previous value and it should be used for replacing in
- // rollback.
- return new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
- (Attribute) originalAttribute.clone());
- }
- }
- }
-
- LdapOperations getLdapOperations() {
- return ldapOperations;
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationExecutor.java
deleted file mode 100644
index dd04d62e..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationExecutor.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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.core;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-
-/**
- * A {@link CompensatingTransactionOperationExecutor} that performs nothing.
- *
- * @author Mattias Arthursson
- */
-public class NullOperationExecutor implements
- CompensatingTransactionOperationExecutor {
-
- private static Log log = LogFactory.getLog(NullOperationExecutor.class);
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback()
- */
- public void rollback() {
- log.info("Rolling back null operation");
- }
-
- public void commit() {
- log.info("Committing back null operation");
- }
-
- public void performOperation() {
- log.info("Performing null operation");
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationRecorder.java
deleted file mode 100644
index 7e2f82ff..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/NullOperationRecorder.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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.core;
-
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationManager;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-
-/**
- * A {@link CompensatingTransactionOperationRecorder} performing nothing,
- * returning a {@link NullOperationExecutor} regardless of the input. Instances
- * of this class will be created if the
- * {@link CompensatingTransactionOperationManager} cannot determine any appropriate
- * {@link CompensatingTransactionOperationRecorder} for the current operation.
- *
- * @author Mattias Arthursson
- *
- */
-public class NullOperationRecorder implements
- CompensatingTransactionOperationRecorder {
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
- */
- public CompensatingTransactionOperationExecutor recordOperation(
- Object[] args) {
- return new NullOperationExecutor();
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationExecutor.java
deleted file mode 100644
index 1f105a4d..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationExecutor.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.Name;
-import javax.naming.directory.Attributes;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-
-/**
- * A {@link CompensatingTransactionOperationExecutor} to manage a rebind
- * operation. The methods in this class do not behave as expected, since it
- * might be impossible to retrieve all the original attributes from the entry.
- * Instead this class performs a rename in {@link #performOperation()},
- * a negating rename in {@link #rollback()}, and the {@link #commit()}
- * operation unbinds the original entry from its temporary location and binds a
- * new entry to the original location using the attributes supplied to the
- * original rebind opertaion.
- *
- * @author Mattias Arthursson
- */
-public class RebindOperationExecutor implements
- CompensatingTransactionOperationExecutor {
-
- private static Log log = LogFactory.getLog(RebindOperationExecutor.class);
-
- private LdapOperations ldapOperations;
-
- private Name originalDn;
-
- private Name temporaryDn;
-
- private Object originalObject;
-
- private Attributes originalAttributes;
-
- /**
- * Constructor.
- *
- * @param ldapOperations
- * the {@link LdapOperations} to use to perform the rollback.
- * @param originalDn
- * The original DN of the entry to bind.
- * @param temporaryDn
- * The temporary DN of the entry.
- * @param originalObject
- * Original 'object' parameter sent to the rebind operation.
- * @param originalAttributes
- * Original 'attributes' parameter sent to the rebind operation
- */
- public RebindOperationExecutor(LdapOperations ldapOperations,
- Name originalDn, Name temporaryDn, Object originalObject,
- Attributes originalAttributes) {
- this.ldapOperations = ldapOperations;
- this.originalDn = originalDn;
- this.temporaryDn = temporaryDn;
- this.originalObject = originalObject;
- this.originalAttributes = originalAttributes;
- }
-
- /**
- * Get the LdapOperations. Package private for testing purposes.
- *
- * @return the LdapOperations.
- */
- LdapOperations getLdapOperations() {
- return ldapOperations;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback()
- */
- public void rollback() {
- log.debug("Rolling back rebind operation");
- try {
- ldapOperations.unbind(originalDn);
- ldapOperations.rename(temporaryDn, originalDn);
- } catch (Exception e) {
- log.warn("Failed to rollback operation, dn: " + originalDn
- + "; temporary DN: " + temporaryDn, e);
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
- */
- public void commit() {
- log.debug("Committing rebind operation");
- ldapOperations.unbind(temporaryDn);
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#performOperation()
- */
- public void performOperation() {
- log.debug("Performing rebind operation - "
- + "renaming original entry and "
- + "binding new contents to entry.");
- ldapOperations.rename(originalDn, temporaryDn);
- ldapOperations.bind(originalDn, originalObject, originalAttributes);
- }
-
- Attributes getOriginalAttributes() {
- return originalAttributes;
- }
-
- Name getOriginalDn() {
- return originalDn;
- }
-
- Object getOriginalObject() {
- return originalObject;
- }
-
- Name getTemporaryDn() {
- return temporaryDn;
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationRecorder.java
deleted file mode 100644
index 709974c6..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RebindOperationRecorder.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.Name;
-import javax.naming.directory.Attributes;
-
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-
-/**
- * A {@link CompensatingTransactionOperationRecorder} keeping track of a rebind
- * operation. Creates {@link RebindOperationExecutor} objects in
- * {@link #recordOperation(Object[])}.
- *
- * @author Mattias Arthursson
- */
-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 the
- * {@link TempEntryRenamingStrategy} to use for generating temp
- * DNs.
- */
- public RebindOperationRecorder(LdapOperations ldapOperations,
- TempEntryRenamingStrategy renamingStrategy) {
- this.ldapOperations = ldapOperations;
- this.renamingStrategy = renamingStrategy;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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 = LdapUtils.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;
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationExecutor.java
deleted file mode 100644
index af14b3f7..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationExecutor.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * 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.core;
-
-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.ldap.transaction.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 Arthursson
- *
- */
-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;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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);
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
- */
- public void commit() {
- log.debug("Nothing to do in commit for rename operation");
- }
-
- /*
- * (non-Javadoc)
- *
- * @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;
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationRecorder.java
deleted file mode 100644
index fa8ccbf4..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/RenameOperationRecorder.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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.core;
-
-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.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-import org.springframework.util.Assert;
-
-/**
- * A {@link CompensatingTransactionOperationRecorder} for keeping track of
- * rename operations. Creates {@link RebindOperationExecutor} objects for
- * rolling back.
- *
- * @author Mattias Arthursson
- *
- */
-public class RenameOperationRecorder implements
- CompensatingTransactionOperationRecorder {
-
- private static Log log = LogFactory.getLog(RenameOperationRecorder.class);
-
- private LdapOperations ldapOperations;
-
- /**
- * Constructor.
- *
- * @param ldapOperations
- * The {@link LdapOperations} to supply to the created
- * {@link RebindOperationExecutor} objects.
- */
- public RenameOperationRecorder(LdapOperations ldapOperations) {
- this.ldapOperations = ldapOperations;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
- */
- public CompensatingTransactionOperationExecutor recordOperation(
- Object[] args) {
- log.debug("Storing rollback information for rename operation");
- Assert.notEmpty(args);
- if (args.length != 2) {
- // This really shouldn't happen.
- throw new IllegalArgumentException("Illegal argument length");
- }
- Name oldDn = LdapUtils.getArgumentAsName(args[0]);
- Name newDn = LdapUtils.getArgumentAsName(args[1]);
- return new RenameOperationExecutor(ldapOperations, oldDn, newDn);
- }
-
- LdapOperations getLdapOperations() {
- return ldapOperations;
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TempEntryRenamingStrategy.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/TempEntryRenamingStrategy.java
deleted file mode 100644
index 869378f8..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TempEntryRenamingStrategy.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.Name;
-
-/**
- * Interface for different strategies to rename temporary entries for unbind and
- * rebind operations.
- *
- * @author Mattias Arthursson
- */
-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.
- */
- public Name getTemporaryName(Name originalName);
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareContextSourceProxy.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareContextSourceProxy.java
deleted file mode 100644
index 283810ff..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareContextSourceProxy.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * 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.core;
-
-import java.lang.reflect.Proxy;
-
-import javax.naming.directory.DirContext;
-
-import org.springframework.dao.DataAccessException;
-import org.springframework.ldap.core.ContextSource;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
-
-/**
- * A proxy for ContextSource to make sure that the returned DirContext objects
- * are aware of the surrounding transactions, making sure that the DirContext is
- * not closed during the transaction and that all modifying operations are
- * recorded, keeping track of the corresponding rollback operations. All
- * returned DirContext instances will be of the type
- * {@link TransactionAwareDirContextInvocationHandler}.
- *
- * @author Mattias Arthursson
- */
-public class TransactionAwareContextSourceProxy implements ContextSource {
- private ContextSource target;
-
- /**
- * Constructor.
- *
- * @param target
- * the target ContextSource.
- */
- public TransactionAwareContextSourceProxy(ContextSource target) {
- this.target = target;
- }
-
- /**
- * Get the target ContextSource.
- *
- * @return the target ContextSource.
- */
- public ContextSource getTarget() {
- return target;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.core.ContextSource#getReadOnlyContext()
- */
- public DirContext getReadOnlyContext() throws DataAccessException {
- return getReadWriteContext();
- }
-
- private DirContext getTransactionAwareDirContextProxy(DirContext context,
- ContextSource target) {
- return (DirContext) Proxy
- .newProxyInstance(DirContextProxy.class.getClassLoader(),
- new Class[] { DirContextProxy.class },
- new TransactionAwareDirContextInvocationHandler(
- context, target));
-
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.core.ContextSource#getReadWriteContext()
- */
- public DirContext getReadWriteContext() throws DataAccessException {
- DirContextHolder contextHolder = (DirContextHolder) TransactionSynchronizationManager
- .getResource(target);
- DirContext ctx = null;
-
- if (contextHolder != null) {
- ctx = contextHolder.getCtx();
- }
-
- if (ctx == null) {
- ctx = target.getReadWriteContext();
- if (contextHolder != null) {
- contextHolder.setCtx(ctx);
- }
- }
- return getTransactionAwareDirContextProxy(ctx, target);
- }
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareDirContextInvocationHandler.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareDirContextInvocationHandler.java
deleted file mode 100644
index bbad4ac8..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/TransactionAwareDirContextInvocationHandler.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * 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.core;
-
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import javax.naming.directory.DirContext;
-
-import org.springframework.ldap.core.ContextSource;
-
-/**
- * Proxy implementation for DirContext, making sure that the instance is not
- * closed during a transaction, and that all modifying operations are recorded,
- * storing compensating rollback operations for them.
- *
- * @author Mattias Arthursson
- */
-public class TransactionAwareDirContextInvocationHandler implements
- InvocationHandler {
-
- private DirContext target;
-
- private ContextSource contextSource;
-
- /**
- * Constructor.
- *
- * @param target
- * The target DirContext.
- * @param contextSource
- * The transactional ContextSource, needed to get hold of the
- * current transaction's {@link DirContextHolder}.
- */
- public TransactionAwareDirContextInvocationHandler(DirContext target,
- ContextSource contextSource) {
- this.target = target;
- this.contextSource = contextSource;
- }
-
- /*
- * (non-Javadoc)
- *
- * @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")) {
- LdapUtils.doCloseConnection(target, contextSource);
- return null;
- } else if (LdapUtils.isSupportedWriteTransactionOperation(methodName)) {
- // Store transaction data and allow operation to proceed.
- LdapUtils.performOperation(contextSource, method, args);
- return null;
- } else {
- try {
- return method.invoke(target, args);
- } catch (InvocationTargetException e) {
- throw e.getTargetException();
- }
- }
- }
-}
\ No newline at end of file
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationExecutor.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationExecutor.java
deleted file mode 100644
index d47f1127..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationExecutor.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * 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.core;
-
-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.ldap.transaction.CompensatingTransactionOperationExecutor;
-
-/**
- * A {@link CompensatingTransactionOperationExecutor} to manage an unbind
- * operation. The methods in this class do not behave as expected, since it
- * might be impossible to retrieve all the original attributes from the entry.
- * Instead this class performs a rename in {@link #performOperation()},
- * a negating rename in {@link #rollback()}, and {@link #commit()} unbinds the
- * entry from its temporary location.
- *
- * @author Mattias Arthursson
- */
-public class UnbindOperationExecutor implements
- CompensatingTransactionOperationExecutor {
-
- private static Log log = LogFactory.getLog(UnbindOperationExecutor.class);
-
- private LdapOperations ldapOperations;
-
- private Name originalDn;
-
- private Name temporaryDn;
-
- /**
- * Constructor.
- *
- * @param ldapOperations
- * The {@link LdapOperations} to use for performing the rollback
- * operation.
- * @param originalDn
- * The original DN of the entry to be removed.
- * @param temporaryDn
- * Temporary DN of the entry to be removed; this is where the
- * entry is temporarily stored during the transaction.
- */
- public UnbindOperationExecutor(LdapOperations ldapOperations,
- Name originalDn, Name temporaryDn) {
- this.ldapOperations = ldapOperations;
- this.originalDn = originalDn;
- this.temporaryDn = temporaryDn;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#rollback()
- */
- public void rollback() {
- try {
- ldapOperations.rename(temporaryDn, originalDn);
- } catch (Exception e) {
- log.warn("Filed to rollback unbind operation, temporaryDn: "
- + temporaryDn + "; originalDn: " + originalDn);
- }
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
- */
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#commit()
- */
- public void commit() {
- log.debug("Committing unbind operation - unbinding temporary entry");
- ldapOperations.unbind(temporaryDn);
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationExecutor#performOperation()
- */
- public void performOperation() {
- log.debug("Performing operation for unbind -"
- + " renaming to temporary entry.");
- ldapOperations.rename(originalDn, temporaryDn);
- }
-
- LdapOperations getLdapOperations() {
- return ldapOperations;
- }
-
- Name getOriginalDn() {
- return originalDn;
- }
-
- Name getTemporaryDn() {
- return temporaryDn;
- }
-
-}
diff --git a/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationRecorder.java b/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationRecorder.java
deleted file mode 100644
index 084b20fa..00000000
--- a/sandbox/src/main/java/org/springframework/ldap/transaction/core/UnbindOperationRecorder.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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.core;
-
-import javax.naming.Name;
-
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-
-/**
- * {@link CompensatingTransactionOperationRecorder} to keep track of unbind
- * operations. This class creates {@link UnbindOperationExecutor} objects for
- * rollback.
- *
- * @author Mattias Arthursson
- */
-public class UnbindOperationRecorder implements
- CompensatingTransactionOperationRecorder {
-
- private LdapOperations ldapOperations;
-
- private TempEntryRenamingStrategy renamingStrategy;
-
- /**
- * Constructor.
- *
- * @param ldapOperations
- * {@link LdapOperations} to use for getting the data prior to
- * unbinding the entry and to supply to the
- * {@link UnbindOperationExecutor} for rollback.
- * @param renamingStrategy
- * the {@link TempEntryRenamingStrategy} to use when generating
- * DNs for temporary entries.
- */
- public UnbindOperationRecorder(LdapOperations ldapOperations,
- TempEntryRenamingStrategy renamingStrategy) {
- this.ldapOperations = ldapOperations;
- this.renamingStrategy = renamingStrategy;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.springframework.ldap.support.transaction.CompensatingTransactionOperationRecorder#recordOperation(java.lang.Object[])
- */
- public CompensatingTransactionOperationExecutor recordOperation(
- Object[] args) {
- Name dn = LdapUtils.getFirstArgumentAsName(args);
- Name temporaryDn = renamingStrategy.getTemporaryName(dn);
-
- return new UnbindOperationExecutor(ldapOperations, dn, temporaryDn);
- }
-
- LdapOperations getLdapOperations() {
- return ldapOperations;
- }
-
- public TempEntryRenamingStrategy getRenamingStrategy() {
- return renamingStrategy;
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManagerTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManagerTest.java
deleted file mode 100644
index f22ca6f3..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/DefaultCompensatingTransactionOperationManagerTest.java
+++ /dev/null
@@ -1,116 +0,0 @@
-package org.springframework.ldap.transaction;
-
-import java.util.Stack;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationFactory;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-import org.springframework.ldap.transaction.DefaultCompensatingTransactionOperationManager;
-
-public class DefaultCompensatingTransactionOperationManagerTest extends
- TestCase {
-
- private MockControl operationExecutorControl;
-
- private CompensatingTransactionOperationExecutor operationExecutorMock;
-
- private MockControl operationFactoryControl;
-
- private CompensatingTransactionOperationFactory operationFactoryMock;
-
- private MockControl operationRecorderControl;
-
- private CompensatingTransactionOperationRecorder operationRecorderMock;
-
- protected void setUp() throws Exception {
- super.setUp();
- operationExecutorControl = MockControl
- .createControl(CompensatingTransactionOperationExecutor.class);
- operationExecutorMock = (CompensatingTransactionOperationExecutor) operationExecutorControl
- .getMock();
-
- operationFactoryControl = MockControl
- .createControl(CompensatingTransactionOperationFactory.class);
- operationFactoryMock = (CompensatingTransactionOperationFactory) operationFactoryControl
- .getMock();
-
- operationRecorderControl = MockControl
- .createControl(CompensatingTransactionOperationRecorder.class);
- operationRecorderMock = (CompensatingTransactionOperationRecorder) operationRecorderControl
- .getMock();
-
- }
-
- protected void tearDown() throws Exception {
- super.tearDown();
- operationExecutorControl = null;
- operationExecutorMock = null;
-
- operationFactoryControl = null;
- operationFactoryMock = null;
-
- operationRecorderControl = null;
- operationRecorderMock = null;
- }
-
- protected void replay() {
- operationExecutorControl.replay();
- operationFactoryControl.replay();
- operationRecorderControl.replay();
- }
-
- protected void verify() {
- operationExecutorControl.verify();
- operationFactoryControl.verify();
- operationRecorderControl.verify();
- }
-
- public void testPerformOperation() {
- Object[] expectedArgs = new Object[0];
-
- operationFactoryControl
- .expectAndReturn(operationFactoryMock
- .createRecordingOperation("some method"),
- operationRecorderMock);
- operationRecorderControl.expectAndReturn(operationRecorderMock
- .recordOperation(expectedArgs), operationExecutorMock);
- operationExecutorMock.performOperation();
-
- DefaultCompensatingTransactionOperationManager tested = new DefaultCompensatingTransactionOperationManager(
- operationFactoryMock);
- replay();
- tested.performOperation("some method", expectedArgs);
- verify();
-
- Stack result = tested.getRollbackOperations();
- assertFalse(result.isEmpty());
- assertSame(operationExecutorMock, result.peek());
- }
-
- public void testRollback() {
- DefaultCompensatingTransactionOperationManager tested = new DefaultCompensatingTransactionOperationManager(
- operationFactoryMock);
- tested.getRollbackOperations().push(operationExecutorMock);
-
- operationExecutorMock.rollback();
-
- replay();
- tested.rollback();
- verify();
- }
-
- public void testCommit() {
- DefaultCompensatingTransactionOperationManager tested = new DefaultCompensatingTransactionOperationManager(
- operationFactoryMock);
- tested.getRollbackOperations().push(operationExecutorMock);
-
- operationExecutorMock.commit();
-
- replay();
- tested.commit();
- verify();
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationExecutorTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationExecutorTest.java
deleted file mode 100644
index 466ee492..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationExecutorTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.directory.BasicAttributes;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.core.BindOperationExecutor;
-
-public class BindOperationExecutorTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testPerformOperation() {
- DistinguishedName expectedDn = new DistinguishedName("cn=john doe");
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- BindOperationExecutor tested = new BindOperationExecutor(
- ldapOperationsMock, expectedDn, expectedObject,
- expectedAttributes);
-
- ldapOperationsMock.bind(expectedDn, expectedObject, expectedAttributes);
-
- replay();
- // perform teste
- tested.performOperation();
- verify();
- }
-
- public void testCommit() {
- DistinguishedName expectedDn = new DistinguishedName("cn=john doe");
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- BindOperationExecutor tested = new BindOperationExecutor(
- ldapOperationsMock, expectedDn, expectedObject,
- expectedAttributes);
-
- // Nothing to do here.
-
- replay();
- // perform teste
- tested.commit();
- verify();
- }
-
- public void testRollback() {
- DistinguishedName expectedDn = new DistinguishedName("cn=john doe");
- BindOperationExecutor tested = new BindOperationExecutor(
- ldapOperationsMock, expectedDn, null, null);
-
- ldapOperationsMock.unbind(expectedDn);
-
- replay();
- // perform teste
- tested.rollback();
- verify();
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationRecorderTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationRecorderTest.java
deleted file mode 100644
index 8db3074e..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/BindOperationRecorderTest.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.directory.BasicAttributes;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.core.BindOperationExecutor;
-import org.springframework.ldap.transaction.core.BindOperationRecorder;
-
-public class BindOperationRecorderTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- public void testRecordOperation_DistinguishedName() {
- BindOperationRecorder tested = new BindOperationRecorder(
- ldapOperationsMock);
- DistinguishedName expectedDn = new DistinguishedName("cn=John Doe");
-
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- // Perform test.
- CompensatingTransactionOperationExecutor operation = tested
- .recordOperation(new Object[] { expectedDn, expectedObject,
- expectedAttributes });
-
- assertTrue(operation instanceof BindOperationExecutor);
- BindOperationExecutor rollbackOperation = (BindOperationExecutor) operation;
- assertSame(expectedDn, rollbackOperation.getDn());
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- assertSame(expectedObject, rollbackOperation.getOriginalObject());
- assertSame(expectedAttributes, rollbackOperation
- .getOriginalAttributes());
- }
-
- public void testPerformOperation_String() {
- BindOperationRecorder tested = new BindOperationRecorder(
- ldapOperationsMock);
- String expectedDn = "cn=John Doe";
-
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- // Perform test.
- CompensatingTransactionOperationExecutor operation = tested
- .recordOperation(new Object[] { expectedDn, expectedObject,
- expectedAttributes });
-
- assertTrue(operation instanceof BindOperationExecutor);
- BindOperationExecutor rollbackOperation = (BindOperationExecutor) operation;
- assertEquals(expectedDn, rollbackOperation.getDn().toString());
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- }
-
- public void testPerformOperation_Invalid() {
- BindOperationRecorder tested = new BindOperationRecorder(
- ldapOperationsMock);
- Object expectedDn = new Object();
-
- try {
- // Perform test.
- tested.recordOperation(new Object[] { expectedDn });
- fail("IllegalArgumentException expected");
- } catch (IllegalArgumentException expected) {
- assertTrue(true);
- }
-
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerTest.java
deleted file mode 100644
index 8846f12f..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ContextSourceTransactionManagerTest.java
+++ /dev/null
@@ -1,187 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.directory.DirContext;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.ContextSource;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationManager;
-import org.springframework.ldap.transaction.core.ContextSourceTransactionManager;
-import org.springframework.ldap.transaction.core.ContextSourceTransactionObject;
-import org.springframework.ldap.transaction.core.DirContextHolder;
-import org.springframework.ldap.transaction.core.TempEntryRenamingStrategy;
-import org.springframework.ldap.transaction.core.TransactionAwareContextSourceProxy;
-import org.springframework.transaction.TransactionDefinition;
-import org.springframework.transaction.support.DefaultTransactionStatus;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
-
-public class ContextSourceTransactionManagerTest extends TestCase {
-
- private MockControl contextSourceControl;
-
- private ContextSource contextSourceMock;
-
- private MockControl contextControl;
-
- private DirContext contextMock;
-
- private ContextSourceTransactionManager tested;
-
- private MockControl transactionDefinitionControl;
-
- private MockControl transactionDataManagerControl;
-
- private CompensatingTransactionOperationManager transactionDataManagerMock;
-
- private TransactionDefinition transactionDefinitionMock;
-
- private MockControl renamingStrategyControl;
-
- private TempEntryRenamingStrategy renamingStrategyMock;
-
- protected void setUp() throws Exception {
- super.setUp();
- if (TransactionSynchronizationManager.isSynchronizationActive()) {
- TransactionSynchronizationManager.clearSynchronization();
- }
-
- contextSourceControl = MockControl.createControl(ContextSource.class);
- contextSourceMock = (ContextSource) contextSourceControl.getMock();
-
- contextControl = MockControl.createControl(DirContext.class);
- contextMock = (DirContext) contextControl.getMock();
-
- transactionDefinitionControl = MockControl
- .createControl(TransactionDefinition.class);
- transactionDefinitionMock = (TransactionDefinition) transactionDefinitionControl
- .getMock();
-
- transactionDataManagerControl = MockControl
- .createControl(CompensatingTransactionOperationManager.class);
- transactionDataManagerMock = (CompensatingTransactionOperationManager) transactionDataManagerControl
- .getMock();
-
- renamingStrategyControl = MockControl
- .createControl(TempEntryRenamingStrategy.class);
- renamingStrategyMock = (TempEntryRenamingStrategy) renamingStrategyControl
- .getMock();
-
- tested = new ContextSourceTransactionManager();
- tested.setContextSource(contextSourceMock);
- tested.setRenamingStrategy(renamingStrategyMock);
- }
-
- protected void tearDown() throws Exception {
- super.tearDown();
-
- contextControl = null;
- contextMock = null;
-
- contextSourceControl = null;
- contextSourceMock = null;
-
- transactionDefinitionControl = null;
- transactionDefinitionMock = null;
-
- transactionDataManagerControl = null;
- transactionDataManagerMock = null;
-
- renamingStrategyControl = null;
- renamingStrategyMock = null;
-
- if (TransactionSynchronizationManager.isSynchronizationActive()) {
- TransactionSynchronizationManager.clearSynchronization();
- }
- }
-
- public void testDoGetTransaction() {
- Object result = tested.doGetTransaction();
-
- assertNotNull(result);
- assertTrue(result instanceof ContextSourceTransactionObject);
- ContextSourceTransactionObject transactionObject = (ContextSourceTransactionObject) result;
- assertNull(transactionObject.getContextHolder());
- }
-
- public void testDoGetTransactionTransactionActive() {
- DirContextHolder expectedContextHolder = new DirContextHolder(null,
- null);
- TransactionSynchronizationManager.bindResource(contextSourceMock,
- expectedContextHolder);
- Object result = tested.doGetTransaction();
- assertSame(expectedContextHolder,
- ((ContextSourceTransactionObject) result).getContextHolder());
- }
-
- public void testDoBegin() {
- contextSourceControl.expectAndReturn(contextSourceMock
- .getReadOnlyContext(), contextMock);
-
- contextSourceControl.replay();
-
- ContextSourceTransactionObject expectedTransactionObject = new ContextSourceTransactionObject(
- null);
- tested.doBegin(expectedTransactionObject, transactionDefinitionMock);
-
- contextSourceControl.verify();
-
- DirContextHolder foundContextHolder = (DirContextHolder) TransactionSynchronizationManager
- .getResource(contextSourceMock);
- assertSame(contextMock, foundContextHolder.getCtx());
- assertSame(renamingStrategyMock, foundContextHolder
- .getRenamingStrategy());
- }
-
- public void testDoCommit() {
- }
-
- public void testDoRollback() {
-
- DirContextHolder expectedContextHolder = new DirContextHolder(
- contextMock, renamingStrategyMock);
- expectedContextHolder
- .setTransactionDataManager(transactionDataManagerMock);
- TransactionSynchronizationManager.bindResource(contextSourceMock,
- expectedContextHolder);
-
- transactionDataManagerMock.rollback();
- transactionDataManagerControl.replay();
- ContextSourceTransactionObject transactionObject = new ContextSourceTransactionObject(
- null);
- transactionObject.setContextHolder(expectedContextHolder);
- tested.doRollback(new DefaultTransactionStatus(transactionObject,
- false, false, false, false, null));
- transactionDataManagerControl.verify();
- }
-
- public void testDoCleanupAfterCompletion() throws Exception {
- DirContextHolder expectedContextHolder = new DirContextHolder(
- contextMock, renamingStrategyMock);
- TransactionSynchronizationManager.bindResource(contextSourceMock,
- expectedContextHolder);
-
- contextMock.close();
- contextControl.replay();
-
- tested.doCleanupAfterCompletion(new ContextSourceTransactionObject(
- expectedContextHolder));
-
- contextControl.verify();
- assertNull(TransactionSynchronizationManager
- .getResource(contextSourceMock));
- assertNull(expectedContextHolder.getTransactionDataManager());
- }
-
- public void testSetContextSource_Proxy() {
- TransactionAwareContextSourceProxy proxy = new TransactionAwareContextSourceProxy(
- contextSourceMock);
-
- // Perform test
- tested.setContextSource(proxy);
- ContextSource result = tested.getContextSource();
-
- // Verify result
- assertSame(contextSourceMock, result);
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategyTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategyTest.java
deleted file mode 100644
index 934c6d6d..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/DefaultTempEntryRenamingStrategyTest.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.Name;
-
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.transaction.core.DefaultTempEntryRenamingStrategy;
-
-import junit.framework.TestCase;
-
-public class DefaultTempEntryRenamingStrategyTest extends TestCase {
-
- public void testGetTemporaryName() {
- DistinguishedName expectedOriginalName = new DistinguishedName(
- "cn=john doe, ou=somecompany, c=SE");
- DefaultTempEntryRenamingStrategy tested = new DefaultTempEntryRenamingStrategy();
-
- Name result = tested.getTemporaryName(expectedOriginalName);
- assertEquals("cn=john doe_temp, ou=somecompany, c=SE", result
- .toString());
- assertNotSame(expectedOriginalName, result);
- }
-
- public void testGetTemporaryDN_MultivalueDN() {
- DistinguishedName expectedOriginalName = new DistinguishedName(
- "cn=john doe+sn=doe, ou=somecompany, c=SE");
- DefaultTempEntryRenamingStrategy tested = new DefaultTempEntryRenamingStrategy();
-
- Name result = tested.getTemporaryName(expectedOriginalName);
- assertEquals("cn=john doe_temp+sn=doe, ou=somecompany, c=SE", result
- .toString());
- }
-
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategyTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategyTest.java
deleted file mode 100644
index 8e946c1f..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/DifferentSubtreeTempEntryRenamingStrategyTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.Name;
-
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.transaction.core.DifferentSubtreeTempEntryRenamingStrategy;
-
-import junit.framework.TestCase;
-
-public class DifferentSubtreeTempEntryRenamingStrategyTest extends TestCase {
-
- public void testGetTemporaryName() {
- DistinguishedName originalName = new DistinguishedName(
- "cn=john doe, ou=somecompany, c=SE");
- DifferentSubtreeTempEntryRenamingStrategy tested = new DifferentSubtreeTempEntryRenamingStrategy(
- new DistinguishedName("ou=tempEntries"));
-
- int nextSequenceNo = tested.getNextSequenceNo();
-
- // Perform test
- Name result = tested.getTemporaryName(originalName);
-
- // Verify result
- assertEquals("cn=john doe" + nextSequenceNo + ", ou=tempEntries",
- result.toString());
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactoryTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactoryTest.java
deleted file mode 100644
index e90d0626..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/LdapCompensatingTransactionOperationFactoryTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationRecorder;
-import org.springframework.ldap.transaction.core.BindOperationRecorder;
-import org.springframework.ldap.transaction.core.LdapCompensatingTransactionOperationFactory;
-import org.springframework.ldap.transaction.core.ModifyAttributesOperationRecorder;
-import org.springframework.ldap.transaction.core.RebindOperationRecorder;
-import org.springframework.ldap.transaction.core.RenameOperationRecorder;
-import org.springframework.ldap.transaction.core.TempEntryRenamingStrategy;
-import org.springframework.ldap.transaction.core.UnbindOperationRecorder;
-
-public class LdapCompensatingTransactionOperationFactoryTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- private MockControl renamingStrategyControl;
-
- private TempEntryRenamingStrategy renamingStrategyMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- renamingStrategyControl = MockControl
- .createControl(TempEntryRenamingStrategy.class);
- renamingStrategyMock = (TempEntryRenamingStrategy) renamingStrategyControl
- .getMock();
-
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
-
- renamingStrategyControl = null;
- renamingStrategyMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- renamingStrategyControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- renamingStrategyControl.verify();
- }
-
- public void testGetRecordingOperation_Bind() throws Exception {
- LdapCompensatingTransactionOperationFactory tested = new LdapCompensatingTransactionOperationFactory(
- null, renamingStrategyMock);
- tested.setLdapOperations(ldapOperationsMock);
-
- CompensatingTransactionOperationRecorder result = tested
- .createRecordingOperation("bind");
- assertTrue(result instanceof BindOperationRecorder);
- BindOperationRecorder bindOperationRecorder = (BindOperationRecorder) result;
- assertSame(ldapOperationsMock, bindOperationRecorder
- .getLdapOperations());
- }
-
- public void testGetRecordingOperation_Rebind() throws Exception {
- LdapCompensatingTransactionOperationFactory tested = new LdapCompensatingTransactionOperationFactory(
- null, renamingStrategyMock);
- tested.setLdapOperations(ldapOperationsMock);
-
- CompensatingTransactionOperationRecorder result = tested
- .createRecordingOperation("rebind");
- assertTrue(result instanceof RebindOperationRecorder);
- RebindOperationRecorder rebindOperationRecorder = (RebindOperationRecorder) result;
- assertSame(ldapOperationsMock, rebindOperationRecorder
- .getLdapOperations());
- assertSame(renamingStrategyMock, rebindOperationRecorder
- .getRenamingStrategy());
- }
-
- public void testGetRecordingOperation_Rename() throws Exception {
- LdapCompensatingTransactionOperationFactory tested = new LdapCompensatingTransactionOperationFactory(
- null, renamingStrategyMock);
- tested.setLdapOperations(ldapOperationsMock);
-
- CompensatingTransactionOperationRecorder result = tested
- .createRecordingOperation("rename");
- assertTrue(result instanceof RenameOperationRecorder);
- RenameOperationRecorder recordingOperation = (RenameOperationRecorder) result;
- assertSame(ldapOperationsMock, recordingOperation.getLdapOperations());
- }
-
- public void testGetRecordingOperation_ModifyAttributes() throws Exception {
- LdapCompensatingTransactionOperationFactory tested = new LdapCompensatingTransactionOperationFactory(
- null, renamingStrategyMock);
- tested.setLdapOperations(ldapOperationsMock);
-
- CompensatingTransactionOperationRecorder result = tested
- .createRecordingOperation("modifyAttributes");
- assertTrue(result instanceof ModifyAttributesOperationRecorder);
- ModifyAttributesOperationRecorder recordingOperation = (ModifyAttributesOperationRecorder) result;
- assertSame(ldapOperationsMock, recordingOperation.getLdapOperations());
- }
-
- public void testGetRecordingOperation_Unbind() throws Exception {
- LdapCompensatingTransactionOperationFactory tested = new LdapCompensatingTransactionOperationFactory(
- null, renamingStrategyMock);
- tested.setLdapOperations(ldapOperationsMock);
-
- CompensatingTransactionOperationRecorder result = tested
- .createRecordingOperation("unbind");
- assertTrue(result instanceof UnbindOperationRecorder);
- UnbindOperationRecorder recordingOperation = (UnbindOperationRecorder) result;
- assertSame(ldapOperationsMock, recordingOperation.getLdapOperations());
- assertSame(renamingStrategyMock, recordingOperation
- .getRenamingStrategy());
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutorTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutorTest.java
deleted file mode 100644
index f57c52a9..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationExecutorTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.Name;
-import javax.naming.directory.ModificationItem;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.core.ModifyAttributesOperationExecutor;
-
-import junit.framework.TestCase;
-
-public class ModifyAttributesOperationExecutorTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testPerformOperation() {
- ModificationItem[] expectedCompensatingItems = new ModificationItem[0];
- ModificationItem[] expectedActualItems = new ModificationItem[0];
-
- Name expectedDn = new DistinguishedName("cn=john doe");
-
- ModifyAttributesOperationExecutor tested = new ModifyAttributesOperationExecutor(
- ldapOperationsMock, expectedDn, expectedActualItems,
- expectedCompensatingItems);
-
- ldapOperationsMock.modifyAttributes(expectedDn, expectedActualItems);
-
- replay();
- // Perform test
- tested.performOperation();
-
- verify();
- }
-
- public void testCommit() {
- ModificationItem[] expectedCompensatingItems = new ModificationItem[0];
- ModificationItem[] expectedActualItems = new ModificationItem[0];
-
- Name expectedDn = new DistinguishedName("cn=john doe");
-
- ModifyAttributesOperationExecutor tested = new ModifyAttributesOperationExecutor(
- ldapOperationsMock, expectedDn, expectedActualItems,
- expectedCompensatingItems);
-
- // No operation here
-
- replay();
- // Perform test
- tested.commit();
-
- verify();
- }
-
- public void testRollback() {
- ModificationItem[] expectedCompensatingItems = new ModificationItem[0];
- ModificationItem[] expectedActualItems = new ModificationItem[0];
-
- Name expectedDn = new DistinguishedName("cn=john doe");
-
- ModifyAttributesOperationExecutor tested = new ModifyAttributesOperationExecutor(
- ldapOperationsMock, expectedDn, expectedActualItems,
- expectedCompensatingItems);
-
- ldapOperationsMock.modifyAttributes(expectedDn,
- expectedCompensatingItems);
-
- replay();
- // Perform test
- tested.rollback();
-
- verify();
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorderTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorderTest.java
deleted file mode 100644
index f9f4b1af..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/ModifyAttributesOperationRecorderTest.java
+++ /dev/null
@@ -1,256 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-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 junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.AttributesMapper;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.core.ModifyAttributesOperationExecutor;
-import org.springframework.ldap.transaction.core.ModifyAttributesOperationRecorder;
-
-public class ModifyAttributesOperationRecorderTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- private MockControl attributesMapperControl;
-
- private AttributesMapper attributesMapperMock;
-
- private ModifyAttributesOperationRecorder tested;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- attributesMapperControl = MockControl
- .createControl(AttributesMapper.class);
- attributesMapperMock = (AttributesMapper) attributesMapperControl
- .getMock();
-
- tested = new ModifyAttributesOperationRecorder(ldapOperationsMock);
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
-
- attributesMapperControl = null;
- attributesMapperMock = null;
-
- tested = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- attributesMapperControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- attributesMapperControl.verify();
- }
-
- public void testRecordOperation() {
- final ModificationItem incomingItem = new ModificationItem(
- DirContext.ADD_ATTRIBUTE, new BasicAttribute("attribute1"));
- ModificationItem[] incomingMods = new ModificationItem[] { incomingItem };
- final ModificationItem compensatingItem = new ModificationItem(
- DirContext.ADD_ATTRIBUTE, new BasicAttribute("attribute2"));
-
- final Attributes expectedAttributes = new BasicAttributes();
-
- tested = new ModifyAttributesOperationRecorder(ldapOperationsMock) {
- AttributesMapper getAttributesMapper() {
- return attributesMapperMock;
- }
-
- protected ModificationItem getCompensatingModificationItem(
- Attributes originalAttributes,
- ModificationItem modificationItem) {
- assertSame(expectedAttributes, originalAttributes);
- assertSame(incomingItem, modificationItem);
- return compensatingItem;
- }
- };
-
- DistinguishedName expectedName = new DistinguishedName("cn=john doe");
- ldapOperationsControl.setDefaultMatcher(MockControl.ARRAY_MATCHER);
- ldapOperationsControl.expectAndReturn(ldapOperationsMock.lookup(
- expectedName, new String[] { "attribute1" },
- attributesMapperMock), expectedAttributes);
-
- replay();
- // Perform test
- CompensatingTransactionOperationExecutor operation = tested
- .recordOperation(new Object[] { expectedName, incomingMods });
- verify();
-
- // Verify outcome
- assertTrue(operation instanceof ModifyAttributesOperationExecutor);
- ModifyAttributesOperationExecutor rollbackOperation = (ModifyAttributesOperationExecutor) operation;
- assertSame(expectedName, rollbackOperation.getDn());
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- assertSame(incomingMods, rollbackOperation.getActualModifications());
- assertEquals(1, rollbackOperation.getCompensatingModifications().length);
- assertSame(compensatingItem, rollbackOperation
- .getCompensatingModifications()[0]);
- }
-
- public void testGetCompensatingModificationItem_RemoveFullExistingAttribute()
- throws NamingException {
- BasicAttribute attribute = new BasicAttribute("someattr");
- attribute.add("value1");
- attribute.add("value2");
- Attributes attributes = new BasicAttributes();
- attributes.put(attribute);
-
- ModificationItem originalItem = new ModificationItem(
- DirContext.REMOVE_ATTRIBUTE, new BasicAttribute("someattr"));
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.ADD_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- Object object = resultAttribute.get(0);
- assertEquals("value1", object);
- assertEquals("value2", resultAttribute.get(1));
- }
-
- public void testGetCompensatingModificationItem_RemoveTwoAttributeValues()
- throws NamingException {
- BasicAttribute attribute = new BasicAttribute("someattr");
- attribute.add("value1");
- attribute.add("value2");
- attribute.add("value3");
- Attributes attributes = new BasicAttributes();
- attributes.put(attribute);
-
- BasicAttribute modificationAttribute = new BasicAttribute("someattr");
- modificationAttribute.add("value1");
- modificationAttribute.add("value2");
- ModificationItem originalItem = new ModificationItem(
- DirContext.REMOVE_ATTRIBUTE, modificationAttribute);
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.ADD_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- Object object = resultAttribute.get(0);
- assertEquals("value1", object);
- assertEquals("value2", resultAttribute.get(1));
- }
-
- public void testGetCompensatingModificationItem_ReplaceExistingAttribute()
- throws NamingException {
- BasicAttribute attribute = new BasicAttribute("someattr");
- attribute.add("value1");
- attribute.add("value2");
- Attributes attributes = new BasicAttributes();
- attributes.put(attribute);
-
- BasicAttribute modificationAttribute = new BasicAttribute("someattr");
- modificationAttribute.add("newvalue1");
- modificationAttribute.add("newvalue2");
- ModificationItem originalItem = new ModificationItem(
- DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("someattr"));
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.REPLACE_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- Object object = resultAttribute.get(0);
- assertEquals("value1", object);
- assertEquals("value2", resultAttribute.get(1));
- }
-
- public void testGetCompensatingModificationItem_ReplaceNonExistingAttribute()
- throws NamingException {
- Attributes attributes = new BasicAttributes();
-
- BasicAttribute modificationAttribute = new BasicAttribute("someattr");
- modificationAttribute.add("newvalue1");
- modificationAttribute.add("newvalue2");
- ModificationItem originalItem = new ModificationItem(
- DirContext.REPLACE_ATTRIBUTE, modificationAttribute);
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.REMOVE_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- assertEquals(0, resultAttribute.size());
- }
-
- public void testGetCompensatingModificationItem_AddNonExistingAttribute()
- throws NamingException {
- Attributes attributes = new BasicAttributes();
-
- BasicAttribute modificationAttribute = new BasicAttribute("someattr");
- modificationAttribute.add("newvalue1");
- modificationAttribute.add("newvalue2");
- ModificationItem originalItem = new ModificationItem(
- DirContext.ADD_ATTRIBUTE, modificationAttribute);
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.REMOVE_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- assertEquals(0, resultAttribute.size());
- }
-
- public void testGetCompensatingModificationItem_AddExistingAttribute()
- throws NamingException {
- BasicAttribute attribute = new BasicAttribute("someattr");
- attribute.add("value1");
- attribute.add("value2");
- Attributes attributes = new BasicAttributes();
- attributes.put(attribute);
-
- BasicAttribute modificationAttribute = new BasicAttribute("someattr");
- modificationAttribute.add("newvalue1");
- modificationAttribute.add("newvalue2");
- ModificationItem originalItem = new ModificationItem(
- DirContext.ADD_ATTRIBUTE, new BasicAttribute("someattr"));
-
- // Perform test
- ModificationItem result = tested.getCompensatingModificationItem(
- attributes, originalItem);
-
- // Verify result
- assertEquals(DirContext.REPLACE_ATTRIBUTE, result.getModificationOp());
- Attribute resultAttribute = result.getAttribute();
- assertEquals("someattr", resultAttribute.getID());
- assertEquals("value1", result.getAttribute().get(0));
- assertEquals("value2", result.getAttribute().get(1));
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationExecutorTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationExecutorTest.java
deleted file mode 100644
index 759aa280..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationExecutorTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.directory.BasicAttributes;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.core.RebindOperationExecutor;
-
-public class RebindOperationExecutorTest extends TestCase {
-
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testPerformOperation() {
- DistinguishedName expectedOriginalDn = new DistinguishedName(
- "cn=john doe");
- DistinguishedName expectedTempDn = new DistinguishedName(
- "cn=john doe_temp");
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- RebindOperationExecutor tested = new RebindOperationExecutor(
- ldapOperationsMock, expectedOriginalDn, expectedTempDn,
- expectedObject, expectedAttributes);
-
- ldapOperationsMock.rename(expectedOriginalDn, expectedTempDn);
- ldapOperationsMock.bind(expectedOriginalDn, expectedObject,
- expectedAttributes);
-
- replay();
- // perform test
- tested.performOperation();
- verify();
- }
-
- public void testCommit() {
- DistinguishedName expectedOriginalDn = new DistinguishedName(
- "cn=john doe");
- DistinguishedName expectedTempDn = new DistinguishedName(
- "cn=john doe_temp");
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- RebindOperationExecutor tested = new RebindOperationExecutor(
- ldapOperationsMock, expectedOriginalDn, expectedTempDn,
- expectedObject, expectedAttributes);
-
- ldapOperationsMock.unbind(expectedTempDn);
-
- replay();
- // perform test
- tested.commit();
- verify();
- }
-
- public void testRollback() {
- DistinguishedName expectedOriginalDn = new DistinguishedName(
- "cn=john doe");
- DistinguishedName expectedTempDn = new DistinguishedName(
- "cn=john doe_temp");
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
- RebindOperationExecutor tested = new RebindOperationExecutor(
- ldapOperationsMock, expectedOriginalDn, expectedTempDn,
- expectedObject, expectedAttributes);
-
- ldapOperationsMock.unbind(expectedOriginalDn);
- ldapOperationsMock.rename(expectedTempDn, expectedOriginalDn);
-
- replay();
- // perform test
- tested.rollback();
- verify();
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationRecorderTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationRecorderTest.java
deleted file mode 100644
index 774647e3..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RebindOperationRecorderTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import javax.naming.directory.BasicAttributes;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.core.RebindOperationExecutor;
-import org.springframework.ldap.transaction.core.RebindOperationRecorder;
-import org.springframework.ldap.transaction.core.TempEntryRenamingStrategy;
-
-public class RebindOperationRecorderTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- private MockControl renamingStrategyControl;
-
- private TempEntryRenamingStrategy renamingStrategyMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- renamingStrategyControl = MockControl
- .createControl(TempEntryRenamingStrategy.class);
- renamingStrategyMock = (TempEntryRenamingStrategy) renamingStrategyControl
- .getMock();
-
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
-
- renamingStrategyControl = null;
- renamingStrategyMock = null;
-
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- renamingStrategyControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- renamingStrategyControl.verify();
- }
-
- public void testRecordOperation() {
- final DistinguishedName expectedDn = new DistinguishedName(
- "cn=john doe");
- final DistinguishedName expectedTempDn = new DistinguishedName(
- "cn=john doe");
- RebindOperationRecorder tested = new RebindOperationRecorder(
- ldapOperationsMock, renamingStrategyMock);
-
- renamingStrategyControl.expectAndReturn(renamingStrategyMock
- .getTemporaryName(expectedDn), expectedTempDn);
-
- replay();
- Object expectedObject = new Object();
- BasicAttributes expectedAttributes = new BasicAttributes();
-
- // perform test
- CompensatingTransactionOperationExecutor result = tested
- .recordOperation(new Object[] { expectedDn, expectedObject,
- expectedAttributes });
- verify();
-
- assertTrue(result instanceof RebindOperationExecutor);
- RebindOperationExecutor rollbackOperation = (RebindOperationExecutor) result;
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- assertSame(expectedDn, rollbackOperation.getOriginalDn());
- assertSame(expectedTempDn, rollbackOperation.getTemporaryDn());
- assertSame(expectedObject, rollbackOperation.getOriginalObject());
- assertSame(expectedAttributes, rollbackOperation
- .getOriginalAttributes());
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationExecutorTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationExecutorTest.java
deleted file mode 100644
index e1296fe4..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationExecutorTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.core.RenameOperationExecutor;
-
-import junit.framework.TestCase;
-
-public class RenameOperationExecutorTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testPerformOperation() {
- DistinguishedName expectedNewName = new DistinguishedName("ou=newOu");
- DistinguishedName expectedOldName = new DistinguishedName("ou=someou");
- RenameOperationExecutor tested = new RenameOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedNewName);
-
- ldapOperationsMock.rename(expectedOldName, expectedNewName);
-
- replay();
- // Perform test.
- tested.performOperation();
- verify();
- }
-
- public void testCommit() {
- DistinguishedName expectedNewName = new DistinguishedName("ou=newOu");
- DistinguishedName expectedOldName = new DistinguishedName("ou=someou");
- RenameOperationExecutor tested = new RenameOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedNewName);
-
- // Nothing to do for this operation.
-
- replay();
- // Perform test.
- tested.commit();
- verify();
- }
-
- public void testRollback() {
- DistinguishedName expectedNewName = new DistinguishedName("ou=newOu");
- DistinguishedName expectedOldName = new DistinguishedName("ou=someou");
- RenameOperationExecutor tested = new RenameOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedNewName);
-
- ldapOperationsMock.rename(expectedNewName, expectedOldName);
-
- replay();
- // Perform test.
- tested.rollback();
- verify();
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationRecorderTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationRecorderTest.java
deleted file mode 100644
index ffc5eb8e..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/RenameOperationRecorderTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.core.RenameOperationExecutor;
-import org.springframework.ldap.transaction.core.RenameOperationRecorder;
-
-public class RenameOperationRecorderTest extends TestCase {
-
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testRecordOperation() {
- RenameOperationRecorder tested = new RenameOperationRecorder(
- ldapOperationsMock);
-
- replay();
- // Perform test
- CompensatingTransactionOperationExecutor operation = tested
- .recordOperation(new Object[] { "ou=someou", "ou=newou" });
- verify();
-
- assertTrue(operation instanceof RenameOperationExecutor);
- RenameOperationExecutor rollbackOperation = (RenameOperationExecutor) operation;
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- assertEquals("ou=newou", rollbackOperation.getNewDn().toString());
- assertEquals("ou=someou", rollbackOperation.getOriginalDn().toString());
- }
-
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationExecutorTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationExecutorTest.java
deleted file mode 100644
index 4db0726a..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationExecutorTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.core.UnbindOperationExecutor;
-
-public class UnbindOperationExecutorTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
-
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- }
-
- public void testPerformOperation() {
- DistinguishedName expectedOldName = new DistinguishedName("cn=oldDn");
- DistinguishedName expectedTempName = new DistinguishedName("cn=newDn");
- UnbindOperationExecutor tested = new UnbindOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedTempName);
-
- ldapOperationsMock.rename(expectedOldName, expectedTempName);
-
- replay();
- // Perform test
- tested.performOperation();
- verify();
- }
-
- public void testCommit() {
- DistinguishedName expectedOldName = new DistinguishedName("cn=oldDn");
- DistinguishedName expectedTempName = new DistinguishedName("cn=newDn");
- UnbindOperationExecutor tested = new UnbindOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedTempName);
-
- ldapOperationsMock.unbind(expectedTempName);
-
- replay();
- // Perform test
- tested.commit();
- verify();
- }
-
- public void testRollback() {
- DistinguishedName expectedOldName = new DistinguishedName("cn=oldDn");
- DistinguishedName expectedTempName = new DistinguishedName("cn=newDn");
- UnbindOperationExecutor tested = new UnbindOperationExecutor(
- ldapOperationsMock, expectedOldName, expectedTempName);
-
- ldapOperationsMock.rename(expectedTempName, expectedOldName);
-
- replay();
- // Perform test
- tested.rollback();
- verify();
- }
-}
diff --git a/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationRecorderTest.java b/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationRecorderTest.java
deleted file mode 100644
index 3f357612..00000000
--- a/sandbox/src/test/java/org/springframework/ldap/transaction/core/UnbindOperationRecorderTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.springframework.ldap.transaction.core;
-
-import junit.framework.TestCase;
-
-import org.easymock.MockControl;
-import org.springframework.ldap.core.DistinguishedName;
-import org.springframework.ldap.core.LdapOperations;
-import org.springframework.ldap.transaction.CompensatingTransactionOperationExecutor;
-import org.springframework.ldap.transaction.core.TempEntryRenamingStrategy;
-import org.springframework.ldap.transaction.core.UnbindOperationExecutor;
-import org.springframework.ldap.transaction.core.UnbindOperationRecorder;
-
-public class UnbindOperationRecorderTest extends TestCase {
- private MockControl ldapOperationsControl;
-
- private LdapOperations ldapOperationsMock;
-
- private MockControl renamingStrategyControl;
-
- private TempEntryRenamingStrategy renamingStrategyMock;
-
- protected void setUp() throws Exception {
- ldapOperationsControl = MockControl.createControl(LdapOperations.class);
- ldapOperationsMock = (LdapOperations) ldapOperationsControl.getMock();
-
- renamingStrategyControl = MockControl
- .createControl(TempEntryRenamingStrategy.class);
- renamingStrategyMock = (TempEntryRenamingStrategy) renamingStrategyControl
- .getMock();
-
- }
-
- protected void tearDown() throws Exception {
- ldapOperationsControl = null;
- ldapOperationsMock = null;
-
- renamingStrategyControl = null;
- renamingStrategyMock = null;
-
- }
-
- protected void replay() {
- ldapOperationsControl.replay();
- renamingStrategyControl.replay();
- }
-
- protected void verify() {
- ldapOperationsControl.verify();
- renamingStrategyControl.verify();
- }
-
- public void testRecordOperation() {
- final DistinguishedName expectedTempName = new DistinguishedName(
- "cn=john doe_temp");
- final DistinguishedName expectedDn = new DistinguishedName(
- "cn=john doe");
- UnbindOperationRecorder tested = new UnbindOperationRecorder(
- ldapOperationsMock, renamingStrategyMock);
-
- renamingStrategyControl.expectAndReturn(renamingStrategyMock
- .getTemporaryName(expectedDn), expectedTempName);
-
- replay();
- // Perform test
- CompensatingTransactionOperationExecutor operation = tested
- .recordOperation(new Object[] { expectedDn });
- verify();
-
- // Verify result
- assertTrue(operation instanceof UnbindOperationExecutor);
- UnbindOperationExecutor rollbackOperation = (UnbindOperationExecutor) operation;
- assertSame(ldapOperationsMock, rollbackOperation.getLdapOperations());
- assertSame(expectedDn, rollbackOperation.getOriginalDn());
- assertSame(expectedTempName, rollbackOperation.getTemporaryDn());
- }
-
-}