2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.cluster.datastore;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertSame;
13 import static org.junit.Assert.fail;
14 import static org.mockito.ArgumentMatchers.any;
15 import static org.mockito.Mockito.doReturn;
16 import static org.mockito.Mockito.mock;
17 import static org.mockito.Mockito.reset;
18 import static org.mockito.Mockito.verify;
19 import static org.mockito.Mockito.verifyNoMoreInteractions;
21 import akka.actor.ActorSystem;
22 import akka.actor.Address;
23 import akka.actor.AddressFromURIString;
24 import akka.cluster.Cluster;
25 import akka.testkit.javadsl.TestKit;
26 import com.google.common.base.Throwables;
27 import com.google.common.util.concurrent.FluentFuture;
28 import com.typesafe.config.ConfigFactory;
29 import java.util.Collection;
30 import java.util.Optional;
31 import java.util.concurrent.ExecutionException;
32 import java.util.concurrent.TimeUnit;
33 import org.junit.AfterClass;
34 import org.junit.BeforeClass;
35 import org.junit.Ignore;
36 import org.junit.Test;
37 import org.mockito.ArgumentCaptor;
38 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
39 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
40 import org.opendaylight.mdsal.common.api.DataValidationFailedException;
41 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
42 import org.opendaylight.mdsal.common.api.PostCanCommitStep;
43 import org.opendaylight.mdsal.common.api.PostPreCommitStep;
44 import org.opendaylight.mdsal.common.api.ThreePhaseCommitStep;
45 import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
46 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
47 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
48 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
49 import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
50 import org.opendaylight.yangtools.concepts.ObjectRegistration;
51 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
52 import org.opendaylight.yangtools.yang.common.Uint64;
53 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
54 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
57 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
58 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
59 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
61 public class DataTreeCohortIntegrationTest {
63 private static final DataValidationFailedException FAILED_CAN_COMMIT =
64 new DataValidationFailedException(YangInstanceIdentifier.class, TestModel.TEST_PATH, "Test failure.");
65 private static final FluentFuture<PostCanCommitStep> FAILED_CAN_COMMIT_FUTURE =
66 FluentFutures.immediateFailedFluentFuture(FAILED_CAN_COMMIT);
68 private static final DOMDataTreeIdentifier TEST_ID =
69 new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
71 private static ActorSystem system;
73 private final DatastoreContext.Builder datastoreContextBuilder =
74 DatastoreContext.newBuilder().shardHeartbeatIntervalInMillis(100);
77 public static void setUpClass() {
78 system = ActorSystem.create("cluster-test", ConfigFactory.load().getConfig("Member1"));
79 final Address member1Address = AddressFromURIString.parse("akka://cluster-test@127.0.0.1:2558");
80 Cluster.get(system).join(member1Address);
84 public static void tearDownClass() {
85 TestKit.shutdownActorSystem(system);
89 protected ActorSystem getSystem() {
93 @SuppressWarnings({ "unchecked", "rawtypes" })
95 public void testSuccessfulCanCommitWithNoopPostStep() throws Exception {
96 final DOMDataTreeCommitCohort cohort = mock(DOMDataTreeCommitCohort.class);
97 doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(Object.class),
98 any(SchemaContext.class), any(Collection.class));
99 ArgumentCaptor<Collection> candidateCapt = ArgumentCaptor.forClass(Collection.class);
100 IntegrationTestKit kit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
102 try (AbstractDataStore dataStore = kit.setupAbstractDataStore(
103 DistributedDataStore.class, "testSuccessfulCanCommitWithNoopPostStep", "test-1")) {
104 final ObjectRegistration<DOMDataTreeCommitCohort> cohortReg = dataStore.registerCommitCohort(TEST_ID,
106 assertNotNull(cohortReg);
108 IntegrationTestKit.verifyShardState(dataStore, "test-1",
109 state -> assertEquals("Cohort registrations", 1, state.getCommitCohortActors().size()));
111 final ContainerNode node = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
112 kit.testWriteTransaction(dataStore, TestModel.TEST_PATH, node);
113 verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), candidateCapt.capture());
114 assertDataTreeCandidate((DOMDataTreeCandidate) candidateCapt.getValue().iterator().next(), TEST_ID,
115 ModificationType.WRITE, Optional.of(node), Optional.empty());
118 doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(Object.class),
119 any(SchemaContext.class), any(Collection.class));
121 kit.testWriteTransaction(dataStore, TestModel.OUTER_LIST_PATH,
122 ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
123 .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
125 verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), any(Collection.class));
129 IntegrationTestKit.verifyShardState(dataStore, "test-1",
130 state -> assertEquals("Cohort registrations", 0, state.getCommitCohortActors().size()));
132 kit.testWriteTransaction(dataStore, TestModel.TEST_PATH, node);
133 verifyNoMoreInteractions(cohort);
137 @SuppressWarnings("unchecked")
139 public void testFailedCanCommit() throws Exception {
140 final DOMDataTreeCommitCohort failedCohort = mock(DOMDataTreeCommitCohort.class);
142 doReturn(FAILED_CAN_COMMIT_FUTURE).when(failedCohort).canCommit(any(Object.class),
143 any(SchemaContext.class), any(Collection.class));
145 IntegrationTestKit kit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
146 try (AbstractDataStore dataStore = kit.setupAbstractDataStore(
147 DistributedDataStore.class, "testFailedCanCommit", "test-1")) {
148 dataStore.registerCommitCohort(TEST_ID, failedCohort);
150 IntegrationTestKit.verifyShardState(dataStore, "test-1",
151 state -> assertEquals("Cohort registrations", 1, state.getCommitCohortActors().size()));
153 DOMStoreWriteTransaction writeTx = dataStore.newWriteOnlyTransaction();
154 writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
155 DOMStoreThreePhaseCommitCohort dsCohort = writeTx.ready();
157 dsCohort.canCommit().get(5, TimeUnit.SECONDS);
158 fail("Exception should be raised.");
159 } catch (ExecutionException e) {
160 assertSame(FAILED_CAN_COMMIT, Throwables.getRootCause(e));
165 @SuppressWarnings({ "unchecked", "rawtypes" })
167 public void testCanCommitWithListEntries() throws Exception {
168 final DOMDataTreeCommitCohort cohort = mock(DOMDataTreeCommitCohort.class);
169 doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(Object.class),
170 any(SchemaContext.class), any(Collection.class));
171 IntegrationTestKit kit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
173 try (AbstractDataStore dataStore = kit.setupAbstractDataStore(
174 DistributedDataStore.class, "testCanCommitWithMultipleListEntries", "cars-1")) {
175 final ObjectRegistration<DOMDataTreeCommitCohort> cohortReg = dataStore.registerCommitCohort(
176 new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH
177 .node(CarsModel.CAR_QNAME)), cohort);
178 assertNotNull(cohortReg);
180 IntegrationTestKit.verifyShardState(dataStore, "cars-1",
181 state -> assertEquals("Cohort registrations", 1, state.getCommitCohortActors().size()));
183 // First write an empty base container and verify the cohort isn't invoked.
185 DOMStoreWriteTransaction writeTx = dataStore.newWriteOnlyTransaction();
186 writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
187 writeTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
188 kit.doCommit(writeTx.ready());
189 verifyNoMoreInteractions(cohort);
191 // Write a single car entry and verify the cohort is invoked.
193 writeTx = dataStore.newWriteOnlyTransaction();
194 final YangInstanceIdentifier optimaPath = CarsModel.newCarPath("optima");
195 final MapEntryNode optimaNode = CarsModel.newCarEntry("optima", Uint64.valueOf(20000));
196 writeTx.write(optimaPath, optimaNode);
197 kit.doCommit(writeTx.ready());
199 ArgumentCaptor<Collection> candidateCapture = ArgumentCaptor.forClass(Collection.class);
200 verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), candidateCapture.capture());
201 assertDataTreeCandidate((DOMDataTreeCandidate) candidateCapture.getValue().iterator().next(),
202 new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, optimaPath), ModificationType.WRITE,
203 Optional.of(optimaNode), Optional.empty());
205 // Write replace the cars container with 2 new car entries. The cohort should get invoked with 3
206 // DOMDataTreeCandidates: once for each of the 2 new car entries (WRITE mod) and once for the deleted prior
207 // car entry (DELETE mod).
210 doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(Object.class),
211 any(SchemaContext.class), any(Collection.class));
213 writeTx = dataStore.newWriteOnlyTransaction();
214 final YangInstanceIdentifier sportagePath = CarsModel.newCarPath("sportage");
215 final MapEntryNode sportageNode = CarsModel.newCarEntry("sportage", Uint64.valueOf(20000));
216 final YangInstanceIdentifier soulPath = CarsModel.newCarPath("soul");
217 final MapEntryNode soulNode = CarsModel.newCarEntry("soul", Uint64.valueOf(20000));
218 writeTx.write(CarsModel.BASE_PATH, CarsModel.newCarsNode(CarsModel.newCarsMapNode(sportageNode,soulNode)));
219 kit.doCommit(writeTx.ready());
221 candidateCapture = ArgumentCaptor.forClass(Collection.class);
222 verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), candidateCapture.capture());
224 assertDataTreeCandidate(findCandidate(candidateCapture, sportagePath), new DOMDataTreeIdentifier(
225 LogicalDatastoreType.CONFIGURATION, sportagePath), ModificationType.WRITE,
226 Optional.of(sportageNode), Optional.empty());
228 assertDataTreeCandidate(findCandidate(candidateCapture, soulPath), new DOMDataTreeIdentifier(
229 LogicalDatastoreType.CONFIGURATION, soulPath), ModificationType.WRITE,
230 Optional.of(soulNode), Optional.empty());
232 assertDataTreeCandidate(findCandidate(candidateCapture, optimaPath), new DOMDataTreeIdentifier(
233 LogicalDatastoreType.CONFIGURATION, optimaPath), ModificationType.DELETE,
234 Optional.empty(), Optional.of(optimaNode));
236 // Delete the cars container - cohort should be invoked for the 2 deleted car entries.
239 doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(Object.class),
240 any(SchemaContext.class), any(Collection.class));
242 writeTx = dataStore.newWriteOnlyTransaction();
243 writeTx.delete(CarsModel.BASE_PATH);
244 kit.doCommit(writeTx.ready());
246 candidateCapture = ArgumentCaptor.forClass(Collection.class);
247 verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), candidateCapture.capture());
249 assertDataTreeCandidate(findCandidate(candidateCapture, sportagePath), new DOMDataTreeIdentifier(
250 LogicalDatastoreType.CONFIGURATION, sportagePath), ModificationType.DELETE,
251 Optional.empty(), Optional.of(sportageNode));
253 assertDataTreeCandidate(findCandidate(candidateCapture, soulPath), new DOMDataTreeIdentifier(
254 LogicalDatastoreType.CONFIGURATION, soulPath), ModificationType.DELETE,
255 Optional.empty(), Optional.of(soulNode));
260 @SuppressWarnings("rawtypes")
261 private static DOMDataTreeCandidate findCandidate(final ArgumentCaptor<Collection> candidateCapture,
262 final YangInstanceIdentifier rootPath) {
263 for (Object obj: candidateCapture.getValue()) {
264 DOMDataTreeCandidate candidate = (DOMDataTreeCandidate)obj;
265 if (rootPath.equals(candidate.getRootPath().getRootIdentifier())) {
274 * FIXME: Since we invoke DOMDataTreeCommitCohort#canCommit on preCommit (as that's when we generate a
275 * DataTreeCandidate) and since currently preCommit is a noop in the Shard backend (it is combined with commit),
276 * we can't actually test abort after canCommit.
278 @SuppressWarnings("unchecked")
281 public void testAbortAfterCanCommit() throws Exception {
282 final DOMDataTreeCommitCohort cohortToAbort = mock(DOMDataTreeCommitCohort.class);
283 final PostCanCommitStep stepToAbort = mock(PostCanCommitStep.class);
284 doReturn(ThreePhaseCommitStep.NOOP_ABORT_FUTURE).when(stepToAbort).abort();
285 doReturn(PostPreCommitStep.NOOP_FUTURE).when(stepToAbort).preCommit();
286 doReturn(FluentFutures.immediateFluentFuture(stepToAbort)).when(cohortToAbort).canCommit(any(Object.class),
287 any(SchemaContext.class), any(Collection.class));
289 IntegrationTestKit kit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
290 try (AbstractDataStore dataStore = kit.setupAbstractDataStore(
291 DistributedDataStore.class, "testAbortAfterCanCommit", "test-1", "cars-1")) {
292 dataStore.registerCommitCohort(TEST_ID, cohortToAbort);
294 IntegrationTestKit.verifyShardState(dataStore, "test-1",
295 state -> assertEquals("Cohort registrations", 1, state.getCommitCohortActors().size()));
297 DOMStoreWriteTransaction writeTx = dataStore.newWriteOnlyTransaction();
298 writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
299 writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
300 DOMStoreThreePhaseCommitCohort dsCohort = writeTx.ready();
302 dsCohort.canCommit().get(5, TimeUnit.SECONDS);
303 dsCohort.preCommit().get(5, TimeUnit.SECONDS);
304 dsCohort.abort().get(5, TimeUnit.SECONDS);
305 verify(stepToAbort).abort();
309 private static void assertDataTreeCandidate(final DOMDataTreeCandidate candidate,
310 final DOMDataTreeIdentifier expTreeId, final ModificationType expType,
311 final Optional<NormalizedNode> expDataAfter, final Optional<NormalizedNode> expDataBefore) {
312 assertNotNull("Expected candidate for path " + expTreeId.getRootIdentifier(), candidate);
313 assertEquals("rootPath", expTreeId, candidate.getRootPath());
314 assertEquals("modificationType", expType, candidate.getRootNode().getModificationType());
316 assertEquals("dataAfter present", expDataAfter.isPresent(), candidate.getRootNode().getDataAfter().isPresent());
317 if (expDataAfter.isPresent()) {
318 assertEquals("dataAfter", expDataAfter.get(), candidate.getRootNode().getDataAfter().get());
321 assertEquals("dataBefore present", expDataBefore.isPresent(),
322 candidate.getRootNode().getDataBefore().isPresent());
323 if (expDataBefore.isPresent()) {
324 assertEquals("dataBefore", expDataBefore.get(), candidate.getRootNode().getDataBefore().get());