Java CanCommitTransaction类代码示例

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
private void handleCanCommitTransaction(final CanCommitTransaction canCommit) {
    LOG.debug("{}: Can committing transaction {}", persistenceId(), canCommit.getTransactionId());

    if (isLeader()) {
        commitCoordinator.handleCanCommit(canCommit.getTransactionId(), getSender(), this);
    } else {
        ActorSelection leader = getLeader();
        if (leader == null) {
            messageRetrySupport.addMessageToRetry(canCommit, getSender(),
                    "Could not canCommit transaction " + canCommit.getTransactionId());
        } else {
            LOG.debug("{}: Forwarding CanCommitTransaction to leader {}", persistenceId(), leader);
            leader.forward(canCommit, getContext());
        }
    }
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Override
public void onReceive(final Object message) {
    if (CanCommitTransaction.isSerializedType(message)) {
        canCommitCount.incrementAndGet();
        onMessage("CanCommitTransaction", message, CanCommitTransaction.fromSerializable(message),
                builder.expCanCommitType, builder.canCommitReply);
    } else if (CommitTransaction.isSerializedType(message)) {
        commitCount.incrementAndGet();
        onMessage("CommitTransaction", message, CommitTransaction.fromSerializable(message),
                builder.expCommitType, builder.commitReply);
    } else if (AbortTransaction.isSerializedType(message)) {
        abortCount.incrementAndGet();
        onMessage("AbortTransaction", message, AbortTransaction.fromSerializable(message),
                builder.expAbortType, builder.abortReply);
    } else {
        assertionError = new AssertionError("Unexpected message " + message);
    }
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
private void sendCanCommitTransaction(final CohortInfo toCohortInfo, final OnComplete<Object> onComplete) {
    CanCommitTransaction message = new CanCommitTransaction(transactionId, toCohortInfo.getActorVersion());

    LOG.debug("Tx {}: sending {} to {}", transactionId, message, toCohortInfo.getResolvedActor());

    Future<Object> future = actorContext.executeOperationAsync(toCohortInfo.getResolvedActor(),
            message.toSerializable(), actorContext.getTransactionCommitOperationTimeout());
    future.onComplete(onComplete, actorContext.getClientDispatcher());
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testReadWriteCommitWithPersistenceDisabled() throws Exception {
    dataStoreContextBuilder.persistent(false);
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testCommitWithPersistenceDisabled");

            waitUntilLeader(shard);

            // Setup a simulated transactions with a mock cohort.

            final FiniteDuration duration = duration("5 seconds");

            final TransactionIdentifier transactionID = nextTransactionId();
            final NormalizedNode<?, ?> containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
            shard.tell(prepareBatchedModifications(transactionID, TestModel.TEST_PATH, containerNode, false),
                    getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the CanCommitTransaction message.

            shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            // Send the CanCommitTransaction message.

            shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.TEST_PATH);
            assertEquals(TestModel.TEST_QNAME.getLocalName(), containerNode, actualNode);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testTransactionCommitWithPriorExpiredCohortEntries() throws Exception {
    dataStoreContextBuilder.shardTransactionCommitTimeoutInSeconds(1);
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testTransactionCommitWithPriorExpiredCohortEntries");

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");

            final TransactionIdentifier transactionID1 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID2 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID2, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID3 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID3, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // All Tx's are readied. We'll send canCommit for the last one
            // but not the others. The others
            // should expire from the queue and the last one should be
            // processed.

            shard.tell(new CanCommitTransaction(transactionID3, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CanCommitTransactionReply.class);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testCanCommitBeforeReadyFailure() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testCanCommitBeforeReadyFailure");

            shard.tell(new CanCommitTransaction(nextTransactionId(), CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Override
protected void handleNonRaftCommand(final Object message) {
    try (MessageTracker.Context context = appendEntriesReplyTracker.received(message)) {
        final Optional<Error> maybeError = context.error();
        if (maybeError.isPresent()) {
            LOG.trace("{} : AppendEntriesReply failed to arrive at the expected interval {}", persistenceId(),
                maybeError.get());
        }

        store.resetTransactionBatch();

        if (message instanceof RequestEnvelope) {
            handleRequestEnvelope((RequestEnvelope)message);
        } else if (MessageAssembler.isHandledMessage(message)) {
            handleRequestAssemblerMessage(message);
        } else if (message instanceof ConnectClientRequest) {
            handleConnectClient((ConnectClientRequest)message);
        } else if (CreateTransaction.isSerializedType(message)) {
            handleCreateTransaction(message);
        } else if (message instanceof BatchedModifications) {
            handleBatchedModifications((BatchedModifications)message);
        } else if (message instanceof ForwardedReadyTransaction) {
            handleForwardedReadyTransaction((ForwardedReadyTransaction) message);
        } else if (message instanceof ReadyLocalTransaction) {
            handleReadyLocalTransaction((ReadyLocalTransaction)message);
        } else if (CanCommitTransaction.isSerializedType(message)) {
            handleCanCommitTransaction(CanCommitTransaction.fromSerializable(message));
        } else if (CommitTransaction.isSerializedType(message)) {
            handleCommitTransaction(CommitTransaction.fromSerializable(message));
        } else if (AbortTransaction.isSerializedType(message)) {
            handleAbortTransaction(AbortTransaction.fromSerializable(message));
        } else if (CloseTransactionChain.isSerializedType(message)) {
            closeTransactionChain(CloseTransactionChain.fromSerializable(message));
        } else if (message instanceof RegisterChangeListener) {
            changeSupport.onMessage((RegisterChangeListener) message, isLeader(), hasLeader());
        } else if (message instanceof RegisterDataTreeChangeListener) {
            treeChangeSupport.onMessage((RegisterDataTreeChangeListener) message, isLeader(), hasLeader());
        } else if (message instanceof UpdateSchemaContext) {
            updateSchemaContext((UpdateSchemaContext) message);
        } else if (message instanceof PeerAddressResolved) {
            PeerAddressResolved resolved = (PeerAddressResolved) message;
            setPeerAddress(resolved.getPeerId(), resolved.getPeerAddress());
        } else if (TX_COMMIT_TIMEOUT_CHECK_MESSAGE.equals(message)) {
            commitTimeoutCheck();
        } else if (message instanceof DatastoreContext) {
            onDatastoreContext((DatastoreContext)message);
        } else if (message instanceof RegisterRoleChangeListener) {
            roleChangeNotifier.get().forward(message, context());
        } else if (message instanceof FollowerInitialSyncUpStatus) {
            shardMBean.setFollowerInitialSyncStatus(((FollowerInitialSyncUpStatus) message).isInitialSyncDone());
            context().parent().tell(message, self());
        } else if (GET_SHARD_MBEAN_MESSAGE.equals(message)) {
            sender().tell(getShardMBean(), self());
        } else if (message instanceof GetShardDataTree) {
            sender().tell(store.getDataTree(), self());
        } else if (message instanceof ServerRemoved) {
            context().parent().forward(message, context());
        } else if (ShardTransactionMessageRetrySupport.TIMER_MESSAGE_CLASS.isInstance(message)) {
            messageRetrySupport.onTimerMessage(message);
        } else if (message instanceof DataTreeCohortActorRegistry.CohortRegistryCommand) {
            store.processCohortRegistryCommand(getSender(),
                    (DataTreeCohortActorRegistry.CohortRegistryCommand) message);
        } else if (message instanceof PersistAbortTransactionPayload) {
            final TransactionIdentifier txId = ((PersistAbortTransactionPayload) message).getTransactionId();
            persistPayload(txId, AbortTransactionPayload.create(txId), true);
        } else if (message instanceof MakeLeaderLocal) {
            onMakeLeaderLocal();
        } else if (RESUME_NEXT_PENDING_TRANSACTION.equals(message)) {
            store.resumeNextPendingTransaction();
        } else if (!responseMessageSlicer.handleMessage(message)) {
            super.handleNonRaftCommand(message);
        }
    }
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
Collection<?> convertPendingTransactionsToMessages(final int maxModificationsPerBatch) {
    final Collection<VersionedExternalizableMessage> messages = new ArrayList<>();
    for (ShardDataTreeCohort cohort : dataTree.getAndClearPendingTransactions()) {
        CohortEntry cohortEntry = cohortCache.remove(cohort.getIdentifier());
        if (cohortEntry == null) {
            continue;
        }

        final Deque<BatchedModifications> newMessages = new ArrayDeque<>();
        cohortEntry.getDataTreeModification().applyToCursor(new AbstractBatchedModificationsCursor() {
            @Override
            protected BatchedModifications getModifications() {
                final BatchedModifications lastBatch = newMessages.peekLast();

                if (lastBatch != null && lastBatch.getModifications().size() >= maxModificationsPerBatch) {
                    return lastBatch;
                }

                // Allocate a new message
                final BatchedModifications ret = new BatchedModifications(cohortEntry.getTransactionId(),
                    cohortEntry.getClientVersion());
                newMessages.add(ret);
                return ret;
            }
        });

        final BatchedModifications last = newMessages.peekLast();
        if (last != null) {
            final boolean immediate = cohortEntry.isDoImmediateCommit();
            last.setDoCommitOnReady(immediate);
            last.setReady(true);
            last.setTotalMessagesSent(newMessages.size());

            messages.addAll(newMessages);

            if (!immediate) {
                switch (cohort.getState()) {
                    case CAN_COMMIT_COMPLETE:
                    case CAN_COMMIT_PENDING:
                        messages.add(new CanCommitTransaction(cohortEntry.getTransactionId(),
                            cohortEntry.getClientVersion()));
                        break;
                    case PRE_COMMIT_COMPLETE:
                    case PRE_COMMIT_PENDING:
                        messages.add(new CommitTransaction(cohortEntry.getTransactionId(),
                            cohortEntry.getClientVersion()));
                        break;
                    default:
                        break;
                }
            }
        }
    }

    return messages;
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
Builder expectCanCommit(final Object newCanCommitReply) {
    return expectCanCommit(CanCommitTransaction.class, newCanCommitReply);
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testBatchedModificationsWithNoCommitOnReady() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testBatchedModificationsWithNoCommitOnReady");

            waitUntilLeader(shard);

            final TransactionIdentifier transactionID = nextTransactionId();
            final FiniteDuration duration = duration("5 seconds");

            // Send a BatchedModifications to start a transaction.

            shard.tell(newBatchedModifications(transactionID, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), false, false, 1), getRef());
            expectMsgClass(duration, BatchedModificationsReply.class);

            // Send a couple more BatchedModifications.

            shard.tell(
                    newBatchedModifications(transactionID, TestModel.OUTER_LIST_PATH,
                            ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build(), false, false, 2),
                    getRef());
            expectMsgClass(duration, BatchedModificationsReply.class);

            shard.tell(newBatchedModifications(transactionID,
                    YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
                            .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1).build(),
                    ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1), true, false, 3),
                    getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the CanCommitTransaction message.

            shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            // Send the CommitTransaction message.

            shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            // Verify data in the data store.

            verifyOuterListEntry(shard, 1);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testBatchedModificationsOnTransactionChain() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testBatchedModificationsOnTransactionChain");

            waitUntilLeader(shard);

            final LocalHistoryIdentifier historyId = nextHistoryId();
            final TransactionIdentifier transactionID1 = new TransactionIdentifier(historyId, 0);
            final TransactionIdentifier transactionID2 = new TransactionIdentifier(historyId, 1);

            final FiniteDuration duration = duration("5 seconds");

            // Send a BatchedModifications to start a chained write
            // transaction and ready it.

            final ContainerNode containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
            final YangInstanceIdentifier path = TestModel.TEST_PATH;
            shard.tell(newBatchedModifications(transactionID1, path, containerNode, true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Create a read Tx on the same chain.

            shard.tell(new CreateTransaction(transactionID2, TransactionType.READ_ONLY.ordinal(),
                    DataStoreVersions.CURRENT_VERSION).toSerializable(), getRef());

            final CreateTransactionReply createReply = expectMsgClass(duration("3 seconds"),
                    CreateTransactionReply.class);

            getSystem().actorSelection(createReply.getTransactionPath())
                    .tell(new ReadData(path, DataStoreVersions.CURRENT_VERSION), getRef());
            final ReadDataReply readReply = expectMsgClass(duration("3 seconds"), ReadDataReply.class);
            assertEquals("Read node", containerNode, readReply.getNormalizedNode());

            // Commit the write transaction.

            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            // Verify data in the data store.

            final NormalizedNode<?, ?> actualNode = readStore(shard, path);
            assertEquals("Stored node", containerNode, actualNode);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testReadyLocalTransactionWithThreePhaseCommit() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testReadyLocalTransactionWithThreePhaseCommit");

            waitUntilLeader(shard);

            final ShardDataTree dataStore = shard.underlyingActor().getDataStore();

            final DataTreeModification modification = dataStore.newModification();

            final ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
            new WriteModification(TestModel.TEST_PATH, writeData).apply(modification);
            final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build();
            new MergeModification(TestModel.OUTER_LIST_PATH, mergeData).apply(modification);

            final TransactionIdentifier txId = nextTransactionId();
            modification.ready();
            final ReadyLocalTransaction readyMessage = new ReadyLocalTransaction(txId, modification, false);

            shard.tell(readyMessage, getRef());

            expectMsgClass(ReadyTransactionReply.class);

            // Send the CanCommitTransaction message.

            shard.tell(new CanCommitTransaction(txId, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            // Send the CanCommitTransaction message.

            shard.tell(new CommitTransaction(txId, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(CommitTransactionReply.class);

            final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.OUTER_LIST_PATH);
            assertEquals(TestModel.OUTER_LIST_QNAME.getLocalName(), mergeData, actualNode);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
private void testCommitWhenTransactionHasModifications(final boolean readWrite) throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TipProducingDataTree dataTree = createDelegatingMockDataTree();
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testCommitWhenTransactionHasModifications-" + readWrite);

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");
            final TransactionIdentifier transactionID = nextTransactionId();

            if (readWrite) {
                shard.tell(prepareForwardedReadyTransaction(shard, transactionID, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), false), getRef());
            } else {
                shard.tell(prepareBatchedModifications(transactionID, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), false), getRef());
            }

            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the CanCommitTransaction message.

            shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            final InOrder inOrder = inOrder(dataTree);
            inOrder.verify(dataTree).validate(any(DataTreeModification.class));
            inOrder.verify(dataTree).prepare(any(DataTreeModification.class));
            inOrder.verify(dataTree).commit(any(DataTreeCandidate.class));

            // Purge request is scheduled as asynchronous, wait for two heartbeats to let it propagate into
            // the journal
            Thread.sleep(HEARTBEAT_MILLIS * 2);

            shard.tell(Shard.GET_SHARD_MBEAN_MESSAGE, getRef());
            final ShardStats shardStats = expectMsgClass(duration, ShardStats.class);

            // Use MBean for verification
            // Committed transaction count should increase as usual
            assertEquals(1, shardStats.getCommittedTransactionsCount());

            // Commit index should advance as we do not have an empty
            // modification
            assertEquals(1, shardStats.getCommitIndex());
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testCommitPhaseFailure() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TipProducingDataTree dataTree = createDelegatingMockDataTree();
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testCommitPhaseFailure");

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");
            final Timeout timeout = new Timeout(duration);

            // Setup 2 simulated transactions with mock cohorts. The first
            // one fails in the
            // commit phase.

            doThrow(new RuntimeException("mock commit failure")).when(dataTree)
                    .commit(any(DataTreeCandidate.class));

            final TransactionIdentifier transactionID1 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID2 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID2, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the CanCommitTransaction message for the first Tx.

            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            // Send the CanCommitTransaction message for the 2nd Tx. This
            // should get queued and
            // processed after the first Tx completes.

            final Future<Object> canCommitFuture = Patterns.ask(shard,
                    new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), timeout);

            // Send the CommitTransaction message for the first Tx. This
            // should send back an error
            // and trigger the 2nd Tx to proceed.

            shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, akka.actor.Status.Failure.class);

            // Wait for the 2nd Tx to complete the canCommit phase.

            final CountDownLatch latch = new CountDownLatch(1);
            canCommitFuture.onComplete(new OnComplete<Object>() {
                @Override
                public void onComplete(final Throwable failure, final Object resp) {
                    latch.countDown();
                }
            }, getSystem().dispatcher());

            assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));

            final InOrder inOrder = inOrder(dataTree);
            inOrder.verify(dataTree).validate(any(DataTreeModification.class));
            inOrder.verify(dataTree).prepare(any(DataTreeModification.class));

            // FIXME: this invocation is done on the result of validate(). To test it, we need to make sure mock
            //        validate performs wrapping and we capture that mock
            // inOrder.verify(dataTree).validate(any(DataTreeModification.class));

            inOrder.verify(dataTree).commit(any(DataTreeCandidate.class));
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction; //导入依赖的package包/类
@Test
public void testPreCommitPhaseFailure() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TipProducingDataTree dataTree = createDelegatingMockDataTree();
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testPreCommitPhaseFailure");

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");
            final Timeout timeout = new Timeout(duration);

            doThrow(new RuntimeException("mock preCommit failure")).when(dataTree)
                    .prepare(any(DataTreeModification.class));

            final TransactionIdentifier transactionID1 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID2 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID2, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the CanCommitTransaction message for the first Tx.

            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                    .fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());

            // Send the CanCommitTransaction message for the 2nd Tx. This
            // should get queued and
            // processed after the first Tx completes.

            final Future<Object> canCommitFuture = Patterns.ask(shard,
                    new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), timeout);

            // Send the CommitTransaction message for the first Tx. This
            // should send back an error
            // and trigger the 2nd Tx to proceed.

            shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, akka.actor.Status.Failure.class);

            // Wait for the 2nd Tx to complete the canCommit phase.

            final CountDownLatch latch = new CountDownLatch(1);
            canCommitFuture.onComplete(new OnComplete<Object>() {
                @Override
                public void onComplete(final Throwable failure, final Object resp) {
                    latch.countDown();
                }
            }, getSystem().dispatcher());

            assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));

            final InOrder inOrder = inOrder(dataTree);
            inOrder.verify(dataTree).validate(any(DataTreeModification.class));
            inOrder.verify(dataTree).prepare(any(DataTreeModification.class));
            inOrder.verify(dataTree).validate(any(DataTreeModification.class));
        }
    };
}