+ }
+
+ @Test
+ public void bug4359AddRemoveCarOnce() throws ExecutionException, InterruptedException {
+ immediatePayloadReplication(shardDataTree, mockShard);
+
+ final List<DataTreeCandidate> candidates = new ArrayList<>();
+ candidates.add(addCar(shardDataTree));
+ candidates.add(removeCar(shardDataTree));
+
+ final NormalizedNode<?, ?> expected = getCars(shardDataTree);
+
+ applyCandidates(shardDataTree, candidates);
+
+ final NormalizedNode<?, ?> actual = getCars(shardDataTree);
+
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void bug4359AddRemoveCarTwice() throws ExecutionException, InterruptedException {
+ immediatePayloadReplication(shardDataTree, mockShard);
+
+ final List<DataTreeCandidate> candidates = new ArrayList<>();
+ candidates.add(addCar(shardDataTree));
+ candidates.add(removeCar(shardDataTree));
+ candidates.add(addCar(shardDataTree));
+ candidates.add(removeCar(shardDataTree));
+
+ final NormalizedNode<?, ?> expected = getCars(shardDataTree);
+
+ applyCandidates(shardDataTree, candidates);
+
+ final NormalizedNode<?, ?> actual = getCars(shardDataTree);
+
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void testListenerNotifiedOnApplySnapshot() throws Exception {
+ immediatePayloadReplication(shardDataTree, mockShard);
+
+ DOMDataTreeChangeListener listener = mock(DOMDataTreeChangeListener.class);
+ shardDataTree.registerTreeChangeListener(CarsModel.CAR_LIST_PATH.node(CarsModel.CAR_QNAME), listener,
+ Optional.absent(), noop -> { });
+
+ addCar(shardDataTree, "optima");
+
+ verifyOnDataTreeChanged(listener, dtc -> {
+ assertEquals("getModificationType", ModificationType.WRITE, dtc.getRootNode().getModificationType());
+ assertEquals("getRootPath", CarsModel.newCarPath("optima"), dtc.getRootPath());
+ });
+
+ addCar(shardDataTree, "sportage");
+
+ verifyOnDataTreeChanged(listener, dtc -> {
+ assertEquals("getModificationType", ModificationType.WRITE, dtc.getRootNode().getModificationType());
+ assertEquals("getRootPath", CarsModel.newCarPath("sportage"), dtc.getRootPath());
+ });
+
+ ShardDataTree newDataTree = new ShardDataTree(mockShard, fullSchema, TreeType.OPERATIONAL);
+ immediatePayloadReplication(newDataTree, mockShard);
+ addCar(newDataTree, "optima");
+ addCar(newDataTree, "murano");
+
+ shardDataTree.applySnapshot(newDataTree.takeStateSnapshot());
+
+ Map<YangInstanceIdentifier, ModificationType> expChanges = Maps.newHashMap();
+ expChanges.put(CarsModel.newCarPath("optima"), ModificationType.WRITE);
+ expChanges.put(CarsModel.newCarPath("murano"), ModificationType.WRITE);
+ expChanges.put(CarsModel.newCarPath("sportage"), ModificationType.DELETE);
+ verifyOnDataTreeChanged(listener, dtc -> {
+ ModificationType expType = expChanges.remove(dtc.getRootPath());
+ assertNotNull("Got unexpected change for " + dtc.getRootPath(), expType);
+ assertEquals("getModificationType", expType, dtc.getRootNode().getModificationType());
+ });
+
+ if (!expChanges.isEmpty()) {
+ fail("Missing change notifications: " + expChanges);
+ }
+ }
+
+ @Test
+ public void testPipelinedTransactionsWithCoordinatedCommits() throws Exception {
+ final ShardDataTreeCohort cohort1 = newShardDataTreeCohort(snapshot ->
+ snapshot.write(CarsModel.BASE_PATH, CarsModel.emptyContainer()));
+
+ final ShardDataTreeCohort cohort2 = newShardDataTreeCohort(snapshot ->
+ snapshot.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()));
+
+ NormalizedNode<?, ?> peopleNode = PeopleModel.create();
+ final ShardDataTreeCohort cohort3 = newShardDataTreeCohort(snapshot ->
+ snapshot.write(PeopleModel.BASE_PATH, peopleNode));
+
+ YangInstanceIdentifier carPath = CarsModel.newCarPath("optima");
+ MapEntryNode carNode = CarsModel.newCarEntry("optima", new BigInteger("100"));
+ final ShardDataTreeCohort cohort4 = newShardDataTreeCohort(snapshot -> snapshot.write(carPath, carNode));
+
+ immediateCanCommit(cohort1);
+ final FutureCallback<Void> canCommitCallback2 = coordinatedCanCommit(cohort2);
+ final FutureCallback<Void> canCommitCallback3 = coordinatedCanCommit(cohort3);
+ final FutureCallback<Void> canCommitCallback4 = coordinatedCanCommit(cohort4);
+
+ final FutureCallback<DataTreeCandidate> preCommitCallback1 = coordinatedPreCommit(cohort1);
+ verify(preCommitCallback1).onSuccess(cohort1.getCandidate());
+ verify(canCommitCallback2).onSuccess(null);
+
+ final FutureCallback<DataTreeCandidate> preCommitCallback2 = coordinatedPreCommit(cohort2);
+ verify(preCommitCallback2).onSuccess(cohort2.getCandidate());
+ verify(canCommitCallback3).onSuccess(null);
+
+ final FutureCallback<DataTreeCandidate> preCommitCallback3 = coordinatedPreCommit(cohort3);
+ verify(preCommitCallback3).onSuccess(cohort3.getCandidate());
+ verify(canCommitCallback4).onSuccess(null);
+
+ final FutureCallback<DataTreeCandidate> preCommitCallback4 = coordinatedPreCommit(cohort4);
+ verify(preCommitCallback4).onSuccess(cohort4.getCandidate());
+
+ final FutureCallback<UnsignedLong> commitCallback2 = coordinatedCommit(cohort2);
+ verify(mockShard, never()).persistPayload(eq(cohort1.getIdentifier()), any(CommitTransactionPayload.class),
+ anyBoolean());
+ verifyNoMoreInteractions(commitCallback2);
+
+ final FutureCallback<UnsignedLong> commitCallback4 = coordinatedCommit(cohort4);
+ verify(mockShard, never()).persistPayload(eq(cohort4.getIdentifier()), any(CommitTransactionPayload.class),
+ anyBoolean());
+ verifyNoMoreInteractions(commitCallback4);
+
+ final FutureCallback<UnsignedLong> commitCallback1 = coordinatedCommit(cohort1);
+ InOrder inOrder = inOrder(mockShard);
+ inOrder.verify(mockShard).persistPayload(eq(cohort1.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(true));
+ inOrder.verify(mockShard).persistPayload(eq(cohort2.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(false));
+ verifyNoMoreInteractions(commitCallback1);
+ verifyNoMoreInteractions(commitCallback2);
+
+ final FutureCallback<UnsignedLong> commitCallback3 = coordinatedCommit(cohort3);
+ inOrder = inOrder(mockShard);
+ inOrder.verify(mockShard).persistPayload(eq(cohort3.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(true));
+ inOrder.verify(mockShard).persistPayload(eq(cohort4.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(false));
+ verifyNoMoreInteractions(commitCallback3);
+ verifyNoMoreInteractions(commitCallback4);
+
+ final ShardDataTreeCohort cohort5 = newShardDataTreeCohort(snapshot ->
+ snapshot.merge(CarsModel.BASE_PATH, CarsModel.emptyContainer()));
+ final FutureCallback<Void> canCommitCallback5 = coordinatedCanCommit(cohort5);
+
+ // The payload instance doesn't matter - it just needs to be of type CommitTransactionPayload.
+ CommitTransactionPayload mockPayload = CommitTransactionPayload.create(nextTransactionId(),
+ cohort1.getCandidate());
+ shardDataTree.applyReplicatedPayload(cohort1.getIdentifier(), mockPayload);
+ shardDataTree.applyReplicatedPayload(cohort2.getIdentifier(), mockPayload);
+ shardDataTree.applyReplicatedPayload(cohort3.getIdentifier(), mockPayload);
+ shardDataTree.applyReplicatedPayload(cohort4.getIdentifier(), mockPayload);
+
+ inOrder = inOrder(commitCallback1, commitCallback2, commitCallback3, commitCallback4);
+ inOrder.verify(commitCallback1).onSuccess(any(UnsignedLong.class));
+ inOrder.verify(commitCallback2).onSuccess(any(UnsignedLong.class));
+ inOrder.verify(commitCallback3).onSuccess(any(UnsignedLong.class));
+ inOrder.verify(commitCallback4).onSuccess(any(UnsignedLong.class));
+
+ verify(canCommitCallback5).onSuccess(null);
+
+ final DataTreeSnapshot snapshot =
+ shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
+ Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
+ assertEquals("Car node present", true, optional.isPresent());
+ assertEquals("Car node", carNode, optional.get());
+
+ optional = snapshot.readNode(PeopleModel.BASE_PATH);
+ assertEquals("People node present", true, optional.isPresent());
+ assertEquals("People node", peopleNode, optional.get());
+ }
+
+ @Test
+ public void testPipelinedTransactionsWithImmediateCommits() throws Exception {
+ final ShardDataTreeCohort cohort1 = newShardDataTreeCohort(snapshot ->
+ snapshot.write(CarsModel.BASE_PATH, CarsModel.emptyContainer()));
+
+ final ShardDataTreeCohort cohort2 = newShardDataTreeCohort(snapshot ->
+ snapshot.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()));
+
+ YangInstanceIdentifier carPath = CarsModel.newCarPath("optima");
+ MapEntryNode carNode = CarsModel.newCarEntry("optima", new BigInteger("100"));
+ final ShardDataTreeCohort cohort3 = newShardDataTreeCohort(snapshot -> snapshot.write(carPath, carNode));
+
+ final FutureCallback<UnsignedLong> commitCallback2 = immediate3PhaseCommit(cohort2);
+ final FutureCallback<UnsignedLong> commitCallback3 = immediate3PhaseCommit(cohort3);
+ final FutureCallback<UnsignedLong> commitCallback1 = immediate3PhaseCommit(cohort1);
+
+ InOrder inOrder = inOrder(mockShard);
+ inOrder.verify(mockShard).persistPayload(eq(cohort1.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(true));
+ inOrder.verify(mockShard).persistPayload(eq(cohort2.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(true));
+ inOrder.verify(mockShard).persistPayload(eq(cohort3.getIdentifier()), any(CommitTransactionPayload.class),
+ eq(false));
+
+ // The payload instance doesn't matter - it just needs to be of type CommitTransactionPayload.
+ CommitTransactionPayload mockPayload = CommitTransactionPayload.create(nextTransactionId(),
+ cohort1.getCandidate());
+ shardDataTree.applyReplicatedPayload(cohort1.getIdentifier(), mockPayload);
+ shardDataTree.applyReplicatedPayload(cohort2.getIdentifier(), mockPayload);
+ shardDataTree.applyReplicatedPayload(cohort3.getIdentifier(), mockPayload);
+
+ inOrder = inOrder(commitCallback1, commitCallback2, commitCallback3);
+ inOrder.verify(commitCallback1).onSuccess(any(UnsignedLong.class));
+ inOrder.verify(commitCallback2).onSuccess(any(UnsignedLong.class));
+ inOrder.verify(commitCallback3).onSuccess(any(UnsignedLong.class));
+
+ final DataTreeSnapshot snapshot =
+ shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
+ Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
+ assertEquals("Car node present", true, optional.isPresent());
+ assertEquals("Car node", carNode, optional.get());
+ }
+
+ @Test
+ public void testPipelinedTransactionsWithImmediateReplication() throws Exception {
+ immediatePayloadReplication(shardDataTree, mockShard);