inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-06-16 17:55:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Tests for the RetryingTransactionHelper

Browse Source 
- Tests new inner transactions
 - Tests various modes of failure, including silent mark for rollback
Archive restore uses retries


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@5953 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Derek Hulley 2007-06-14 12:34:39 +00:00
parent d403021a74
commit dd2f3985b9
3 changed files with 394 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
source/java/org/alfresco/repo/node/archive/NodeArchiveServiceImpl.java
View File

@ -30,8 +30,8 @@ import java.util.List;
import org.alfresco.model.ContentModel;
import org.alfresco.repo.node.archive.RestoreNodeReport.RestoreStatus;
import org.alfresco.repo.security.permissions.AccessDeniedException;
import org.alfresco.repo.transaction.TransactionUtil;
import org.alfresco.repo.transaction.TransactionUtil.TransactionWork;
import org.alfresco.repo.transaction.RetryingTransactionHelper;
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
import org.alfresco.service.cmr.repository.ChildAssociationRef;
import org.alfresco.service.cmr.repository.InvalidNodeRefException;
import org.alfresco.service.cmr.repository.NodeRef;
@ -129,14 +129,15 @@ public class NodeArchiveServiceImpl implements NodeArchiveService
try
{
// Transactional wrapper to attempt the restore
TransactionWork<NodeRef> restoreWork = new TransactionWork<NodeRef>()
RetryingTransactionHelper txnHelper = transactionService.getRetryingTransactionHelper();
RetryingTransactionCallback<NodeRef> restoreCallback = new RetryingTransactionCallback<NodeRef>()
{
public NodeRef doWork() throws Exception
public NodeRef execute() throws Exception
{
return nodeService.restoreNode(archivedNodeRef, destinationNodeRef, assocTypeQName, assocQName);
}
};
NodeRef newNodeRef = TransactionUtil.executeInNonPropagatingUserTransaction(transactionService, restoreWork);
NodeRef newNodeRef = txnHelper.doInTransaction(restoreCallback, false, true);
// success
report.setRestoredNodeRef(newNodeRef);
report.setStatus(RestoreStatus.SUCCESS);
@ -274,9 +275,10 @@ public class NodeArchiveServiceImpl implements NodeArchiveService
*/
public void purgeArchivedNode(final NodeRef archivedNodeRef)
{
TransactionWork<Object> deleteWork = new TransactionWork<Object>()
RetryingTransactionHelper txnHelper = transactionService.getRetryingTransactionHelper();
RetryingTransactionCallback<Object> deleteCallback = new RetryingTransactionCallback<Object>()
{
public Object doWork() throws Exception
public Object execute() throws Exception
{
try
{
@ -289,7 +291,7 @@ public class NodeArchiveServiceImpl implements NodeArchiveService
return null;
}
};
TransactionUtil.executeInNonPropagatingUserTransaction(transactionService, deleteWork);
txnHelper.doInTransaction(deleteCallback, false, true);
}
/**

33
source/java/org/alfresco/repo/transaction/RetryingTransactionHelper.java
View File

@ -27,7 +27,6 @@ package org.alfresco.repo.transaction;
import java.sql.BatchUpdateException;
import java.util.Random;
import javax.transaction.RollbackException;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.UserTransaction;
@ -57,7 +56,7 @@ public class RetryingTransactionHelper
/**
* Exceptions that trigger retries.
*/
private static final Class[] RETRY_EXCEPTIONS;
public static final Class[] RETRY_EXCEPTIONS;
static
{
RETRY_EXCEPTIONS = new Class[] {
@ -149,6 +148,7 @@ public class RetryingTransactionHelper
*
* @param cb The callback containing the unit of work.
* @return Returns the result of the unit of work.
* @throws RuntimeException all checked exceptions are converted
*/
public <R> R doInTransaction(RetryingTransactionCallback<R> cb)
{
@ -167,6 +167,7 @@ public class RetryingTransactionHelper
* @param cb The callback containing the unit of work.
* @param readOnly Whether this is a read only transaction.
* @return Returns the result of the unit of work.
* @throws RuntimeException all checked exceptions are converted
*/
public <R> R doInTransaction(RetryingTransactionCallback<R> cb, boolean readOnly)
{
@ -184,11 +185,12 @@ public class RetryingTransactionHelper
*
* @param cb The callback containing the unit of work.
* @param readOnly Whether this is a read only transaction.
* @param newTransaction <tt>true</tt> to force a new transaction or
* @param requiresNew <tt>true</tt> to force a new transaction or
* <tt>false</tt> to partake in any existing transaction.
* @return Returns the result of the unit of work.
* @throws RuntimeException all checked exceptions are converted
*/
public <R> R doInTransaction(RetryingTransactionCallback<R> cb, boolean readOnly, boolean newTransaction)
public <R> R doInTransaction(RetryingTransactionCallback<R> cb, boolean readOnly, boolean requiresNew)
{
if (this.readOnly && !readOnly)
{
@ -203,7 +205,7 @@ public class RetryingTransactionHelper
boolean isNew = false;
try
{
if (newTransaction)
if (requiresNew)
{
txn = fTxnService.getNonPropagatingUserTransaction();
}
@ -211,12 +213,10 @@ public class RetryingTransactionHelper
{
txn = fTxnService.getUserTransaction(readOnly);
}
// Do we need to handle transaction demarcation. If no, we cannot do retries,
// that will be up to the containing transaction.
isNew = newTransaction || txn.getStatus() == Status.STATUS_NO_TRANSACTION;
// Only start a transaction if required. This check isn't necessary as the transactional
// behaviour ensures that the appropriate propogation is performed. It is a useful and
// simple optimization.
isNew = requiresNew || txn.getStatus() == Status.STATUS_NO_TRANSACTION;
if (isNew)
{
txn.begin();
@ -250,13 +250,6 @@ public class RetryingTransactionHelper
}
return result;
}
catch (RollbackException e)
{
// Our explicit rollback didn't work
throw new AlfrescoRuntimeException(
"Unexpected rollback exception: \n" + e.getMessage(),
e);
}
catch (Throwable e)
{
// Somebody else 'owns' the transaction, so just rethrow.
@ -268,7 +261,9 @@ public class RetryingTransactionHelper
}
else
{
throw new AlfrescoRuntimeException("Unknown Exception.", e);
throw new AlfrescoRuntimeException(
"Exception from transactional callback: " + cb,
e);
}
}
// Rollback if we can.
@ -283,15 +278,15 @@ public class RetryingTransactionHelper
}
catch (IllegalStateException e1)
{
throw new AlfrescoRuntimeException("Failure during rollback.", e1);
throw new AlfrescoRuntimeException("Failure during rollback: " + cb, e1);
}
catch (SecurityException e1)
{
throw new AlfrescoRuntimeException("Failure during rollback.", e1);
throw new AlfrescoRuntimeException("Failure during rollback: " + cb, e1);
}
catch (SystemException e1)
{
throw new AlfrescoRuntimeException("Failure during rollback.", e1);
throw new AlfrescoRuntimeException("Failure during rollback: " + cb, e1);
}
}
lastException = (e instanceof RuntimeException) ?

370
source/java/org/alfresco/repo/transaction/RetryingTransactionHelperTest.java Normal file
View File

@ -0,0 +1,370 @@
/*
* Copyright (C) 2005-2007 Alfresco Software Limited.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* As a special exception to the terms and conditions of version 2.0 of
* the GPL, you may redistribute this Program in connection with Free/Libre
* and Open Source Software ("FLOSS") applications as described in Alfresco's
* FLOSS exception. You should have recieved a copy of the text describing
* the FLOSS exception, and it is also available here:
* http://www.alfresco.com/legal/licensing"
*/
package org.alfresco.repo.transaction;
import junit.framework.TestCase;
import org.alfresco.error.ExceptionStackUtil;
import org.alfresco.model.ContentModel;
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
import org.alfresco.service.ServiceRegistry;
import org.alfresco.service.cmr.repository.InvalidNodeRefException;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.alfresco.service.transaction.TransactionService;
import org.alfresco.util.ApplicationContextHelper;
import org.springframework.context.ApplicationContext;
import org.springframework.dao.ConcurrencyFailureException;
/**
* Tests the transaction retrying behaviour with various failure modes.
*
* @see RetryingTransactionHelper
* @see TransactionService
*
* @author Derek Hulley
* @since 2.1
*/
public class RetryingTransactionHelperTest extends TestCase
{
private static final QName PROP_CHECK_VALUE = QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "check_value");
private static ApplicationContext ctx = ApplicationContextHelper.getApplicationContext();
private ServiceRegistry serviceRegistry;
private TransactionService transactionService;
private NodeService nodeService;
private RetryingTransactionHelper txnHelper;
private NodeRef rootNodeRef;
private NodeRef workingNodeRef;
@Override
public void setUp() throws Exception
{
serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);
transactionService = serviceRegistry.getTransactionService();
nodeService = serviceRegistry.getNodeService();
txnHelper = transactionService.getRetryingTransactionHelper();
StoreRef storeRef = nodeService.createStore(
StoreRef.PROTOCOL_WORKSPACE,
"test-" + getName() + "-" + System.currentTimeMillis());
rootNodeRef = nodeService.getRootNode(storeRef);
// Create a node to work on
workingNodeRef = nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, getName()),
ContentModel.TYPE_CMOBJECT).getChildRef();
}
public void testSetUp() throws Exception
{
assertNotNull(rootNodeRef);
assertNotNull(workingNodeRef);
}
/**
* Get the count, which is 0 to start each test
*
* @return Returns the current count
*/
private Long getCheckValue()
{
Long checkValue = (Long) nodeService.getProperty(workingNodeRef, PROP_CHECK_VALUE);
if (checkValue == null)
{
checkValue = new Long(0);
nodeService.setProperty(workingNodeRef, PROP_CHECK_VALUE, checkValue);
}
return checkValue;
}
/**
* Increment the test count, which is 0 to start each test
*
* @return Returns the current count
*/
private Long incrementCheckValue()
{
Long checkValue = getCheckValue();
checkValue = new Long(checkValue.longValue() + 1L);
nodeService.setProperty(workingNodeRef, PROP_CHECK_VALUE, checkValue);
return checkValue;
}
/**
* @return Never returns anything
* @throws InvalidNodeRefException <b>ALWAYS</b>
*/
private Long blowUp()
{
NodeRef invalidNodeRef = new NodeRef(workingNodeRef.getStoreRef(), "BOGUS");
nodeService.setProperty(invalidNodeRef, PROP_CHECK_VALUE, null);
fail("Expected to generate an InvalidNodeRefException");
return null;
}
/**
* Check that it works without complications.
*/
public void testSuccessNoRetry()
{
long beforeValue = getCheckValue();
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
return incrementCheckValue();
}
};
long txnValue = txnHelper.doInTransaction(callback);
long afterValue = getCheckValue();
assertEquals("The value must have increased", beforeValue + 1, afterValue);
assertEquals("The txn value must be the same as the value after", afterValue, txnValue);
}
/**
* Check that the retries happening for simple concurrency exceptions
*/
public void testSuccessWithRetry()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
private int maxCalls = 3;
private int callCount = 0;
public Long execute() throws Throwable
{
callCount++;
Long checkValue = incrementCheckValue();
if (callCount == maxCalls)
{
return checkValue;
}
else
{
throw new ConcurrencyFailureException("Testing");
}
}
};
long txnValue = txnHelper.doInTransaction(callback);
assertEquals("Only one increment expected", 1, txnValue);
}
/**
* Checks that a non-retrying exception is passed out and that the transaction is rolled back.
*/
public void testNonRetryingFailure()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
incrementCheckValue();
return blowUp();
}
};
try
{
txnHelper.doInTransaction(callback);
fail("Wrapper didn't generate an exception");
}
catch (InvalidNodeRefException e)
{
// Correct
}
catch (Throwable e)
{
fail("Incorrect exception from wrapper: " + e);
}
// Check that the value didn't change
long checkValue = getCheckValue();
assertEquals("Check value should not have changed", 0, checkValue);
}
/**
* Sometimes, exceptions or other states may cause the transaction to be marked for
* rollback without an exception being generated. This tests that the exception stays
* absorbed and that another isn't generated, but that the transaction was rolled back
* properly.
*/
public void testNonRetryingSilentRollback()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
incrementCheckValue();
try
{
return blowUp();
}
catch (InvalidNodeRefException e)
{
// Expected, but absorbed
}
return null;
}
};
txnHelper.doInTransaction(callback);
long checkValue = getCheckValue();
assertEquals("Check value should not have changed", 0, checkValue);
}
/**
* Checks nesting of two transactions with <code>requiresNew == false</code>
*/
public void testNestedWithPropogation()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
RetryingTransactionCallback<Long> callbackInner = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
incrementCheckValue();
incrementCheckValue();
return getCheckValue();
}
};
txnHelper.doInTransaction(callbackInner, false, false);
incrementCheckValue();
incrementCheckValue();
return getCheckValue();
}
};
long checkValue = txnHelper.doInTransaction(callback);
assertEquals("Nesting requiresNew==false didn't work", 4, checkValue);
}
/**
* Checks nesting of two transactions with <code>requiresNew == true</code>
*/
public void testNestedWithoutPropogation()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
RetryingTransactionCallback<Long> callbackInner = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
incrementCheckValue();
incrementCheckValue();
return getCheckValue();
}
};
txnHelper.doInTransaction(callbackInner, false, true);
incrementCheckValue();
incrementCheckValue();
return getCheckValue();
}
};
long checkValue = txnHelper.doInTransaction(callback);
assertEquals("Nesting requiresNew==true didn't work", 4, checkValue);
}
/**
* Checks nesting of two transactions with <code>requiresNew == true</code>,
* but where the two transactions get involved in a concurrency struggle.
*/
public void testNestedWithoutPropogationConcurrentUntilFailure()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
RetryingTransactionCallback<Long> callbackInner = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
incrementCheckValue();
return getCheckValue();
}
};
incrementCheckValue();
txnHelper.doInTransaction(callbackInner, false, true);
return getCheckValue();
}
};
try
{
txnHelper.doInTransaction(callback);
fail("Concurrent nested access not leading to failure");
}
catch (Throwable e)
{
Throwable validCause = ExceptionStackUtil.getCause(e, RetryingTransactionHelper.RETRY_EXCEPTIONS);
assertNotNull("Unexpected cause of the failure", validCause);
}
}
/**
* Checks nesting of two transactions with <code>requiresNew == true</code>,
* but where the inner transaction fails writes values that the outer transaction
* fails on.
*/
public void testNestedWithoutPropogationOuterFailing()
{
RetryingTransactionCallback<Long> callback = new RetryingTransactionCallback<Long>()
{
private int maxCalls = 3;
private int callCount = 0;
public Long execute() throws Throwable
{
callCount++;
RetryingTransactionCallback<Long> callbackInner = new RetryingTransactionCallback<Long>()
{
public Long execute() throws Throwable
{
for (int i = 0; i < 5; i++)
{
incrementCheckValue();
}
return getCheckValue();
}
};
// Increment the value so that the outer transaction is bound to the particular
// version of the data
incrementCheckValue();
// Don't execute the inner transaction the last time around
if (callCount < maxCalls)
{
txnHelper.doInTransaction(callbackInner, false, true);
}
return getCheckValue();
}
};
long checkValue = txnHelper.doInTransaction(callback);
assertEquals("Check value not incremented", 11, checkValue);
}
}