public void testOrderedIncoming() throws Exception {
TransactionBatchContext batch1 = transactionBatch(0, 1, 2);
TransactionBatchContext batch2 = transactionBatch(1, 2, 3);
sequencer.goToActiveMode();
sequencer.addResentServerTransactionIDs(batch2.getTransactionIDs());
sequencer.addResentServerTransactionIDs(batch1.getTransactionIDs());
sequencer.transactionManagerStarted(clientIDs(0, 1));
// Add a batch that isn't resent, should be processed last
TransactionBatchContext batch3 = transactionBatch(0, 4, 5);
TransactionBatchContext batch4 = transactionBatch(1, 4, 5);
sequencer.addTransactions(batch3);
sequencer.addTransactions(batch4);
sequencer.addTransactions(batch2);
sequencer.addTransactions(batch1);
ArgumentCaptor<Map> c = ArgumentCaptor.<Map>forClass(Map.class);
ArgumentCaptor<NodeID> n = ArgumentCaptor.<NodeID>forClass(NodeID.class);
InOrder inOrder = inOrder(replicatedObjectManager, transactionManager);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch1);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch2);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch3);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch4);
verifyBatches(true, c, batch1, batch2, batch3, batch4);
}
public void testAddResentAfterStarted() throws Exception {
sequencer.goToActiveMode();
sequencer.transactionManagerStarted(Collections.EMPTY_SET);
try {
sequencer.addResentServerTransactionIDs(transactionIDs(0, 1, 2));
fail();
} catch (IllegalStateException e) {
// Expected
}
}
public void testDiscontinuousGIDInOrder() throws Exception {
// Cut batch1 into 2 sub-batches based on the GID split, batch2 is just 1 batch sitting between
// batch1 part1 and batch1 part2
when(gtxm.getGlobalTransactionID(serverTransactionID(0, 1)))
.thenReturn(new GlobalTransactionID(0));
when(gtxm.getGlobalTransactionID(serverTransactionID(1, 1)))
.thenReturn(new GlobalTransactionID(1));
when(gtxm.getGlobalTransactionID(serverTransactionID(0, 2)))
.thenReturn(new GlobalTransactionID(2));
TransactionBatchContext batch1 = transactionBatch(0, 1, 2);
TransactionBatchContext batch2 = transactionBatch(1, 1);
sequencer.goToActiveMode();
sequencer.addResentServerTransactionIDs(batch1.getTransactionIDs());
sequencer.addResentServerTransactionIDs(batch2.getTransactionIDs());
sequencer.transactionManagerStarted(clientIDs(0, 1));
sequencer.addTransactions(batch1);
sequencer.addTransactions(batch2);
InOrder inOrder = inOrder(transactionManager, replicatedObjectManager);
// Make sure transactions are passed through and relayed in 3 chunks (1 per GID range) in the
// correct order
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch1.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(0, 1))));
inOrder
.verify(replicatedObjectManager)
.relayTransactions(argThat(hasClientIDAndTxns(0, serverTransactionID(0, 1))));
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch2.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(1, 1))));
inOrder
.verify(replicatedObjectManager)
.relayTransactions(argThat(hasClientIDAndTxns(1, serverTransactionID(1, 1))));
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch1.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(0, 2))));
inOrder
.verify(replicatedObjectManager)
.relayTransactions(argThat(hasClientIDAndTxns(0, serverTransactionID(0, 2))));
}
public void testCallbackOnResentComplete() throws Exception {
sequencer.callBackOnResentTxnsInSystemCompletion(callBack);
sequencer.goToActiveMode();
TransactionBatchContext context = transactionBatch(0, 1, 2, 3);
sequencer.addResentServerTransactionIDs(context.getTransactionIDs());
verify(transactionManager, never()).callBackOnTxnsInSystemCompletion(callBack);
sequencer.transactionManagerStarted(clientIDs(0));
verify(transactionManager, never()).callBackOnTxnsInSystemCompletion(callBack);
sequencer.addTransactions(context);
verify(transactionManager).callBackOnTxnsInSystemCompletion(callBack);
}
public void testResentTxnWrapping() throws Exception {
TransactionBatchContext batch1 = transactionBatch(0, 1, 2);
TransactionBatchContext batch2 = transactionBatch(1, 2, 3);
sequencer.goToActiveMode();
sequencer.addResentServerTransactionIDs(batch2.getTransactionIDs());
sequencer.addResentServerTransactionIDs(batch1.getTransactionIDs());
sequencer.transactionManagerStarted(clientIDs(0, 1));
sequencer.addTransactions(batch2);
sequencer.addTransactions(batch1);
// Add non-resent batches (pass through mode)
TransactionBatchContext batch3 = transactionBatch(0, 4, 5);
TransactionBatchContext batch4 = transactionBatch(1, 4, 5);
sequencer.addTransactions(batch3);
sequencer.addTransactions(batch4);
ArgumentCaptor<Map> c = ArgumentCaptor.<Map>forClass(Map.class);
ArgumentCaptor<NodeID> n = ArgumentCaptor.<NodeID>forClass(NodeID.class);
InOrder inOrder = inOrder(replicatedObjectManager, transactionManager);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch1);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch2);
verifyBatches(true, c, batch1, batch2);
// reset arg captor
c = ArgumentCaptor.<Map>forClass(Map.class);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch3);
inOrder.verify(transactionManager).incomingTransactions(n.capture(), c.capture());
inOrder.verify(replicatedObjectManager).relayTransactions(batch4);
verifyBatches(false, c, batch3, batch4);
}
public void incomingTransactions(
ChannelID cid, Set txnIDs, Collection txns, boolean relayed, Collection completedTxnIds) {
final boolean active = isActive();
TransactionAccount ci = getOrCreateTransactionAccount(cid);
ci.incommingTransactions(txnIDs);
for (Iterator i = txns.iterator(); i.hasNext(); ) {
final ServerTransaction txn = (ServerTransaction) i.next();
final ServerTransactionID stxnID = txn.getServerTransactionID();
final TransactionID txnID = stxnID.getClientTransactionID();
if (active && !relayed) {
ci.relayTransactionComplete(txnID);
} else if (!active) {
gtxm.createGlobalTransactionDescIfNeeded(stxnID, txn.getGlobalTransactionID());
}
}
fireIncomingTransactionsEvent(cid, txnIDs);
resentTxnSequencer.addTransactions(txns, completedTxnIds);
}
@Override
protected void setUp() throws Exception {
transactionManager = mock(ServerTransactionManager.class);
gtxm = mock(ServerGlobalTransactionManager.class);
callBack = mock(TxnsInSystemCompletionListener.class);
sequencer = new ResentTransactionSequencer();
replicatedObjectManager = mock(ReplicatedObjectManager.class);
batchReader = mock(TransactionBatchReader.class);
L2HACoordinator l2HACoordinator = mock(L2HACoordinator.class);
when(l2HACoordinator.getReplicatedObjectManager()).thenReturn(replicatedObjectManager);
ServerConfigurationContext context = mock(ServerConfigurationContext.class);
when(context.getServerGlobalTransactionManager()).thenReturn(gtxm);
when(context.getTransactionManager()).thenReturn(transactionManager);
when(context.getL2Coordinator()).thenReturn(l2HACoordinator);
sequencer.initializeContext(context);
}
public void testClientDisconnect() throws Exception {
sequencer.callBackOnResentTxnsInSystemCompletion(callBack);
sequencer.goToActiveMode();
TransactionBatchContext batch1 = transactionBatch(0, 1);
TransactionBatchContext batch2 = transactionBatch(1, 1);
TransactionBatchContext batch3 = transactionBatch(2, 1);
sequencer.addResentServerTransactionIDs(batch1.getTransactionIDs());
sequencer.addResentServerTransactionIDs(batch2.getTransactionIDs());
sequencer.addResentServerTransactionIDs(batch3.getTransactionIDs());
sequencer.transactionManagerStarted(clientIDs(0, 1, 2));
sequencer.addTransactions(batch2);
sequencer.clearAllTransactionsFor(batch2.getSourceNodeID());
sequencer.addTransactions(batch3);
sequencer.addTransactions(batch1);
InOrder inOrder = inOrder(transactionManager);
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch1.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(0, 1))));
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch2.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(1, 1))));
inOrder
.verify(transactionManager)
.incomingTransactions(
eq(batch3.getSourceNodeID()),
argThat(hasServerTransactions(serverTransactionID(2, 1))));
inOrder.verify(transactionManager).callBackOnTxnsInSystemCompletion(callBack);
}
public void goToActiveMode() {
state = ACTIVE_MODE;
resentTxnSequencer.goToActiveMode();
lwmProvider.goToActiveMode();
}
