Bug 8391 - Close producer in become-prefix-leader rpc implementation
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / DistributedDataStoreRemotingIntegrationTest.java
1 /*
2  * Copyright (c) 2015, 2017 Brocade Communications Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8 package org.opendaylight.controller.cluster.datastore;
9
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertTrue;
13 import static org.junit.Assert.fail;
14 import static org.mockito.Matchers.any;
15 import static org.mockito.Matchers.eq;
16 import static org.mockito.Mockito.timeout;
17 import static org.mockito.Mockito.verify;
18
19 import akka.actor.ActorRef;
20 import akka.actor.ActorSelection;
21 import akka.actor.ActorSystem;
22 import akka.actor.Address;
23 import akka.actor.AddressFromURIString;
24 import akka.cluster.Cluster;
25 import akka.dispatch.Futures;
26 import akka.pattern.Patterns;
27 import akka.testkit.JavaTestKit;
28 import com.google.common.base.Optional;
29 import com.google.common.base.Stopwatch;
30 import com.google.common.base.Supplier;
31 import com.google.common.base.Throwables;
32 import com.google.common.collect.ImmutableMap;
33 import com.google.common.util.concurrent.ListenableFuture;
34 import com.google.common.util.concurrent.MoreExecutors;
35 import com.google.common.util.concurrent.Uninterruptibles;
36 import com.typesafe.config.ConfigFactory;
37 import java.math.BigInteger;
38 import java.util.Arrays;
39 import java.util.Collection;
40 import java.util.Collections;
41 import java.util.LinkedList;
42 import java.util.List;
43 import java.util.concurrent.ExecutionException;
44 import java.util.concurrent.TimeUnit;
45 import java.util.concurrent.atomic.AtomicLong;
46 import org.junit.After;
47 import org.junit.Assume;
48 import org.junit.Before;
49 import org.junit.Test;
50 import org.junit.runner.RunWith;
51 import org.junit.runners.Parameterized;
52 import org.junit.runners.Parameterized.Parameter;
53 import org.junit.runners.Parameterized.Parameters;
54 import org.mockito.Mockito;
55 import org.mockito.stubbing.Answer;
56 import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
57 import org.opendaylight.controller.cluster.databroker.ClientBackedDataStore;
58 import org.opendaylight.controller.cluster.databroker.ConcurrentDOMDataBroker;
59 import org.opendaylight.controller.cluster.datastore.DatastoreContext.Builder;
60 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
61 import org.opendaylight.controller.cluster.datastore.exceptions.ShardLeaderNotRespondingException;
62 import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
63 import org.opendaylight.controller.cluster.datastore.messages.ForwardedReadyTransaction;
64 import org.opendaylight.controller.cluster.datastore.messages.GetShardDataTree;
65 import org.opendaylight.controller.cluster.datastore.messages.ReadyLocalTransaction;
66 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
67 import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
68 import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
69 import org.opendaylight.controller.cluster.datastore.persisted.MetadataShardDataTreeSnapshot;
70 import org.opendaylight.controller.cluster.datastore.persisted.ShardSnapshotState;
71 import org.opendaylight.controller.cluster.raft.client.messages.Shutdown;
72 import org.opendaylight.controller.cluster.raft.persisted.ApplyJournalEntries;
73 import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
74 import org.opendaylight.controller.cluster.raft.policy.DisableElectionsRaftPolicy;
75 import org.opendaylight.controller.cluster.raft.utils.InMemoryJournal;
76 import org.opendaylight.controller.cluster.raft.utils.InMemorySnapshotStore;
77 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
78 import org.opendaylight.controller.md.cluster.datastore.model.PeopleModel;
79 import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
80 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
81 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
82 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
83 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
84 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
85 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
86 import org.opendaylight.controller.sal.core.spi.data.DOMStore;
87 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
88 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
89 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
90 import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
91 import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
92 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
93 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
94 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
95 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
96 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
97 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
98 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
99 import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
100 import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
101 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
102 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
103 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
104 import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
105 import scala.concurrent.Await;
106 import scala.concurrent.Future;
107 import scala.concurrent.duration.FiniteDuration;
108
109 /**
110  * End-to-end distributed data store tests that exercise remote shards and transactions.
111  *
112  * @author Thomas Pantelis
113  */
114 @RunWith(Parameterized.class)
115 public class DistributedDataStoreRemotingIntegrationTest extends AbstractTest {
116
117     @Parameters(name = "{0}")
118     public static Collection<Object[]> data() {
119         return Arrays.asList(new Object[][] {
120                 { DistributedDataStore.class, 7}, { ClientBackedDataStore.class, 60 }
121         });
122     }
123
124     @Parameter(0)
125     public Class<? extends AbstractDataStore> testParameter;
126     @Parameter(1)
127     public int commitTimeout;
128
129     private static final String[] CARS_AND_PEOPLE = {"cars", "people"};
130     private static final String[] CARS = {"cars"};
131
132     private static final Address MEMBER_1_ADDRESS = AddressFromURIString.parse(
133             "akka://cluster-test@127.0.0.1:2558");
134     private static final Address MEMBER_2_ADDRESS = AddressFromURIString.parse(
135             "akka://cluster-test@127.0.0.1:2559");
136
137     private static final String MODULE_SHARDS_CARS_ONLY_1_2 = "module-shards-cars-member-1-and-2.conf";
138     private static final String MODULE_SHARDS_CARS_PEOPLE_1_2 = "module-shards-member1-and-2.conf";
139     private static final String MODULE_SHARDS_CARS_PEOPLE_1_2_3 = "module-shards-member1-and-2-and-3.conf";
140
141     private ActorSystem leaderSystem;
142     private ActorSystem followerSystem;
143     private ActorSystem follower2System;
144
145     private final DatastoreContext.Builder leaderDatastoreContextBuilder =
146             DatastoreContext.newBuilder().shardHeartbeatIntervalInMillis(100).shardElectionTimeoutFactor(2);
147
148     private final DatastoreContext.Builder followerDatastoreContextBuilder =
149             DatastoreContext.newBuilder().shardHeartbeatIntervalInMillis(100).shardElectionTimeoutFactor(5)
150                 .customRaftPolicyImplementation(DisableElectionsRaftPolicy.class.getName());
151     private final TransactionIdentifier tx1 = nextTransactionId();
152     private final TransactionIdentifier tx2 = nextTransactionId();
153
154     private AbstractDataStore followerDistributedDataStore;
155     private AbstractDataStore leaderDistributedDataStore;
156     private IntegrationTestKit followerTestKit;
157     private IntegrationTestKit leaderTestKit;
158
159     @Before
160     public void setUp() {
161         InMemoryJournal.clear();
162         InMemorySnapshotStore.clear();
163
164         leaderSystem = ActorSystem.create("cluster-test", ConfigFactory.load().getConfig("Member1"));
165         Cluster.get(leaderSystem).join(MEMBER_1_ADDRESS);
166
167         followerSystem = ActorSystem.create("cluster-test", ConfigFactory.load().getConfig("Member2"));
168         Cluster.get(followerSystem).join(MEMBER_1_ADDRESS);
169
170         follower2System = ActorSystem.create("cluster-test", ConfigFactory.load().getConfig("Member3"));
171         Cluster.get(follower2System).join(MEMBER_1_ADDRESS);
172     }
173
174     @After
175     public void tearDown() {
176         if (followerDistributedDataStore != null) {
177             leaderDistributedDataStore.close();
178         }
179         if (leaderDistributedDataStore != null) {
180             leaderDistributedDataStore.close();
181         }
182
183         JavaTestKit.shutdownActorSystem(leaderSystem);
184         JavaTestKit.shutdownActorSystem(followerSystem);
185         JavaTestKit.shutdownActorSystem(follower2System);
186
187         InMemoryJournal.clear();
188         InMemorySnapshotStore.clear();
189     }
190
191     private void initDatastoresWithCars(final String type) throws Exception {
192         initDatastores(type, MODULE_SHARDS_CARS_ONLY_1_2, CARS);
193     }
194
195     private void initDatastoresWithCarsAndPeople(final String type) throws Exception {
196         initDatastores(type, MODULE_SHARDS_CARS_PEOPLE_1_2, CARS_AND_PEOPLE);
197     }
198
199     private void initDatastores(final String type, final String moduleShardsConfig, final String[] shards)
200             throws Exception {
201         leaderTestKit = new IntegrationTestKit(leaderSystem, leaderDatastoreContextBuilder, commitTimeout);
202
203         leaderDistributedDataStore = leaderTestKit.setupAbstractDataStore(
204                 testParameter, type, moduleShardsConfig, false, shards);
205
206         followerTestKit = new IntegrationTestKit(followerSystem, followerDatastoreContextBuilder, commitTimeout);
207         followerDistributedDataStore = followerTestKit.setupAbstractDataStore(
208                 testParameter, type, moduleShardsConfig, false, shards);
209
210         leaderTestKit.waitUntilLeader(leaderDistributedDataStore.getActorContext(), shards);
211
212         leaderTestKit.waitForMembersUp("member-2");
213         followerTestKit.waitForMembersUp("member-1");
214     }
215
216     private static void verifyCars(final DOMStoreReadTransaction readTx, final MapEntryNode... entries)
217             throws Exception {
218         final Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
219         assertEquals("isPresent", true, optional.isPresent());
220
221         final CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = ImmutableNodes.mapNodeBuilder(
222                 CarsModel.CAR_QNAME);
223         for (final NormalizedNode<?, ?> entry: entries) {
224             listBuilder.withChild((MapEntryNode) entry);
225         }
226
227         assertEquals("Car list node", listBuilder.build(), optional.get());
228     }
229
230     private static void verifyNode(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path,
231             final NormalizedNode<?, ?> expNode) throws Exception {
232         final Optional<NormalizedNode<?, ?>> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
233         assertEquals("isPresent", true, optional.isPresent());
234         assertEquals("Data node", expNode, optional.get());
235     }
236
237     private static void verifyExists(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path)
238             throws Exception {
239         final Boolean exists = readTx.exists(path).get(5, TimeUnit.SECONDS);
240         assertEquals("exists", true, exists);
241     }
242
243     @Test
244     public void testWriteTransactionWithSingleShard() throws Exception {
245         final String testName = "testWriteTransactionWithSingleShard";
246         initDatastoresWithCars(testName);
247
248         final String followerCarShardName = "member-2-shard-cars-" + testName;
249
250         DOMStoreWriteTransaction writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
251         assertNotNull("newWriteOnlyTransaction returned null", writeTx);
252
253         writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
254         writeTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
255
256         final MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
257         final YangInstanceIdentifier car1Path = CarsModel.newCarPath("optima");
258         writeTx.merge(car1Path, car1);
259
260         final MapEntryNode car2 = CarsModel.newCarEntry("sportage", BigInteger.valueOf(25000));
261         final YangInstanceIdentifier car2Path = CarsModel.newCarPath("sportage");
262         writeTx.merge(car2Path, car2);
263
264         followerTestKit.doCommit(writeTx.ready());
265
266         verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car1, car2);
267
268         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car1, car2);
269
270         // Test delete
271
272         writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
273
274         writeTx.delete(car1Path);
275
276         followerTestKit.doCommit(writeTx.ready());
277
278         verifyExists(followerDistributedDataStore.newReadOnlyTransaction(), car2Path);
279
280         verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car2);
281
282         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car2);
283
284         // Re-instate the follower member 2 as a single-node to verify replication and recovery.
285
286         // The following is a bit tricky. Before we reinstate the follower we need to ensure it has persisted and
287         // applied and all the log entries from the leader. Since we've verified the car data above we know that
288         // all the transactions have been applied on the leader so we first read and capture its lastAppliedIndex.
289         final AtomicLong leaderLastAppliedIndex = new AtomicLong();
290         IntegrationTestKit.verifyShardState(leaderDistributedDataStore, CARS[0],
291             state -> leaderLastAppliedIndex.set(state.getLastApplied()));
292
293         // Now we need to make sure the follower has persisted the leader's lastAppliedIndex via ApplyJournalEntries.
294         // However we don't know exactly how many ApplyJournalEntries messages there will be as it can differ between
295         // the tell-based and ask-based front-ends. For ask-based there will be exactly 2 ApplyJournalEntries but
296         // tell-based persists additional payloads which could be replicated and applied in a batch resulting in
297         // either 2 or 3 ApplyJournalEntries. To handle this we read the follower's persisted ApplyJournalEntries
298         // until we find the one that encompasses the leader's lastAppliedIndex.
299         Stopwatch sw = Stopwatch.createStarted();
300         boolean done = false;
301         while (!done) {
302             final List<ApplyJournalEntries> entries = InMemoryJournal.get(followerCarShardName,
303                     ApplyJournalEntries.class);
304             for (ApplyJournalEntries aje: entries) {
305                 if (aje.getToIndex() >= leaderLastAppliedIndex.get()) {
306                     done = true;
307                     break;
308                 }
309             }
310
311             assertTrue("Follower did not persist ApplyJournalEntries containing leader's lastAppliedIndex "
312                     + leaderLastAppliedIndex + ". Entries persisted: " + entries, sw.elapsed(TimeUnit.SECONDS) <= 5);
313
314             Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
315         }
316
317         JavaTestKit.shutdownActorSystem(leaderSystem, null, Boolean.TRUE);
318         JavaTestKit.shutdownActorSystem(followerSystem, null, Boolean.TRUE);
319
320         final ActorSystem newSystem = newActorSystem("reinstated-member2", "Member2");
321
322         try (AbstractDataStore member2Datastore = new IntegrationTestKit(newSystem, leaderDatastoreContextBuilder,
323                 commitTimeout)
324                 .setupAbstractDataStore(testParameter, testName, "module-shards-member2", true, CARS)) {
325             verifyCars(member2Datastore.newReadOnlyTransaction(), car2);
326         }
327     }
328
329     @Test
330     public void testReadWriteTransactionWithSingleShard() throws Exception {
331         initDatastoresWithCars("testReadWriteTransactionWithSingleShard");
332
333         final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
334         assertNotNull("newReadWriteTransaction returned null", rwTx);
335
336         rwTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
337         rwTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
338
339         final MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
340         rwTx.merge(CarsModel.newCarPath("optima"), car1);
341
342         verifyCars(rwTx, car1);
343
344         final MapEntryNode car2 = CarsModel.newCarEntry("sportage", BigInteger.valueOf(25000));
345         final YangInstanceIdentifier car2Path = CarsModel.newCarPath("sportage");
346         rwTx.merge(car2Path, car2);
347
348         verifyExists(rwTx, car2Path);
349
350         followerTestKit.doCommit(rwTx.ready());
351
352         verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car1, car2);
353     }
354
355     @Test
356     public void testWriteTransactionWithMultipleShards() throws Exception {
357         initDatastoresWithCarsAndPeople("testWriteTransactionWithMultipleShards");
358
359         final DOMStoreWriteTransaction writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
360         assertNotNull("newWriteOnlyTransaction returned null", writeTx);
361
362         final YangInstanceIdentifier carsPath = CarsModel.BASE_PATH;
363         final NormalizedNode<?, ?> carsNode = CarsModel.emptyContainer();
364         writeTx.write(carsPath, carsNode);
365
366         final YangInstanceIdentifier peoplePath = PeopleModel.BASE_PATH;
367         final NormalizedNode<?, ?> peopleNode = PeopleModel.emptyContainer();
368         writeTx.write(peoplePath, peopleNode);
369
370         followerTestKit.doCommit(writeTx.ready());
371
372         final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
373
374         verifyNode(readTx, carsPath, carsNode);
375         verifyNode(readTx, peoplePath, peopleNode);
376     }
377
378     @Test
379     public void testReadWriteTransactionWithMultipleShards() throws Exception {
380         initDatastoresWithCarsAndPeople("testReadWriteTransactionWithMultipleShards");
381
382         final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
383         assertNotNull("newReadWriteTransaction returned null", rwTx);
384
385         final YangInstanceIdentifier carsPath = CarsModel.BASE_PATH;
386         final NormalizedNode<?, ?> carsNode = CarsModel.emptyContainer();
387         rwTx.write(carsPath, carsNode);
388
389         final YangInstanceIdentifier peoplePath = PeopleModel.BASE_PATH;
390         final NormalizedNode<?, ?> peopleNode = PeopleModel.emptyContainer();
391         rwTx.write(peoplePath, peopleNode);
392
393         followerTestKit.doCommit(rwTx.ready());
394
395         final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
396
397         verifyNode(readTx, carsPath, carsNode);
398         verifyNode(readTx, peoplePath, peopleNode);
399     }
400
401     @Test
402     public void testTransactionChainWithSingleShard() throws Exception {
403         initDatastoresWithCars("testTransactionChainWithSingleShard");
404
405         final DOMStoreTransactionChain txChain = followerDistributedDataStore.createTransactionChain();
406
407         // Add the top-level cars container with write-only.
408
409         final DOMStoreWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
410         assertNotNull("newWriteOnlyTransaction returned null", writeTx);
411
412         writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
413
414         final DOMStoreThreePhaseCommitCohort writeTxReady = writeTx.ready();
415
416         // Verify the top-level cars container with read-only.
417
418         verifyNode(txChain.newReadOnlyTransaction(), CarsModel.BASE_PATH, CarsModel.emptyContainer());
419
420         // Perform car operations with read-write.
421
422         final DOMStoreReadWriteTransaction rwTx = txChain.newReadWriteTransaction();
423
424         verifyNode(rwTx, CarsModel.BASE_PATH, CarsModel.emptyContainer());
425
426         rwTx.merge(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
427
428         final MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
429         final YangInstanceIdentifier car1Path = CarsModel.newCarPath("optima");
430         rwTx.write(car1Path, car1);
431
432         verifyExists(rwTx, car1Path);
433
434         verifyCars(rwTx, car1);
435
436         final MapEntryNode car2 = CarsModel.newCarEntry("sportage", BigInteger.valueOf(25000));
437         rwTx.merge(CarsModel.newCarPath("sportage"), car2);
438
439         rwTx.delete(car1Path);
440
441         followerTestKit.doCommit(writeTxReady);
442
443         followerTestKit.doCommit(rwTx.ready());
444
445         txChain.close();
446
447         verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car2);
448     }
449
450     @Test
451     public void testTransactionChainWithMultipleShards() throws Exception {
452         initDatastoresWithCarsAndPeople("testTransactionChainWithMultipleShards");
453
454         final DOMStoreTransactionChain txChain = followerDistributedDataStore.createTransactionChain();
455
456         DOMStoreWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
457         assertNotNull("newWriteOnlyTransaction returned null", writeTx);
458
459         writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
460         writeTx.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
461
462         writeTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
463         writeTx.write(PeopleModel.PERSON_LIST_PATH, PeopleModel.newPersonMapNode());
464
465         followerTestKit.doCommit(writeTx.ready());
466
467         final DOMStoreReadWriteTransaction readWriteTx = txChain.newReadWriteTransaction();
468
469         final MapEntryNode car = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
470         final YangInstanceIdentifier carPath = CarsModel.newCarPath("optima");
471         readWriteTx.write(carPath, car);
472
473         final MapEntryNode person = PeopleModel.newPersonEntry("jack");
474         final YangInstanceIdentifier personPath = PeopleModel.newPersonPath("jack");
475         readWriteTx.merge(personPath, person);
476
477         Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
478         assertEquals("isPresent", true, optional.isPresent());
479         assertEquals("Data node", car, optional.get());
480
481         optional = readWriteTx.read(personPath).get(5, TimeUnit.SECONDS);
482         assertEquals("isPresent", true, optional.isPresent());
483         assertEquals("Data node", person, optional.get());
484
485         final DOMStoreThreePhaseCommitCohort cohort2 = readWriteTx.ready();
486
487         writeTx = txChain.newWriteOnlyTransaction();
488
489         writeTx.delete(personPath);
490
491         final DOMStoreThreePhaseCommitCohort cohort3 = writeTx.ready();
492
493         followerTestKit.doCommit(cohort2);
494         followerTestKit.doCommit(cohort3);
495
496         txChain.close();
497
498         final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
499         verifyCars(readTx, car);
500
501         optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
502         assertEquals("isPresent", false, optional.isPresent());
503     }
504
505     @Test
506     public void testChainedTransactionFailureWithSingleShard() throws Exception {
507         initDatastoresWithCars("testChainedTransactionFailureWithSingleShard");
508
509         final ConcurrentDOMDataBroker broker = new ConcurrentDOMDataBroker(
510                 ImmutableMap.<LogicalDatastoreType, DOMStore>builder().put(
511                         LogicalDatastoreType.CONFIGURATION, followerDistributedDataStore).build(),
512                         MoreExecutors.directExecutor());
513
514         final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
515         final DOMTransactionChain txChain = broker.createTransactionChain(listener);
516
517         final DOMDataWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
518
519         final ContainerNode invalidData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
520                 new YangInstanceIdentifier.NodeIdentifier(CarsModel.BASE_QNAME))
521                     .withChild(ImmutableNodes.leafNode(TestModel.JUNK_QNAME, "junk")).build();
522
523         writeTx.merge(LogicalDatastoreType.CONFIGURATION, CarsModel.BASE_PATH, invalidData);
524
525         try {
526             writeTx.submit().checkedGet(5, TimeUnit.SECONDS);
527             fail("Expected TransactionCommitFailedException");
528         } catch (final TransactionCommitFailedException e) {
529             // Expected
530         }
531
532         verify(listener, timeout(5000)).onTransactionChainFailed(eq(txChain), eq(writeTx), any(Throwable.class));
533
534         txChain.close();
535         broker.close();
536     }
537
538     @Test
539     public void testChainedTransactionFailureWithMultipleShards() throws Exception {
540         initDatastoresWithCarsAndPeople("testChainedTransactionFailureWithMultipleShards");
541
542         final ConcurrentDOMDataBroker broker = new ConcurrentDOMDataBroker(
543                 ImmutableMap.<LogicalDatastoreType, DOMStore>builder().put(
544                         LogicalDatastoreType.CONFIGURATION, followerDistributedDataStore).build(),
545                         MoreExecutors.directExecutor());
546
547         final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
548         final DOMTransactionChain txChain = broker.createTransactionChain(listener);
549
550         final DOMDataWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
551
552         writeTx.put(LogicalDatastoreType.CONFIGURATION, PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
553
554         final ContainerNode invalidData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
555                 new YangInstanceIdentifier.NodeIdentifier(CarsModel.BASE_QNAME))
556                     .withChild(ImmutableNodes.leafNode(TestModel.JUNK_QNAME, "junk")).build();
557
558         // Note that merge will validate the data and fail but put succeeds b/c deep validation is not
559         // done for put for performance reasons.
560         writeTx.merge(LogicalDatastoreType.CONFIGURATION, CarsModel.BASE_PATH, invalidData);
561
562         try {
563             writeTx.submit().checkedGet(5, TimeUnit.SECONDS);
564             fail("Expected TransactionCommitFailedException");
565         } catch (final TransactionCommitFailedException e) {
566             // Expected
567         }
568
569         verify(listener, timeout(5000)).onTransactionChainFailed(eq(txChain), eq(writeTx), any(Throwable.class));
570
571         txChain.close();
572         broker.close();
573     }
574
575     @Test
576     public void testSingleShardTransactionsWithLeaderChanges() throws Exception {
577         final String testName = "testSingleShardTransactionsWithLeaderChanges";
578         initDatastoresWithCars(testName);
579
580         final String followerCarShardName = "member-2-shard-cars-" + testName;
581         InMemoryJournal.addWriteMessagesCompleteLatch(followerCarShardName, 1, ApplyJournalEntries.class);
582
583         // Write top-level car container from the follower so it uses a remote Tx.
584
585         DOMStoreWriteTransaction writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
586
587         writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
588         writeTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
589
590         followerTestKit.doCommit(writeTx.ready());
591
592         InMemoryJournal.waitForWriteMessagesComplete(followerCarShardName);
593
594         // Switch the leader to the follower
595
596         sendDatastoreContextUpdate(followerDistributedDataStore, followerDatastoreContextBuilder
597                 .shardElectionTimeoutFactor(1).customRaftPolicyImplementation(null));
598
599         JavaTestKit.shutdownActorSystem(leaderSystem, null, true);
600         Cluster.get(followerSystem).leave(MEMBER_1_ADDRESS);
601
602         followerTestKit.waitUntilNoLeader(followerDistributedDataStore.getActorContext(), CARS);
603
604         leaderSystem = ActorSystem.create("cluster-test", ConfigFactory.load().getConfig("Member1"));
605         Cluster.get(leaderSystem).join(MEMBER_2_ADDRESS);
606
607         final DatastoreContext.Builder newMember1Builder = DatastoreContext.newBuilder()
608                 .shardHeartbeatIntervalInMillis(100).shardElectionTimeoutFactor(5);
609         IntegrationTestKit newMember1TestKit = new IntegrationTestKit(leaderSystem, newMember1Builder, commitTimeout);
610
611         try (AbstractDataStore ds =
612                 newMember1TestKit.setupAbstractDataStore(
613                         testParameter, testName, MODULE_SHARDS_CARS_ONLY_1_2, false, CARS)) {
614
615             followerTestKit.waitUntilLeader(followerDistributedDataStore.getActorContext(), CARS);
616
617             // Write a car entry to the new leader - should switch to local Tx
618
619             writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
620
621             MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
622             YangInstanceIdentifier car1Path = CarsModel.newCarPath("optima");
623             writeTx.merge(car1Path, car1);
624
625             followerTestKit.doCommit(writeTx.ready());
626
627             verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car1);
628         }
629     }
630
631     @SuppressWarnings("unchecked")
632     @Test
633     public void testReadyLocalTransactionForwardedToLeader() throws Exception {
634         initDatastoresWithCars("testReadyLocalTransactionForwardedToLeader");
635         followerTestKit.waitUntilLeader(followerDistributedDataStore.getActorContext(), "cars");
636
637         final Optional<ActorRef> carsFollowerShard = followerDistributedDataStore.getActorContext()
638                 .findLocalShard("cars");
639         assertEquals("Cars follower shard found", true, carsFollowerShard.isPresent());
640
641         final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
642         dataTree.setSchemaContext(SchemaContextHelper.full());
643
644         // Send a tx with immediate commit.
645
646         DataTreeModification modification = dataTree.takeSnapshot().newModification();
647         new WriteModification(CarsModel.BASE_PATH, CarsModel.emptyContainer()).apply(modification);
648         new MergeModification(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()).apply(modification);
649
650         final MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
651         new WriteModification(CarsModel.newCarPath("optima"), car1).apply(modification);
652         modification.ready();
653
654         ReadyLocalTransaction readyLocal = new ReadyLocalTransaction(tx1 , modification, true);
655
656         carsFollowerShard.get().tell(readyLocal, followerTestKit.getRef());
657         Object resp = followerTestKit.expectMsgClass(Object.class);
658         if (resp instanceof akka.actor.Status.Failure) {
659             throw new AssertionError("Unexpected failure response", ((akka.actor.Status.Failure)resp).cause());
660         }
661
662         assertEquals("Response type", CommitTransactionReply.class, resp.getClass());
663
664         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car1);
665
666         // Send another tx without immediate commit.
667
668         modification = dataTree.takeSnapshot().newModification();
669         MapEntryNode car2 = CarsModel.newCarEntry("sportage", BigInteger.valueOf(30000));
670         new WriteModification(CarsModel.newCarPath("sportage"), car2).apply(modification);
671         modification.ready();
672
673         readyLocal = new ReadyLocalTransaction(tx2 , modification, false);
674
675         carsFollowerShard.get().tell(readyLocal, followerTestKit.getRef());
676         resp = followerTestKit.expectMsgClass(Object.class);
677         if (resp instanceof akka.actor.Status.Failure) {
678             throw new AssertionError("Unexpected failure response", ((akka.actor.Status.Failure)resp).cause());
679         }
680
681         assertEquals("Response type", ReadyTransactionReply.class, resp.getClass());
682
683         final ActorSelection txActor = leaderDistributedDataStore.getActorContext().actorSelection(
684                 ((ReadyTransactionReply)resp).getCohortPath());
685
686         final Supplier<Short> versionSupplier = Mockito.mock(Supplier.class);
687         Mockito.doReturn(DataStoreVersions.CURRENT_VERSION).when(versionSupplier).get();
688         ThreePhaseCommitCohortProxy cohort = new ThreePhaseCommitCohortProxy(
689                 leaderDistributedDataStore.getActorContext(), Arrays.asList(
690                         new ThreePhaseCommitCohortProxy.CohortInfo(Futures.successful(txActor), versionSupplier)), tx2);
691         cohort.canCommit().get(5, TimeUnit.SECONDS);
692         cohort.preCommit().get(5, TimeUnit.SECONDS);
693         cohort.commit().get(5, TimeUnit.SECONDS);
694
695         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car1, car2);
696     }
697
698     @SuppressWarnings("unchecked")
699     @Test
700     public void testForwardedReadyTransactionForwardedToLeader() throws Exception {
701         initDatastoresWithCars("testForwardedReadyTransactionForwardedToLeader");
702         followerTestKit.waitUntilLeader(followerDistributedDataStore.getActorContext(), "cars");
703
704         final Optional<ActorRef> carsFollowerShard = followerDistributedDataStore.getActorContext()
705                 .findLocalShard("cars");
706         assertEquals("Cars follower shard found", true, carsFollowerShard.isPresent());
707
708         carsFollowerShard.get().tell(GetShardDataTree.INSTANCE, followerTestKit.getRef());
709         final DataTree dataTree = followerTestKit.expectMsgClass(DataTree.class);
710
711         // Send a tx with immediate commit.
712
713         DataTreeModification modification = dataTree.takeSnapshot().newModification();
714         new WriteModification(CarsModel.BASE_PATH, CarsModel.emptyContainer()).apply(modification);
715         new MergeModification(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()).apply(modification);
716
717         final MapEntryNode car1 = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
718         new WriteModification(CarsModel.newCarPath("optima"), car1).apply(modification);
719
720         ForwardedReadyTransaction forwardedReady = new ForwardedReadyTransaction(tx1,
721                 DataStoreVersions.CURRENT_VERSION, new ReadWriteShardDataTreeTransaction(
722                         Mockito.mock(ShardDataTreeTransactionParent.class), tx1, modification), true);
723
724         carsFollowerShard.get().tell(forwardedReady, followerTestKit.getRef());
725         Object resp = followerTestKit.expectMsgClass(Object.class);
726         if (resp instanceof akka.actor.Status.Failure) {
727             throw new AssertionError("Unexpected failure response", ((akka.actor.Status.Failure)resp).cause());
728         }
729
730         assertEquals("Response type", CommitTransactionReply.class, resp.getClass());
731
732         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car1);
733
734         // Send another tx without immediate commit.
735
736         modification = dataTree.takeSnapshot().newModification();
737         MapEntryNode car2 = CarsModel.newCarEntry("sportage", BigInteger.valueOf(30000));
738         new WriteModification(CarsModel.newCarPath("sportage"), car2).apply(modification);
739
740         forwardedReady = new ForwardedReadyTransaction(tx2,
741                 DataStoreVersions.CURRENT_VERSION, new ReadWriteShardDataTreeTransaction(
742                         Mockito.mock(ShardDataTreeTransactionParent.class), tx2, modification), false);
743
744         carsFollowerShard.get().tell(forwardedReady, followerTestKit.getRef());
745         resp = followerTestKit.expectMsgClass(Object.class);
746         if (resp instanceof akka.actor.Status.Failure) {
747             throw new AssertionError("Unexpected failure response", ((akka.actor.Status.Failure)resp).cause());
748         }
749
750         assertEquals("Response type", ReadyTransactionReply.class, resp.getClass());
751
752         ActorSelection txActor = leaderDistributedDataStore.getActorContext().actorSelection(
753                 ((ReadyTransactionReply)resp).getCohortPath());
754
755         final Supplier<Short> versionSupplier = Mockito.mock(Supplier.class);
756         Mockito.doReturn(DataStoreVersions.CURRENT_VERSION).when(versionSupplier).get();
757         final ThreePhaseCommitCohortProxy cohort = new ThreePhaseCommitCohortProxy(
758                 leaderDistributedDataStore.getActorContext(), Arrays.asList(
759                         new ThreePhaseCommitCohortProxy.CohortInfo(Futures.successful(txActor), versionSupplier)), tx2);
760         cohort.canCommit().get(5, TimeUnit.SECONDS);
761         cohort.preCommit().get(5, TimeUnit.SECONDS);
762         cohort.commit().get(5, TimeUnit.SECONDS);
763
764         verifyCars(leaderDistributedDataStore.newReadOnlyTransaction(), car1, car2);
765     }
766
767     @Test
768     public void testTransactionForwardedToLeaderAfterRetry() throws Exception {
769         //TODO remove when test passes also for ClientBackedDataStore
770         Assume.assumeTrue(testParameter.equals(DistributedDataStore.class));
771         followerDatastoreContextBuilder.shardBatchedModificationCount(2);
772         leaderDatastoreContextBuilder.shardBatchedModificationCount(2);
773         initDatastoresWithCarsAndPeople("testTransactionForwardedToLeaderAfterRetry");
774
775         // Do an initial write to get the primary shard info cached.
776
777         final DOMStoreWriteTransaction initialWriteTx = followerDistributedDataStore.newWriteOnlyTransaction();
778         initialWriteTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
779         initialWriteTx.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
780         followerTestKit.doCommit(initialWriteTx.ready());
781
782         // Wait for the commit to be replicated to the follower.
783
784         MemberNode.verifyRaftState(followerDistributedDataStore, "cars",
785             raftState -> assertEquals("getLastApplied", 0, raftState.getLastApplied()));
786
787         MemberNode.verifyRaftState(followerDistributedDataStore, "people",
788             raftState -> assertEquals("getLastApplied", 0, raftState.getLastApplied()));
789
790         // Prepare, ready and canCommit a WO tx that writes to 2 shards. This will become the current tx in
791         // the leader shard.
792
793         final DOMStoreWriteTransaction writeTx1 = followerDistributedDataStore.newWriteOnlyTransaction();
794         writeTx1.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
795         writeTx1.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
796         final DOMStoreThreePhaseCommitCohort writeTx1Cohort = writeTx1.ready();
797         final ListenableFuture<Boolean> writeTx1CanCommit = writeTx1Cohort.canCommit();
798         writeTx1CanCommit.get(5, TimeUnit.SECONDS);
799
800         // Prepare and ready another WO tx that writes to 2 shards but don't canCommit yet. This will be queued
801         // in the leader shard.
802
803         final DOMStoreWriteTransaction writeTx2 = followerDistributedDataStore.newWriteOnlyTransaction();
804         final LinkedList<MapEntryNode> cars = new LinkedList<>();
805         int carIndex = 1;
806         cars.add(CarsModel.newCarEntry("car" + carIndex, BigInteger.valueOf(carIndex)));
807         writeTx2.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
808         carIndex++;
809         NormalizedNode<?, ?> people = PeopleModel.newPersonMapNode();
810         writeTx2.write(PeopleModel.PERSON_LIST_PATH, people);
811         final DOMStoreThreePhaseCommitCohort writeTx2Cohort = writeTx2.ready();
812
813         // Prepare another WO that writes to a single shard and thus will be directly committed on ready. This
814         // tx writes 5 cars so 2 BatchedModidifications messages will be sent initially and cached in the
815         // leader shard (with shardBatchedModificationCount set to 2). The 3rd BatchedModidifications will be
816         // sent on ready.
817
818         final DOMStoreWriteTransaction writeTx3 = followerDistributedDataStore.newWriteOnlyTransaction();
819         for (int i = 1; i <= 5; i++, carIndex++) {
820             cars.add(CarsModel.newCarEntry("car" + carIndex, BigInteger.valueOf(carIndex)));
821             writeTx3.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
822         }
823
824         // Prepare another WO that writes to a single shard. This will send a single BatchedModidifications
825         // message on ready.
826
827         final DOMStoreWriteTransaction writeTx4 = followerDistributedDataStore.newWriteOnlyTransaction();
828         cars.add(CarsModel.newCarEntry("car" + carIndex, BigInteger.valueOf(carIndex)));
829         writeTx4.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
830         carIndex++;
831
832         // Prepare a RW tx that will create a tx actor and send a ForwardedReadyTransaciton message to the
833         // leader shard on ready.
834
835         final DOMStoreReadWriteTransaction readWriteTx = followerDistributedDataStore.newReadWriteTransaction();
836         cars.add(CarsModel.newCarEntry("car" + carIndex, BigInteger.valueOf(carIndex)));
837         readWriteTx.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
838
839         IntegrationTestKit.verifyShardStats(leaderDistributedDataStore, "cars",
840             stats -> assertEquals("getReadWriteTransactionCount", 1, stats.getReadWriteTransactionCount()));
841
842         // Disable elections on the leader so it switches to follower.
843
844         sendDatastoreContextUpdate(leaderDistributedDataStore, leaderDatastoreContextBuilder
845                 .customRaftPolicyImplementation(DisableElectionsRaftPolicy.class.getName())
846                 .shardElectionTimeoutFactor(10));
847
848         Cluster.get(followerSystem).leave(MEMBER_1_ADDRESS);
849         leaderTestKit.waitUntilNoLeader(leaderDistributedDataStore.getActorContext(), "cars");
850
851         // Submit all tx's - the messages should get queued for retry.
852
853         final ListenableFuture<Boolean> writeTx2CanCommit = writeTx2Cohort.canCommit();
854         final DOMStoreThreePhaseCommitCohort writeTx3Cohort = writeTx3.ready();
855         final DOMStoreThreePhaseCommitCohort writeTx4Cohort = writeTx4.ready();
856         final DOMStoreThreePhaseCommitCohort rwTxCohort = readWriteTx.ready();
857
858         // Enable elections on the other follower so it becomes the leader, at which point the
859         // tx's should get forwarded from the previous leader to the new leader to complete the commits.
860
861         sendDatastoreContextUpdate(followerDistributedDataStore, followerDatastoreContextBuilder
862                 .customRaftPolicyImplementation(null).shardElectionTimeoutFactor(1));
863
864         followerTestKit.doCommit(writeTx1CanCommit, writeTx1Cohort);
865         followerTestKit.doCommit(writeTx2CanCommit, writeTx2Cohort);
866         followerTestKit.doCommit(writeTx3Cohort);
867         followerTestKit.doCommit(writeTx4Cohort);
868         followerTestKit.doCommit(rwTxCohort);
869
870         DOMStoreReadTransaction readTx = leaderDistributedDataStore.newReadOnlyTransaction();
871         verifyCars(readTx, cars.toArray(new MapEntryNode[cars.size()]));
872         verifyNode(readTx, PeopleModel.PERSON_LIST_PATH, people);
873     }
874
875     @Test
876     public void testLeadershipTransferOnShutdown() throws Exception {
877         //TODO remove when test passes also for ClientBackedDataStore
878         Assume.assumeTrue(testParameter.equals(DistributedDataStore.class));
879         leaderDatastoreContextBuilder.shardBatchedModificationCount(1);
880         followerDatastoreContextBuilder.shardElectionTimeoutFactor(10).customRaftPolicyImplementation(null);
881         final String testName = "testLeadershipTransferOnShutdown";
882         initDatastores(testName, MODULE_SHARDS_CARS_PEOPLE_1_2_3, CARS_AND_PEOPLE);
883
884         final IntegrationTestKit follower2TestKit = new IntegrationTestKit(follower2System,
885                 DatastoreContext.newBuilderFrom(followerDatastoreContextBuilder.build()).operationTimeoutInMillis(100),
886                 commitTimeout);
887         try (AbstractDataStore follower2DistributedDataStore = follower2TestKit.setupAbstractDataStore(
888                 testParameter, testName, MODULE_SHARDS_CARS_PEOPLE_1_2_3, false)) {
889
890             followerTestKit.waitForMembersUp("member-3");
891             follower2TestKit.waitForMembersUp("member-1", "member-2");
892
893             // Create and submit a couple tx's so they're pending.
894
895             DOMStoreWriteTransaction writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
896             writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
897             writeTx.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
898             writeTx.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
899             final DOMStoreThreePhaseCommitCohort cohort1 = writeTx.ready();
900
901             IntegrationTestKit.verifyShardStats(leaderDistributedDataStore, "cars",
902                 stats -> assertEquals("getTxCohortCacheSize", 1, stats.getTxCohortCacheSize()));
903
904             writeTx = followerDistributedDataStore.newWriteOnlyTransaction();
905             final MapEntryNode car = CarsModel.newCarEntry("optima", BigInteger.valueOf(20000));
906             writeTx.write(CarsModel.newCarPath("optima"), car);
907             final DOMStoreThreePhaseCommitCohort cohort2 = writeTx.ready();
908
909             IntegrationTestKit.verifyShardStats(leaderDistributedDataStore, "cars",
910                 stats -> assertEquals("getTxCohortCacheSize", 2, stats.getTxCohortCacheSize()));
911
912             // Gracefully stop the leader via a Shutdown message.
913
914             sendDatastoreContextUpdate(leaderDistributedDataStore, leaderDatastoreContextBuilder
915                 .shardElectionTimeoutFactor(100));
916
917             final FiniteDuration duration = FiniteDuration.create(5, TimeUnit.SECONDS);
918             final Future<ActorRef> future = leaderDistributedDataStore.getActorContext().findLocalShardAsync("cars");
919             final ActorRef leaderActor = Await.result(future, duration);
920
921             final Future<Boolean> stopFuture = Patterns.gracefulStop(leaderActor, duration, Shutdown.INSTANCE);
922
923             // Commit the 2 transactions. They should finish and succeed.
924
925             followerTestKit.doCommit(cohort1);
926             followerTestKit.doCommit(cohort2);
927
928             // Wait for the leader actor stopped.
929
930             final Boolean stopped = Await.result(stopFuture, duration);
931             assertEquals("Stopped", Boolean.TRUE, stopped);
932
933             // Verify leadership was transferred by reading the committed data from the other nodes.
934
935             verifyCars(followerDistributedDataStore.newReadOnlyTransaction(), car);
936             verifyCars(follower2DistributedDataStore.newReadOnlyTransaction(), car);
937         }
938     }
939
940     @Test
941     public void testTransactionWithIsolatedLeader() throws Exception {
942         //TODO remove when test passes also for ClientBackedDataStore
943         Assume.assumeTrue(testParameter.equals(DistributedDataStore.class));
944         // Set the isolated leader check interval high so we can control the switch to IsolatedLeader.
945         leaderDatastoreContextBuilder.shardIsolatedLeaderCheckIntervalInMillis(10000000);
946         final String testName = "testTransactionWithIsolatedLeader";
947         initDatastoresWithCars(testName);
948
949         // Tx that is submitted after the follower is stopped but before the leader transitions to IsolatedLeader.
950         final DOMStoreWriteTransaction preIsolatedLeaderWriteTx = leaderDistributedDataStore.newWriteOnlyTransaction();
951         preIsolatedLeaderWriteTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
952
953         // Tx that is submitted after the leader transitions to IsolatedLeader.
954         final DOMStoreWriteTransaction noShardLeaderWriteTx = leaderDistributedDataStore.newWriteOnlyTransaction();
955         noShardLeaderWriteTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
956
957         // Tx that is submitted after the follower is reinstated.
958         final DOMStoreWriteTransaction successWriteTx = leaderDistributedDataStore.newWriteOnlyTransaction();
959         successWriteTx.merge(CarsModel.BASE_PATH, CarsModel.emptyContainer());
960
961         // Stop the follower
962         followerTestKit.watch(followerDistributedDataStore.getActorContext().getShardManager());
963         followerDistributedDataStore.close();
964         followerTestKit.expectTerminated(followerDistributedDataStore.getActorContext().getShardManager());
965
966         // Submit the preIsolatedLeaderWriteTx so it's pending
967         final DOMStoreThreePhaseCommitCohort preIsolatedLeaderTxCohort = preIsolatedLeaderWriteTx.ready();
968
969         // Change the isolated leader check interval low so it changes to IsolatedLeader.
970         sendDatastoreContextUpdate(leaderDistributedDataStore, leaderDatastoreContextBuilder
971                 .shardIsolatedLeaderCheckIntervalInMillis(200));
972
973         MemberNode.verifyRaftState(leaderDistributedDataStore, "cars",
974             raftState -> assertEquals("getRaftState", "IsolatedLeader", raftState.getRaftState()));
975
976         try {
977             leaderTestKit.doCommit(noShardLeaderWriteTx.ready());
978             fail("Expected NoShardLeaderException");
979         } catch (final ExecutionException e) {
980             assertEquals("getCause", NoShardLeaderException.class, Throwables.getRootCause(e).getClass());
981         }
982
983         sendDatastoreContextUpdate(leaderDistributedDataStore, leaderDatastoreContextBuilder
984                 .shardElectionTimeoutFactor(100));
985
986         final DOMStoreThreePhaseCommitCohort successTxCohort = successWriteTx.ready();
987
988         followerDistributedDataStore = followerTestKit.setupAbstractDataStore(
989                 testParameter, testName, MODULE_SHARDS_CARS_ONLY_1_2, false, CARS);
990
991         leaderTestKit.doCommit(preIsolatedLeaderTxCohort);
992         leaderTestKit.doCommit(successTxCohort);
993     }
994
995     @Test
996     public void testTransactionWithShardLeaderNotResponding() throws Exception {
997         followerDatastoreContextBuilder.shardElectionTimeoutFactor(50);
998         initDatastoresWithCars("testTransactionWithShardLeaderNotResponding");
999
1000         // Do an initial read to get the primary shard info cached.
1001
1002         final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
1003         readTx.read(CarsModel.BASE_PATH).checkedGet(5, TimeUnit.SECONDS);
1004
1005         // Shutdown the leader and try to create a new tx.
1006
1007         JavaTestKit.shutdownActorSystem(leaderSystem, null, true);
1008
1009         followerDatastoreContextBuilder.operationTimeoutInMillis(50).shardElectionTimeoutFactor(1);
1010         sendDatastoreContextUpdate(followerDistributedDataStore, followerDatastoreContextBuilder);
1011
1012         final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
1013
1014         rwTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
1015
1016         try {
1017             followerTestKit.doCommit(rwTx.ready());
1018             fail("Exception expected");
1019         } catch (final ExecutionException e) {
1020             final String msg = "Unexpected exception: " + Throwables.getStackTraceAsString(e.getCause());
1021             assertTrue(msg, Throwables.getRootCause(e) instanceof NoShardLeaderException
1022                     || e.getCause() instanceof ShardLeaderNotRespondingException);
1023         }
1024     }
1025
1026     @Test
1027     public void testTransactionWithCreateTxFailureDueToNoLeader() throws Exception {
1028         initDatastoresWithCars("testTransactionWithCreateTxFailureDueToNoLeader");
1029
1030         // Do an initial read to get the primary shard info cached.
1031
1032         final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
1033         readTx.read(CarsModel.BASE_PATH).checkedGet(5, TimeUnit.SECONDS);
1034
1035         // Shutdown the leader and try to create a new tx.
1036
1037         JavaTestKit.shutdownActorSystem(leaderSystem, null, true);
1038
1039         Cluster.get(followerSystem).leave(MEMBER_1_ADDRESS);
1040
1041         Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
1042
1043         sendDatastoreContextUpdate(followerDistributedDataStore, followerDatastoreContextBuilder
1044                 .operationTimeoutInMillis(10).shardElectionTimeoutFactor(1).customRaftPolicyImplementation(null));
1045
1046         final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
1047
1048         rwTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
1049
1050         try {
1051             followerTestKit.doCommit(rwTx.ready());
1052             fail("Exception expected");
1053         } catch (final ExecutionException e) {
1054             final String msg = "Expected instance of NoShardLeaderException, actual: \n"
1055                     + Throwables.getStackTraceAsString(e.getCause());
1056             assertTrue(msg, Throwables.getRootCause(e) instanceof NoShardLeaderException);
1057         }
1058     }
1059
1060     @Test
1061     public void testTransactionRetryWithInitialAskTimeoutExOnCreateTx() throws Exception {
1062         String testName = "testTransactionRetryWithInitialAskTimeoutExOnCreateTx";
1063         initDatastores(testName, MODULE_SHARDS_CARS_PEOPLE_1_2_3, CARS);
1064
1065         final DatastoreContext.Builder follower2DatastoreContextBuilder = DatastoreContext.newBuilder()
1066                 .shardHeartbeatIntervalInMillis(100).shardElectionTimeoutFactor(5);
1067         final IntegrationTestKit follower2TestKit = new IntegrationTestKit(
1068                 follower2System, follower2DatastoreContextBuilder, commitTimeout);
1069
1070         try (AbstractDataStore ds =
1071                 follower2TestKit.setupAbstractDataStore(
1072                         testParameter, testName, MODULE_SHARDS_CARS_PEOPLE_1_2_3, false, CARS)) {
1073
1074             followerTestKit.waitForMembersUp("member-1", "member-3");
1075             follower2TestKit.waitForMembersUp("member-1", "member-2");
1076
1077             // Do an initial read to get the primary shard info cached.
1078
1079             final DOMStoreReadTransaction readTx = followerDistributedDataStore.newReadOnlyTransaction();
1080             readTx.read(CarsModel.BASE_PATH).checkedGet(5, TimeUnit.SECONDS);
1081
1082             // Shutdown the leader and try to create a new tx.
1083
1084             JavaTestKit.shutdownActorSystem(leaderSystem, null, true);
1085
1086             Cluster.get(followerSystem).leave(MEMBER_1_ADDRESS);
1087
1088             sendDatastoreContextUpdate(followerDistributedDataStore, followerDatastoreContextBuilder
1089                 .operationTimeoutInMillis(500).shardElectionTimeoutFactor(1).customRaftPolicyImplementation(null));
1090
1091             final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
1092
1093             rwTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
1094
1095             followerTestKit.doCommit(rwTx.ready());
1096         }
1097     }
1098
1099     @Test
1100     public void testInstallSnapshot() throws Exception {
1101         final String testName = "testInstallSnapshot";
1102         final String leaderCarShardName = "member-1-shard-cars-" + testName;
1103         final String followerCarShardName = "member-2-shard-cars-" + testName;
1104
1105         // Setup a saved snapshot on the leader. The follower will startup with no data and the leader should
1106         // install a snapshot to sync the follower.
1107
1108         TipProducingDataTree tree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
1109         tree.setSchemaContext(SchemaContextHelper.full());
1110
1111         final ContainerNode carsNode = CarsModel.newCarsNode(
1112                 CarsModel.newCarsMapNode(CarsModel.newCarEntry("optima", BigInteger.valueOf(20000))));
1113         AbstractShardTest.writeToStore(tree, CarsModel.BASE_PATH, carsNode);
1114
1115         final NormalizedNode<?, ?> snapshotRoot = AbstractShardTest.readStore(tree, YangInstanceIdentifier.EMPTY);
1116         final Snapshot initialSnapshot = Snapshot.create(
1117                 new ShardSnapshotState(new MetadataShardDataTreeSnapshot(snapshotRoot)),
1118                 Collections.emptyList(), 5, 1, 5, 1, 1, null, null);
1119         InMemorySnapshotStore.addSnapshot(leaderCarShardName, initialSnapshot);
1120
1121         InMemorySnapshotStore.addSnapshotSavedLatch(leaderCarShardName);
1122         InMemorySnapshotStore.addSnapshotSavedLatch(followerCarShardName);
1123
1124         initDatastoresWithCars(testName);
1125
1126         final Optional<NormalizedNode<?, ?>> readOptional = leaderDistributedDataStore.newReadOnlyTransaction().read(
1127                 CarsModel.BASE_PATH).checkedGet(5, TimeUnit.SECONDS);
1128         assertEquals("isPresent", true, readOptional.isPresent());
1129         assertEquals("Node", carsNode, readOptional.get());
1130
1131         verifySnapshot(InMemorySnapshotStore.waitForSavedSnapshot(leaderCarShardName, Snapshot.class),
1132                 initialSnapshot, snapshotRoot);
1133
1134         verifySnapshot(InMemorySnapshotStore.waitForSavedSnapshot(followerCarShardName, Snapshot.class),
1135                 initialSnapshot, snapshotRoot);
1136     }
1137
1138     private static void verifySnapshot(final Snapshot actual, final Snapshot expected,
1139                                        final NormalizedNode<?, ?> expRoot) {
1140         assertEquals("Snapshot getLastAppliedTerm", expected.getLastAppliedTerm(), actual.getLastAppliedTerm());
1141         assertEquals("Snapshot getLastAppliedIndex", expected.getLastAppliedIndex(), actual.getLastAppliedIndex());
1142         assertEquals("Snapshot getLastTerm", expected.getLastTerm(), actual.getLastTerm());
1143         assertEquals("Snapshot getLastIndex", expected.getLastIndex(), actual.getLastIndex());
1144         assertEquals("Snapshot state type", ShardSnapshotState.class, actual.getState().getClass());
1145         MetadataShardDataTreeSnapshot shardSnapshot =
1146                 (MetadataShardDataTreeSnapshot) ((ShardSnapshotState)actual.getState()).getSnapshot();
1147         assertEquals("Snapshot root node", expRoot, shardSnapshot.getRootNode().get());
1148     }
1149
1150     private static void sendDatastoreContextUpdate(final AbstractDataStore dataStore, final Builder builder) {
1151         final Builder newBuilder = DatastoreContext.newBuilderFrom(builder.build());
1152         final DatastoreContextFactory mockContextFactory = Mockito.mock(DatastoreContextFactory.class);
1153         final Answer<DatastoreContext> answer = invocation -> newBuilder.build();
1154         Mockito.doAnswer(answer).when(mockContextFactory).getBaseDatastoreContext();
1155         Mockito.doAnswer(answer).when(mockContextFactory).getShardDatastoreContext(Mockito.anyString());
1156         dataStore.onDatastoreContextUpdated(mockContextFactory);
1157     }
1158 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.