2 * Copyright (c) 2014, 2015 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
9 package org.opendaylight.controller.cluster.datastore;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.mockito.Matchers.any;
15 import static org.mockito.Matchers.anyString;
16 import static org.mockito.Matchers.eq;
17 import static org.mockito.Matchers.isA;
18 import static org.mockito.Mockito.doReturn;
19 import static org.mockito.Mockito.doThrow;
20 import static org.mockito.Mockito.mock;
21 import static org.mockito.Mockito.never;
22 import static org.mockito.Mockito.verify;
23 import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_ONLY;
24 import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_WRITE;
25 import static org.opendaylight.controller.cluster.datastore.TransactionType.WRITE_ONLY;
26 import akka.actor.ActorRef;
27 import akka.actor.ActorSelection;
28 import akka.actor.ActorSystem;
29 import akka.actor.Props;
30 import akka.dispatch.Futures;
31 import akka.util.Timeout;
32 import com.google.common.base.Optional;
33 import com.google.common.collect.Sets;
34 import com.google.common.util.concurrent.CheckedFuture;
35 import com.google.common.util.concurrent.FutureCallback;
36 import com.google.common.util.concurrent.Uninterruptibles;
37 import java.util.Collection;
38 import java.util.List;
39 import java.util.concurrent.CountDownLatch;
40 import java.util.concurrent.ExecutionException;
41 import java.util.concurrent.TimeUnit;
42 import java.util.concurrent.atomic.AtomicReference;
43 import org.junit.Assert;
44 import org.junit.Test;
45 import org.mockito.InOrder;
46 import org.mockito.Mockito;
47 import org.opendaylight.controller.cluster.datastore.config.Configuration;
48 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
49 import org.opendaylight.controller.cluster.datastore.exceptions.NotInitializedException;
50 import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException;
51 import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException;
52 import org.opendaylight.controller.cluster.datastore.messages.BatchedModifications;
53 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
54 import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
55 import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
56 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
57 import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
58 import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
59 import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
60 import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
61 import org.opendaylight.controller.cluster.datastore.utils.NormalizedNodeAggregatorTest;
62 import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
63 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
64 import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
65 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
66 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
67 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply;
68 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
69 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
70 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
71 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
72 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
73 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
74 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
75 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
76 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
77 import scala.concurrent.Promise;
79 @SuppressWarnings("resource")
80 public class TransactionProxyTest extends AbstractTransactionProxyTest {
82 @SuppressWarnings("serial")
83 static class TestException extends RuntimeException {
86 static interface Invoker {
87 CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception;
91 public void testRead() throws Exception {
92 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
94 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
96 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
97 eq(actorSelection(actorRef)), eqSerializedReadData());
99 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
100 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
102 assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
104 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
106 doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
107 eq(actorSelection(actorRef)), eqSerializedReadData());
109 readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
111 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
113 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
116 @Test(expected = ReadFailedException.class)
117 public void testReadWithInvalidReplyMessageType() throws Exception {
118 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
120 doReturn(Futures.successful(new Object())).when(mockActorContext).
121 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
123 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
125 transactionProxy.read(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
128 @Test(expected = TestException.class)
129 public void testReadWithAsyncRemoteOperatonFailure() throws Throwable {
130 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
132 doReturn(Futures.failed(new TestException())).when(mockActorContext).
133 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
135 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
137 propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
140 private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker)
142 ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
144 if (exToThrow instanceof PrimaryNotFoundException) {
145 doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
147 doReturn(primaryShardInfoReply(getSystem(), actorRef)).
148 when(mockActorContext).findPrimaryShardAsync(anyString());
151 doReturn(Futures.failed(exToThrow)).when(mockActorContext).executeOperationAsync(
152 any(ActorSelection.class), any(), any(Timeout.class));
154 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
156 propagateReadFailedExceptionCause(invoker.invoke(transactionProxy));
159 private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Throwable {
160 testExceptionOnInitialCreateTransaction(exToThrow, new Invoker() {
162 public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
163 return proxy.read(TestModel.TEST_PATH);
168 @Test(expected = PrimaryNotFoundException.class)
169 public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
170 testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"));
173 @Test(expected = TimeoutException.class)
174 public void testReadWhenATimeoutExceptionIsThrown() throws Throwable {
175 testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test",
176 new Exception("reason")));
179 @Test(expected = TestException.class)
180 public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable {
181 testReadWithExceptionOnInitialCreateTransaction(new TestException());
185 public void testReadWithPriorRecordingOperationSuccessful() throws Throwable {
186 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
188 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
190 expectBatchedModifications(actorRef, 1);
192 doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
193 eq(actorSelection(actorRef)), eqSerializedReadData());
195 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
197 transactionProxy.write(TestModel.TEST_PATH, expectedNode);
199 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
200 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
202 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
203 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
205 InOrder inOrder = Mockito.inOrder(mockActorContext);
206 inOrder.verify(mockActorContext).executeOperationAsync(
207 eq(actorSelection(actorRef)), isA(BatchedModifications.class));
209 inOrder.verify(mockActorContext).executeOperationAsync(
210 eq(actorSelection(actorRef)), eqSerializedReadData());
213 @Test(expected=IllegalStateException.class)
214 public void testReadPreConditionCheck() {
215 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
216 transactionProxy.read(TestModel.TEST_PATH);
219 @Test(expected=IllegalArgumentException.class)
220 public void testInvalidCreateTransactionReply() throws Throwable {
221 ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
223 doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext).
224 actorSelection(actorRef.path().toString());
226 doReturn(primaryShardInfoReply(getSystem(), actorRef)).
227 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
229 doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
230 eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY),
233 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
235 propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
239 public void testExists() throws Exception {
240 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
242 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
244 doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
245 eq(actorSelection(actorRef)), eqSerializedDataExists());
247 Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
249 assertEquals("Exists response", false, exists);
251 doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
252 eq(actorSelection(actorRef)), eqSerializedDataExists());
254 exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
256 assertEquals("Exists response", true, exists);
259 @Test(expected = PrimaryNotFoundException.class)
260 public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
261 testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() {
263 public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
264 return proxy.exists(TestModel.TEST_PATH);
269 @Test(expected = ReadFailedException.class)
270 public void testExistsWithInvalidReplyMessageType() throws Exception {
271 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
273 doReturn(Futures.successful(new Object())).when(mockActorContext).
274 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
276 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
278 transactionProxy.exists(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
281 @Test(expected = TestException.class)
282 public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable {
283 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
285 doReturn(Futures.failed(new TestException())).when(mockActorContext).
286 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
288 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
290 propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
294 public void testExistsWithPriorRecordingOperationSuccessful() throws Throwable {
295 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
297 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
299 expectBatchedModifications(actorRef, 1);
301 doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
302 eq(actorSelection(actorRef)), eqSerializedDataExists());
304 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
306 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
308 Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
310 assertEquals("Exists response", true, exists);
312 InOrder inOrder = Mockito.inOrder(mockActorContext);
313 inOrder.verify(mockActorContext).executeOperationAsync(
314 eq(actorSelection(actorRef)), isA(BatchedModifications.class));
316 inOrder.verify(mockActorContext).executeOperationAsync(
317 eq(actorSelection(actorRef)), eqSerializedDataExists());
320 @Test(expected=IllegalStateException.class)
321 public void testExistsPreConditionCheck() {
322 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
323 transactionProxy.exists(TestModel.TEST_PATH);
327 public void testWrite() throws Exception {
328 dataStoreContextBuilder.shardBatchedModificationCount(1);
329 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
331 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
333 expectBatchedModifications(actorRef, 1);
335 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
337 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
339 verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), false);
343 public void testWriteAfterAsyncRead() throws Throwable {
344 ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem(), DefaultShardStrategy.DEFAULT_SHARD);
346 Promise<Object> createTxPromise = akka.dispatch.Futures.promise();
347 doReturn(createTxPromise).when(mockActorContext).executeOperationAsync(
348 eq(getSystem().actorSelection(actorRef.path())),
349 eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
351 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
352 eq(actorSelection(actorRef)), eqSerializedReadData());
354 expectBatchedModificationsReady(actorRef);
356 final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
358 final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
360 final CountDownLatch readComplete = new CountDownLatch(1);
361 final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
362 com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH),
363 new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
365 public void onSuccess(Optional<NormalizedNode<?, ?>> result) {
367 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
368 } catch (Exception e) {
371 readComplete.countDown();
376 public void onFailure(Throwable t) {
378 readComplete.countDown();
382 createTxPromise.success(createTransactionReply(actorRef, DataStoreVersions.CURRENT_VERSION));
384 Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS);
386 if(caughtEx.get() != null) {
387 throw caughtEx.get();
390 // This sends the batched modification.
391 transactionProxy.ready();
393 verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), true);
396 @Test(expected=IllegalStateException.class)
397 public void testWritePreConditionCheck() {
398 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
399 transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
402 @Test(expected=IllegalStateException.class)
403 public void testWriteAfterReadyPreConditionCheck() {
404 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
406 transactionProxy.ready();
408 transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
412 public void testMerge() throws Exception {
413 dataStoreContextBuilder.shardBatchedModificationCount(1);
414 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
416 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
418 expectBatchedModifications(actorRef, 1);
420 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
422 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
424 verifyOneBatchedModification(actorRef, new MergeModification(TestModel.TEST_PATH, nodeToWrite), false);
428 public void testDelete() throws Exception {
429 dataStoreContextBuilder.shardBatchedModificationCount(1);
430 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
432 expectBatchedModifications(actorRef, 1);
434 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
436 transactionProxy.delete(TestModel.TEST_PATH);
438 verifyOneBatchedModification(actorRef, new DeleteModification(TestModel.TEST_PATH), false);
442 public void testReadWrite() throws Exception {
443 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
445 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
447 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
448 eq(actorSelection(actorRef)), eqSerializedReadData());
450 expectBatchedModifications(actorRef, 1);
452 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
454 transactionProxy.read(TestModel.TEST_PATH);
456 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
458 transactionProxy.read(TestModel.TEST_PATH);
460 transactionProxy.read(TestModel.TEST_PATH);
462 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
463 assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
465 verifyBatchedModifications(batchedModifications.get(0), false,
466 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
470 public void testReadyWithReadWrite() throws Exception {
471 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
473 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
475 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
476 eq(actorSelection(actorRef)), eqSerializedReadData());
478 expectBatchedModificationsReady(actorRef, true);
480 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
482 transactionProxy.read(TestModel.TEST_PATH);
484 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
486 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
488 assertTrue(ready instanceof SingleCommitCohortProxy);
490 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
492 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
493 assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
495 verifyBatchedModifications(batchedModifications.get(0), true, true,
496 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
498 assertEquals("getTotalMessageCount", 1, batchedModifications.get(0).getTotalMessagesSent());
502 public void testReadyWithNoModifications() throws Exception {
503 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
505 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
506 eq(actorSelection(actorRef)), eqSerializedReadData());
508 expectBatchedModificationsReady(actorRef, true);
510 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
512 transactionProxy.read(TestModel.TEST_PATH);
514 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
516 assertTrue(ready instanceof SingleCommitCohortProxy);
518 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
520 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
521 assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
523 verifyBatchedModifications(batchedModifications.get(0), true, true);
527 public void testReadyWithMultipleShardWrites() throws Exception {
528 ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
530 ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk");
532 expectBatchedModificationsReady(actorRef1);
533 expectBatchedModificationsReady(actorRef2);
535 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
537 transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME));
538 transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
540 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
542 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
544 verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef1),
545 actorSelection(actorRef2));
549 public void testReadyWithWriteOnlyAndLastBatchPending() throws Exception {
550 dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
552 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
554 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
556 expectBatchedModificationsReady(actorRef, true);
558 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
560 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
562 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
564 assertTrue(ready instanceof SingleCommitCohortProxy);
566 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
568 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
569 assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
571 verifyBatchedModifications(batchedModifications.get(0), true, true,
572 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
574 verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
575 isA(ReadyTransaction.SERIALIZABLE_CLASS));
579 public void testReadyWithWriteOnlyAndLastBatchEmpty() throws Exception {
580 dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true);
581 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
583 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
585 expectBatchedModificationsReady(actorRef, true);
587 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
589 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
591 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
593 assertTrue(ready instanceof SingleCommitCohortProxy);
595 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
597 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
598 assertEquals("Captured BatchedModifications count", 2, batchedModifications.size());
600 verifyBatchedModifications(batchedModifications.get(0), false,
601 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
603 verifyBatchedModifications(batchedModifications.get(1), true, true);
605 verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
606 isA(ReadyTransaction.SERIALIZABLE_CLASS));
610 public void testReadyWithReplyFailure() throws Exception {
611 dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
613 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
615 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
617 expectFailedBatchedModifications(actorRef);
619 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
621 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
623 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
625 assertTrue(ready instanceof SingleCommitCohortProxy);
627 verifyCohortFutures((SingleCommitCohortProxy)ready, TestException.class);
631 public void testReadyWithDebugContextEnabled() throws Exception {
632 dataStoreContextBuilder.transactionDebugContextEnabled(true);
634 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
636 expectBatchedModificationsReady(actorRef, true);
638 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
640 transactionProxy.merge(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
642 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
644 assertTrue(ready instanceof DebugThreePhaseCommitCohort);
646 verifyCohortFutures((DebugThreePhaseCommitCohort)ready, new CommitTransactionReply().toSerializable());
650 public void testReadyWithLocalTransaction() throws Exception {
651 ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
653 doReturn(getSystem().actorSelection(shardActorRef.path())).
654 when(mockActorContext).actorSelection(shardActorRef.path().toString());
656 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, createDataTree()))).
657 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
659 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
661 expectReadyLocalTransaction(shardActorRef, true);
663 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
664 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
666 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
667 assertTrue(ready instanceof SingleCommitCohortProxy);
668 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
672 public void testReadyWithLocalTransactionWithFailure() throws Exception {
673 ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
675 doReturn(getSystem().actorSelection(shardActorRef.path())).
676 when(mockActorContext).actorSelection(shardActorRef.path().toString());
678 Optional<DataTree> mockDataTree = createDataTree();
679 DataTreeModification mockModification = mockDataTree.get().takeSnapshot().newModification();
680 doThrow(new RuntimeException("mock")).when(mockModification).ready();
682 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, mockDataTree))).
683 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
685 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
687 expectReadyLocalTransaction(shardActorRef, true);
689 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
690 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
692 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
693 assertTrue(ready instanceof SingleCommitCohortProxy);
694 verifyCohortFutures((SingleCommitCohortProxy)ready, RuntimeException.class);
697 private void testWriteOnlyTxWithFindPrimaryShardFailure(Exception toThrow) throws Exception {
698 doReturn(Futures.failed(toThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
700 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
702 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
704 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
706 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
708 transactionProxy.delete(TestModel.TEST_PATH);
710 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
712 assertTrue(ready instanceof SingleCommitCohortProxy);
714 verifyCohortFutures((SingleCommitCohortProxy)ready, toThrow.getClass());
718 public void testWriteOnlyTxWithPrimaryNotFoundException() throws Exception {
719 testWriteOnlyTxWithFindPrimaryShardFailure(new PrimaryNotFoundException("mock"));
723 public void testWriteOnlyTxWithNotInitializedException() throws Exception {
724 testWriteOnlyTxWithFindPrimaryShardFailure(new NotInitializedException("mock"));
728 public void testWriteOnlyTxWithNoShardLeaderException() throws Exception {
729 testWriteOnlyTxWithFindPrimaryShardFailure(new NoShardLeaderException("mock"));
733 public void testReadyWithInvalidReplyMessageType() throws Exception {
734 dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
735 ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
737 ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk");
739 doReturn(Futures.successful(new Object())).when(mockActorContext).
740 executeOperationAsync(eq(actorSelection(actorRef1)), isA(BatchedModifications.class));
742 expectBatchedModificationsReady(actorRef2);
744 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
746 transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME));
747 transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
749 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
751 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
753 verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef2),
754 IllegalArgumentException.class);
758 public void testGetIdentifier() {
759 setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
760 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
762 Object id = transactionProxy.getIdentifier();
763 assertNotNull("getIdentifier returned null", id);
764 assertTrue("Invalid identifier: " + id, id.toString().startsWith(memberName));
768 public void testClose() throws Exception{
769 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
771 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
772 eq(actorSelection(actorRef)), eqSerializedReadData());
774 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
776 transactionProxy.read(TestModel.TEST_PATH);
778 transactionProxy.close();
780 verify(mockActorContext).sendOperationAsync(
781 eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
786 * Method to test a local Tx actor. The Tx paths are matched to decide if the
787 * Tx actor is local or not. This is done by mocking the Tx actor path
788 * and the caller paths and ensuring that the paths have the remote-address format
790 * Note: Since the default akka provider for test is not a RemoteActorRefProvider,
791 * the paths returned for the actors for all the tests are not qualified remote paths.
792 * Hence are treated as non-local/remote actors. In short, all tests except
793 * few below run for remote actors
798 public void testLocalTxActorRead() throws Exception {
799 setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
800 doReturn(true).when(mockActorContext).isPathLocal(anyString());
802 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
804 // negative test case with null as the reply
805 doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
806 any(ActorSelection.class), eqReadData());
808 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
809 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
811 assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
813 // test case with node as read data reply
814 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
816 doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
817 any(ActorSelection.class), eqReadData());
819 readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
821 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
823 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
825 // test for local data exists
826 doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
827 any(ActorSelection.class), eqDataExists());
829 boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
831 assertEquals("Exists response", true, exists);
835 public void testLocalTxActorReady() throws Exception {
836 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
837 doReturn(true).when(mockActorContext).isPathLocal(anyString());
839 expectBatchedModificationsReady(actorRef, true);
841 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
843 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
844 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
846 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
848 assertTrue(ready instanceof SingleCommitCohortProxy);
850 verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
853 private static interface TransactionProxyOperation {
854 void run(TransactionProxy transactionProxy);
857 private void throttleOperation(TransactionProxyOperation operation) {
858 throttleOperation(operation, 1, true);
861 private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){
862 throttleOperation(operation, outstandingOpsLimit, shardFound, TimeUnit.MILLISECONDS.toNanos(
863 mockActorContext.getDatastoreContext().getOperationTimeoutInMillis()));
866 private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef){
867 return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION,
868 Optional.<DataTree>absent());
871 private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef, Optional<DataTree> dataTreeOptional){
872 return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION,
877 private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound, long expectedCompletionTime){
878 ActorSystem actorSystem = getSystem();
879 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
881 // Note that we setting batchedModificationCount to one less than what we need because in TransactionProxy
882 // we now allow one extra permit to be allowed for ready
883 doReturn(dataStoreContextBuilder.operationTimeoutInSeconds(2).
884 shardBatchedModificationCount(outstandingOpsLimit-1).build()).when(mockActorContext).getDatastoreContext();
886 doReturn(actorSystem.actorSelection(shardActorRef.path())).
887 when(mockActorContext).actorSelection(shardActorRef.path().toString());
890 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
891 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
892 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
893 when(mockActorContext).findPrimaryShardAsync(eq("cars"));
896 doReturn(Futures.failed(new Exception("not found")))
897 .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
900 String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
902 doReturn(incompleteFuture()).when(mockActorContext).
903 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
904 eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
906 doReturn(true).when(mockActorContext).isPathLocal(actorPath);
908 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
910 long start = System.nanoTime();
912 operation.run(transactionProxy);
914 long end = System.nanoTime();
916 Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
917 expectedCompletionTime, (end-start)),
918 ((end - start) > expectedCompletionTime) && ((end - start) < expectedCompletionTime*2));
922 private void completeOperation(TransactionProxyOperation operation){
923 completeOperation(operation, true);
926 private void completeOperation(TransactionProxyOperation operation, boolean shardFound){
927 ActorSystem actorSystem = getSystem();
928 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
930 doReturn(actorSystem.actorSelection(shardActorRef.path())).
931 when(mockActorContext).actorSelection(shardActorRef.path().toString());
934 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
935 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
937 doReturn(Futures.failed(new PrimaryNotFoundException("test")))
938 .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
941 ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
942 String actorPath = txActorRef.path().toString();
943 CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder().
944 setTransactionId("txn-1").setTransactionActorPath(actorPath).
945 setMessageVersion(DataStoreVersions.CURRENT_VERSION).build();
947 doReturn(actorSystem.actorSelection(actorPath)).when(mockActorContext).actorSelection(actorPath);
949 doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
950 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
951 eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
953 doReturn(true).when(mockActorContext).isPathLocal(anyString());
955 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
957 long start = System.nanoTime();
959 operation.run(transactionProxy);
961 long end = System.nanoTime();
963 long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInMillis());
964 Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
965 expected, (end-start)), (end - start) <= expected);
968 private void completeOperationLocal(TransactionProxyOperation operation, Optional<DataTree> dataTreeOptional){
969 ActorSystem actorSystem = getSystem();
970 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
972 doReturn(actorSystem.actorSelection(shardActorRef.path())).
973 when(mockActorContext).actorSelection(shardActorRef.path().toString());
975 doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, dataTreeOptional))).
976 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
978 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
980 long start = System.nanoTime();
982 operation.run(transactionProxy);
984 long end = System.nanoTime();
986 long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInMillis());
987 Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
988 expected, (end-start)), (end - start) <= expected);
991 private static Optional<DataTree> createDataTree(){
992 DataTree dataTree = mock(DataTree.class);
993 Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
994 DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
995 DataTreeModification dataTreeModification = mock(DataTreeModification.class);
997 doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
998 doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
1000 return dataTreeOptional;
1003 private static Optional<DataTree> createDataTree(NormalizedNode readResponse){
1004 DataTree dataTree = mock(DataTree.class);
1005 Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
1006 DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
1007 DataTreeModification dataTreeModification = mock(DataTreeModification.class);
1009 doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
1010 doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
1011 doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
1013 return dataTreeOptional;
1018 public void testWriteCompletionForLocalShard(){
1019 completeOperationLocal(new TransactionProxyOperation() {
1021 public void run(TransactionProxy transactionProxy) {
1022 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1024 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1026 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1029 }, createDataTree());
1033 public void testWriteThrottlingWhenShardFound(){
1034 throttleOperation(new TransactionProxyOperation() {
1036 public void run(TransactionProxy transactionProxy) {
1037 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1039 expectIncompleteBatchedModifications();
1041 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1043 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1049 public void testWriteThrottlingWhenShardNotFound(){
1050 // Confirm that there is no throttling when the Shard is not found
1051 completeOperation(new TransactionProxyOperation() {
1053 public void run(TransactionProxy transactionProxy) {
1054 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1056 expectBatchedModifications(2);
1058 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1060 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1068 public void testWriteCompletion(){
1069 completeOperation(new TransactionProxyOperation() {
1071 public void run(TransactionProxy transactionProxy) {
1072 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1074 expectBatchedModifications(2);
1076 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1078 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1084 public void testMergeThrottlingWhenShardFound(){
1085 throttleOperation(new TransactionProxyOperation() {
1087 public void run(TransactionProxy transactionProxy) {
1088 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1090 expectIncompleteBatchedModifications();
1092 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1094 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1100 public void testMergeThrottlingWhenShardNotFound(){
1101 completeOperation(new TransactionProxyOperation() {
1103 public void run(TransactionProxy transactionProxy) {
1104 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1106 expectBatchedModifications(2);
1108 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1110 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1116 public void testMergeCompletion(){
1117 completeOperation(new TransactionProxyOperation() {
1119 public void run(TransactionProxy transactionProxy) {
1120 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1122 expectBatchedModifications(2);
1124 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1126 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1133 public void testMergeCompletionForLocalShard(){
1134 completeOperationLocal(new TransactionProxyOperation() {
1136 public void run(TransactionProxy transactionProxy) {
1137 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1139 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1141 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1144 }, createDataTree());
1149 public void testDeleteThrottlingWhenShardFound(){
1151 throttleOperation(new TransactionProxyOperation() {
1153 public void run(TransactionProxy transactionProxy) {
1154 expectIncompleteBatchedModifications();
1156 transactionProxy.delete(TestModel.TEST_PATH);
1158 transactionProxy.delete(TestModel.TEST_PATH);
1165 public void testDeleteThrottlingWhenShardNotFound(){
1167 completeOperation(new TransactionProxyOperation() {
1169 public void run(TransactionProxy transactionProxy) {
1170 expectBatchedModifications(2);
1172 transactionProxy.delete(TestModel.TEST_PATH);
1174 transactionProxy.delete(TestModel.TEST_PATH);
1180 public void testDeleteCompletionForLocalShard(){
1181 completeOperationLocal(new TransactionProxyOperation() {
1183 public void run(TransactionProxy transactionProxy) {
1185 transactionProxy.delete(TestModel.TEST_PATH);
1187 transactionProxy.delete(TestModel.TEST_PATH);
1189 }, createDataTree());
1194 public void testDeleteCompletion(){
1195 completeOperation(new TransactionProxyOperation() {
1197 public void run(TransactionProxy transactionProxy) {
1198 expectBatchedModifications(2);
1200 transactionProxy.delete(TestModel.TEST_PATH);
1202 transactionProxy.delete(TestModel.TEST_PATH);
1209 public void testReadThrottlingWhenShardFound(){
1211 throttleOperation(new TransactionProxyOperation() {
1213 public void run(TransactionProxy transactionProxy) {
1214 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1215 any(ActorSelection.class), eqReadData());
1217 transactionProxy.read(TestModel.TEST_PATH);
1219 transactionProxy.read(TestModel.TEST_PATH);
1225 public void testReadThrottlingWhenShardNotFound(){
1227 completeOperation(new TransactionProxyOperation() {
1229 public void run(TransactionProxy transactionProxy) {
1230 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1231 any(ActorSelection.class), eqReadData());
1233 transactionProxy.read(TestModel.TEST_PATH);
1235 transactionProxy.read(TestModel.TEST_PATH);
1242 public void testReadCompletion(){
1243 completeOperation(new TransactionProxyOperation() {
1245 public void run(TransactionProxy transactionProxy) {
1246 NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1248 doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
1249 any(ActorSelection.class), eqReadData());
1251 transactionProxy.read(TestModel.TEST_PATH);
1253 transactionProxy.read(TestModel.TEST_PATH);
1260 public void testReadCompletionForLocalShard(){
1261 final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1262 completeOperationLocal(new TransactionProxyOperation() {
1264 public void run(TransactionProxy transactionProxy) {
1265 transactionProxy.read(TestModel.TEST_PATH);
1267 transactionProxy.read(TestModel.TEST_PATH);
1269 }, createDataTree(nodeToRead));
1274 public void testReadCompletionForLocalShardWhenExceptionOccurs(){
1275 completeOperationLocal(new TransactionProxyOperation() {
1277 public void run(TransactionProxy transactionProxy) {
1278 transactionProxy.read(TestModel.TEST_PATH);
1280 transactionProxy.read(TestModel.TEST_PATH);
1282 }, createDataTree());
1287 public void testExistsThrottlingWhenShardFound(){
1289 throttleOperation(new TransactionProxyOperation() {
1291 public void run(TransactionProxy transactionProxy) {
1292 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1293 any(ActorSelection.class), eqDataExists());
1295 transactionProxy.exists(TestModel.TEST_PATH);
1297 transactionProxy.exists(TestModel.TEST_PATH);
1303 public void testExistsThrottlingWhenShardNotFound(){
1305 completeOperation(new TransactionProxyOperation() {
1307 public void run(TransactionProxy transactionProxy) {
1308 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1309 any(ActorSelection.class), eqDataExists());
1311 transactionProxy.exists(TestModel.TEST_PATH);
1313 transactionProxy.exists(TestModel.TEST_PATH);
1320 public void testExistsCompletion(){
1321 completeOperation(new TransactionProxyOperation() {
1323 public void run(TransactionProxy transactionProxy) {
1324 doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
1325 any(ActorSelection.class), eqDataExists());
1327 transactionProxy.exists(TestModel.TEST_PATH);
1329 transactionProxy.exists(TestModel.TEST_PATH);
1336 public void testExistsCompletionForLocalShard(){
1337 final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1338 completeOperationLocal(new TransactionProxyOperation() {
1340 public void run(TransactionProxy transactionProxy) {
1341 transactionProxy.exists(TestModel.TEST_PATH);
1343 transactionProxy.exists(TestModel.TEST_PATH);
1345 }, createDataTree(nodeToRead));
1350 public void testExistsCompletionForLocalShardWhenExceptionOccurs(){
1351 completeOperationLocal(new TransactionProxyOperation() {
1353 public void run(TransactionProxy transactionProxy) {
1354 transactionProxy.exists(TestModel.TEST_PATH);
1356 transactionProxy.exists(TestModel.TEST_PATH);
1358 }, createDataTree());
1362 public void testReadyThrottling(){
1364 throttleOperation(new TransactionProxyOperation() {
1366 public void run(TransactionProxy transactionProxy) {
1367 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1369 expectBatchedModifications(1);
1371 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1373 transactionProxy.ready();
1379 public void testReadyThrottlingWithTwoTransactionContexts(){
1380 throttleOperation(new TransactionProxyOperation() {
1382 public void run(TransactionProxy transactionProxy) {
1383 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1384 NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
1386 expectBatchedModifications(2);
1388 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1389 any(ActorSelection.class), any(ReadyTransaction.class));
1391 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1393 // Trying to write to Cars will cause another transaction context to get created
1394 transactionProxy.write(CarsModel.BASE_PATH, carsNode);
1396 // Now ready should block for both transaction contexts
1397 transactionProxy.ready();
1399 }, 1, true, TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInMillis()) * 2);
1402 private void testModificationOperationBatching(TransactionType type) throws Exception {
1403 int shardBatchedModificationCount = 3;
1404 dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
1406 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), type);
1408 expectBatchedModifications(actorRef, shardBatchedModificationCount);
1410 YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
1411 NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1413 YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
1414 NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
1416 YangInstanceIdentifier writePath3 = TestModel.INNER_LIST_PATH;
1417 NormalizedNode<?, ?> writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
1419 YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
1420 NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1422 YangInstanceIdentifier mergePath2 = TestModel.OUTER_LIST_PATH;
1423 NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
1425 YangInstanceIdentifier mergePath3 = TestModel.INNER_LIST_PATH;
1426 NormalizedNode<?, ?> mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
1428 YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH;
1429 YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH;
1431 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, type);
1433 transactionProxy.write(writePath1, writeNode1);
1434 transactionProxy.write(writePath2, writeNode2);
1435 transactionProxy.delete(deletePath1);
1436 transactionProxy.merge(mergePath1, mergeNode1);
1437 transactionProxy.merge(mergePath2, mergeNode2);
1438 transactionProxy.write(writePath3, writeNode3);
1439 transactionProxy.merge(mergePath3, mergeNode3);
1440 transactionProxy.delete(deletePath2);
1442 // This sends the last batch.
1443 transactionProxy.ready();
1445 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
1446 assertEquals("Captured BatchedModifications count", 3, batchedModifications.size());
1448 verifyBatchedModifications(batchedModifications.get(0), false, new WriteModification(writePath1, writeNode1),
1449 new WriteModification(writePath2, writeNode2), new DeleteModification(deletePath1));
1451 verifyBatchedModifications(batchedModifications.get(1), false, new MergeModification(mergePath1, mergeNode1),
1452 new MergeModification(mergePath2, mergeNode2), new WriteModification(writePath3, writeNode3));
1454 verifyBatchedModifications(batchedModifications.get(2), true, true,
1455 new MergeModification(mergePath3, mergeNode3), new DeleteModification(deletePath2));
1457 assertEquals("getTotalMessageCount", 3, batchedModifications.get(2).getTotalMessagesSent());
1461 public void testReadWriteModificationOperationBatching() throws Throwable {
1462 testModificationOperationBatching(READ_WRITE);
1466 public void testWriteOnlyModificationOperationBatching() throws Throwable {
1467 testModificationOperationBatching(WRITE_ONLY);
1471 public void testOptimizedWriteOnlyModificationOperationBatching() throws Throwable {
1472 dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
1473 testModificationOperationBatching(WRITE_ONLY);
1477 public void testModificationOperationBatchingWithInterleavedReads() throws Throwable {
1479 int shardBatchedModificationCount = 10;
1480 dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
1482 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
1484 expectBatchedModifications(actorRef, shardBatchedModificationCount);
1486 YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
1487 NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1489 YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
1490 NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
1492 YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
1493 NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1495 YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH;
1496 NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
1498 YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
1500 doReturn(readSerializedDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
1501 eq(actorSelection(actorRef)), eqSerializedReadData(writePath2));
1503 doReturn(readSerializedDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
1504 eq(actorSelection(actorRef)), eqSerializedReadData(mergePath2));
1506 doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
1507 eq(actorSelection(actorRef)), eqSerializedDataExists());
1509 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
1511 transactionProxy.write(writePath1, writeNode1);
1512 transactionProxy.write(writePath2, writeNode2);
1514 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).
1515 get(5, TimeUnit.SECONDS);
1517 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
1518 assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
1520 transactionProxy.merge(mergePath1, mergeNode1);
1521 transactionProxy.merge(mergePath2, mergeNode2);
1523 readOptional = transactionProxy.read(mergePath2).get(5, TimeUnit.SECONDS);
1525 transactionProxy.delete(deletePath);
1527 Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
1528 assertEquals("Exists response", true, exists);
1530 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
1531 assertEquals("Response NormalizedNode", mergeNode2, readOptional.get());
1533 List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
1534 assertEquals("Captured BatchedModifications count", 3, batchedModifications.size());
1536 verifyBatchedModifications(batchedModifications.get(0), false, new WriteModification(writePath1, writeNode1),
1537 new WriteModification(writePath2, writeNode2));
1539 verifyBatchedModifications(batchedModifications.get(1), false, new MergeModification(mergePath1, mergeNode1),
1540 new MergeModification(mergePath2, mergeNode2));
1542 verifyBatchedModifications(batchedModifications.get(2), false, new DeleteModification(deletePath));
1544 InOrder inOrder = Mockito.inOrder(mockActorContext);
1545 inOrder.verify(mockActorContext).executeOperationAsync(
1546 eq(actorSelection(actorRef)), isA(BatchedModifications.class));
1548 inOrder.verify(mockActorContext).executeOperationAsync(
1549 eq(actorSelection(actorRef)), eqSerializedReadData(writePath2));
1551 inOrder.verify(mockActorContext).executeOperationAsync(
1552 eq(actorSelection(actorRef)), isA(BatchedModifications.class));
1554 inOrder.verify(mockActorContext).executeOperationAsync(
1555 eq(actorSelection(actorRef)), eqSerializedReadData(mergePath2));
1557 inOrder.verify(mockActorContext).executeOperationAsync(
1558 eq(actorSelection(actorRef)), isA(BatchedModifications.class));
1560 inOrder.verify(mockActorContext).executeOperationAsync(
1561 eq(actorSelection(actorRef)), eqSerializedDataExists());
1565 public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException, java.util.concurrent.TimeoutException {
1567 SchemaContext schemaContext = SchemaContextHelper.full();
1568 Configuration configuration = mock(Configuration.class);
1569 doReturn(configuration).when(mockActorContext).getConfiguration();
1570 doReturn(schemaContext).when(mockActorContext).getSchemaContext();
1571 doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames();
1573 NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1574 NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
1576 setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
1577 setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));
1579 doReturn(memberName).when(mockActorContext).getCurrentMemberName();
1581 doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
1583 TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
1585 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
1586 YangInstanceIdentifier.builder().build()).get(5, TimeUnit.SECONDS);
1588 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
1590 NormalizedNode<?, ?> normalizedNode = readOptional.get();
1592 assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
1594 Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
1596 for(NormalizedNode<?,?> node : collection){
1597 assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
1600 assertTrue("Child with QName = " + TestModel.TEST_QNAME + " not found",
1601 NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME) != null);
1603 assertEquals(expectedNode1, NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME));
1605 assertTrue("Child with QName = " + CarsModel.BASE_QNAME + " not found",
1606 NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME) != null);
1608 assertEquals(expectedNode2, NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME));
1612 private void setUpReadData(String shardName, NormalizedNode<?, ?> expectedNode) {
1613 ActorSystem actorSystem = getSystem();
1614 ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
1616 doReturn(getSystem().actorSelection(shardActorRef.path())).
1617 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1619 doReturn(primaryShardInfoReply(getSystem(), shardActorRef)).
1620 when(mockActorContext).findPrimaryShardAsync(eq(shardName));
1622 doReturn(true).when(mockActorContext).isPathLocal(shardActorRef.path().toString());
1624 ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1626 doReturn(actorSystem.actorSelection(txActorRef.path())).
1627 when(mockActorContext).actorSelection(txActorRef.path().toString());
1629 doReturn(Futures.successful(createTransactionReply(txActorRef, DataStoreVersions.CURRENT_VERSION))).when(mockActorContext).
1630 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1631 eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
1633 doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
1634 eq(actorSelection(txActorRef)), eqSerializedReadData(YangInstanceIdentifier.builder().build()));