+/*
+ * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_ONLY;
-import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_WRITE;
-import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.WRITE_ONLY;
+import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_ONLY;
+import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_WRITE;
+import static org.opendaylight.controller.cluster.datastore.TransactionType.WRITE_ONLY;
+
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.dispatch.Futures;
-import akka.testkit.JavaTestKit;
+import akka.util.Timeout;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
+import com.google.common.base.Throwables;
+import com.google.common.collect.Sets;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Uninterruptibles;
-import com.typesafe.config.Config;
-import com.typesafe.config.ConfigFactory;
-import java.io.IOException;
+import java.util.Collection;
import java.util.List;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
-import org.junit.AfterClass;
import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Mock;
+import org.mockito.InOrder;
import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType;
+import org.opendaylight.controller.cluster.access.concepts.MemberName;
+import org.opendaylight.controller.cluster.datastore.config.Configuration;
+import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
+import org.opendaylight.controller.cluster.datastore.exceptions.NotInitializedException;
import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException;
import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException;
+import org.opendaylight.controller.cluster.datastore.messages.BatchedModifications;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
-import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
-import org.opendaylight.controller.cluster.datastore.messages.DataExists;
-import org.opendaylight.controller.cluster.datastore.messages.DataExistsReply;
-import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
-import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
-import org.opendaylight.controller.cluster.datastore.messages.MergeData;
-import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
-import org.opendaylight.controller.cluster.datastore.messages.ReadData;
-import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
-import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
-import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
-import org.opendaylight.controller.cluster.datastore.messages.WriteData;
-import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
+import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
+import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
+import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
+import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
-import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategyFactory;
-import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
-import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
-import org.opendaylight.controller.cluster.datastore.utils.MockConfiguration;
+import org.opendaylight.controller.cluster.datastore.utils.NormalizedNodeAggregatorTest;
+import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
+import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages;
-import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import scala.concurrent.Await;
-import scala.concurrent.Future;
import scala.concurrent.Promise;
-import scala.concurrent.duration.Duration;
@SuppressWarnings("resource")
-public class TransactionProxyTest {
+public class TransactionProxyTest extends AbstractTransactionProxyTest {
@SuppressWarnings("serial")
static class TestException extends RuntimeException {
}
- static interface Invoker {
+ interface Invoker {
CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception;
}
- private static ActorSystem system;
-
- private final Configuration configuration = new MockConfiguration();
-
- @Mock
- private ActorContext mockActorContext;
-
- private SchemaContext schemaContext;
-
- @Mock
- private ClusterWrapper mockClusterWrapper;
-
- String memberName = "mock-member";
-
- @BeforeClass
- public static void setUpClass() throws IOException {
-
- Config config = ConfigFactory.parseMap(ImmutableMap.<String, Object>builder().
- put("akka.actor.default-dispatcher.type",
- "akka.testkit.CallingThreadDispatcherConfigurator").build()).
- withFallback(ConfigFactory.load());
- system = ActorSystem.create("test", config);
- }
-
- @AfterClass
- public static void tearDownClass() throws IOException {
- JavaTestKit.shutdownActorSystem(system);
- system = null;
- }
-
- @Before
- public void setUp(){
- MockitoAnnotations.initMocks(this);
-
- schemaContext = TestModel.createTestContext();
-
- DatastoreContext dataStoreContext = DatastoreContext.newBuilder().operationTimeoutInSeconds(2).build();
-
- doReturn(getSystem()).when(mockActorContext).getActorSystem();
- doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
- doReturn(memberName).when(mockActorContext).getCurrentMemberName();
- doReturn(schemaContext).when(mockActorContext).getSchemaContext();
- doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
- doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
- doReturn(dataStoreContext).when(mockActorContext).getDatastoreContext();
- doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
-
- ShardStrategyFactory.setConfiguration(configuration);
- }
-
- private ActorSystem getSystem() {
- return system;
- }
-
- private CreateTransaction eqCreateTransaction(final String memberName,
- final TransactionType type) {
- ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
- @Override
- public boolean matches(Object argument) {
- if(CreateTransaction.SERIALIZABLE_CLASS.equals(argument.getClass())) {
- CreateTransaction obj = CreateTransaction.fromSerializable(argument);
- return obj.getTransactionId().startsWith(memberName) &&
- obj.getTransactionType() == type.ordinal();
- }
-
- return false;
- }
- };
-
- return argThat(matcher);
- }
-
- private DataExists eqSerializedDataExists() {
- ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
- @Override
- public boolean matches(Object argument) {
- return DataExists.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
- DataExists.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private DataExists eqDataExists() {
- ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
- @Override
- public boolean matches(Object argument) {
- return (argument instanceof DataExists) &&
- ((DataExists)argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private ReadData eqSerializedReadData() {
- ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
- @Override
- public boolean matches(Object argument) {
- return ReadData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
- ReadData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private ReadData eqReadData() {
- ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
- @Override
- public boolean matches(Object argument) {
- return (argument instanceof ReadData) &&
- ((ReadData)argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite) {
- return eqSerializedWriteData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
- }
-
- private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite,
- final int transactionVersion) {
- ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
- @Override
- public boolean matches(Object argument) {
- if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
- WriteData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
- (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
- ShardTransactionMessages.WriteData.class.equals(argument.getClass()))) {
-
- WriteData obj = WriteData.fromSerializable(argument);
- return obj.getPath().equals(TestModel.TEST_PATH) &&
- obj.getData().equals(nodeToWrite);
- }
-
- return false;
- }
- };
-
- return argThat(matcher);
- }
-
- private WriteData eqWriteData(final NormalizedNode<?, ?> nodeToWrite) {
- ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
- @Override
- public boolean matches(Object argument) {
- if(argument instanceof WriteData) {
- WriteData obj = (WriteData) argument;
- return obj.getPath().equals(TestModel.TEST_PATH) &&
- obj.getData().equals(nodeToWrite);
- }
- return false;
- }
- };
-
- return argThat(matcher);
- }
-
- private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite) {
- return eqSerializedMergeData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
- }
-
- private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite,
- final int transactionVersion) {
- ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
- @Override
- public boolean matches(Object argument) {
- if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
- MergeData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
- (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
- ShardTransactionMessages.MergeData.class.equals(argument.getClass()))) {
-
- MergeData obj = MergeData.fromSerializable(argument);
- return obj.getPath().equals(TestModel.TEST_PATH) &&
- obj.getData().equals(nodeToWrite);
- }
-
- return false;
- }
- };
-
- return argThat(matcher);
- }
-
- private MergeData eqMergeData(final NormalizedNode<?, ?> nodeToWrite) {
- ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
- @Override
- public boolean matches(Object argument) {
- if(argument instanceof MergeData) {
- MergeData obj = ((MergeData) argument);
- return obj.getPath().equals(TestModel.TEST_PATH) &&
- obj.getData().equals(nodeToWrite);
- }
-
- return false;
- }
- };
-
- return argThat(matcher);
- }
-
- private DeleteData eqSerializedDeleteData() {
- ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
- @Override
- public boolean matches(Object argument) {
- return DeleteData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
- DeleteData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private DeleteData eqDeleteData() {
- ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
- @Override
- public boolean matches(Object argument) {
- return argument instanceof DeleteData &&
- ((DeleteData)argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
- private Future<Object> readySerializedTxReply(String path) {
- return Futures.successful((Object)new ReadyTransactionReply(path).toSerializable());
- }
-
- private Future<Object> readyTxReply(String path) {
- return Futures.successful((Object)new ReadyTransactionReply(path));
- }
-
- private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data,
- short transactionVersion) {
- return Futures.successful(new ReadDataReply(data).toSerializable(transactionVersion));
- }
-
- private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data) {
- return readSerializedDataReply(data, DataStoreVersions.CURRENT_VERSION);
- }
-
- private Future<ReadDataReply> readDataReply(NormalizedNode<?, ?> data) {
- return Futures.successful(new ReadDataReply(data));
- }
-
- private Future<Object> dataExistsSerializedReply(boolean exists) {
- return Futures.successful(new DataExistsReply(exists).toSerializable());
- }
-
- private Future<DataExistsReply> dataExistsReply(boolean exists) {
- return Futures.successful(new DataExistsReply(exists));
- }
-
- private Future<Object> writeSerializedDataReply(short version) {
- return Futures.successful(new WriteDataReply().toSerializable(version));
- }
-
- private Future<Object> writeSerializedDataReply() {
- return writeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
- }
-
- private Future<WriteDataReply> writeDataReply() {
- return Futures.successful(new WriteDataReply());
- }
-
- private Future<Object> mergeSerializedDataReply(short version) {
- return Futures.successful(new MergeDataReply().toSerializable(version));
- }
-
- private Future<Object> mergeSerializedDataReply() {
- return mergeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
- }
-
- private Future<Object> incompleteFuture(){
- return mock(Future.class);
- }
-
- private Future<MergeDataReply> mergeDataReply() {
- return Futures.successful(new MergeDataReply());
- }
-
- private Future<Object> deleteSerializedDataReply(short version) {
- return Futures.successful(new DeleteDataReply().toSerializable(version));
- }
-
- private Future<Object> deleteSerializedDataReply() {
- return deleteSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
- }
-
- private Future<DeleteDataReply> deleteDataReply() {
- return Futures.successful(new DeleteDataReply());
- }
-
- private ActorSelection actorSelection(ActorRef actorRef) {
- return getSystem().actorSelection(actorRef.path());
- }
-
- private CreateTransactionReply createTransactionReply(ActorRef actorRef, int transactionVersion){
- return CreateTransactionReply.newBuilder()
- .setTransactionActorPath(actorRef.path().toString())
- .setTransactionId("txn-1")
- .setMessageVersion(transactionVersion)
- .build();
- }
-
- private ActorRef setupActorContextWithoutInitialCreateTransaction(ActorSystem actorSystem) {
- ActorRef actorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
- doReturn(actorSystem.actorSelection(actorRef.path())).
- when(mockActorContext).actorSelection(actorRef.path().toString());
-
- doReturn(Futures.successful(actorSystem.actorSelection(actorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
-
- doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
-
- doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
-
- return actorRef;
- }
-
- private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem,
- TransactionType type, int transactionVersion) {
- ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(actorSystem);
-
- doReturn(Futures.successful(createTransactionReply(actorRef, transactionVersion))).when(mockActorContext).
- executeOperationAsync(eq(actorSystem.actorSelection(actorRef.path())),
- eqCreateTransaction(memberName, type));
-
- return actorRef;
- }
-
- private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem, TransactionType type) {
- return setupActorContextWithInitialCreateTransaction(actorSystem, type, DataStoreVersions.CURRENT_VERSION);
- }
-
-
- private void propagateReadFailedExceptionCause(CheckedFuture<?, ReadFailedException> future)
- throws Throwable {
-
- try {
- future.checkedGet(5, TimeUnit.SECONDS);
- fail("Expected ReadFailedException");
- } catch(ReadFailedException e) {
- throw e.getCause();
- }
- }
-
@Test
public void testRead() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
public void testReadWithInvalidReplyMessageType() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- doReturn(Futures.successful(new Object())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(Futures.successful(new Object())).when(mockActorContext)
+ .executeOperationAsync(eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
transactionProxy.read(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
}
@Test(expected = TestException.class)
- public void testReadWithAsyncRemoteOperatonFailure() throws Throwable {
+ public void testReadWithAsyncRemoteOperatonFailure() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(Futures.failed(new TestException())).when(mockActorContext)
+ .executeOperationAsync(eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
}
- private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker)
- throws Throwable {
+ private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker) throws Exception {
ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
if (exToThrow instanceof PrimaryNotFoundException) {
doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
} else {
- doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(anyString());
+ doReturn(primaryShardInfoReply(getSystem(), actorRef)).when(mockActorContext)
+ .findPrimaryShardAsync(anyString());
}
doReturn(Futures.failed(exToThrow)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), any());
+ any(ActorSelection.class), any(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
propagateReadFailedExceptionCause(invoker.invoke(transactionProxy));
}
- private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Throwable {
- testExceptionOnInitialCreateTransaction(exToThrow, new Invoker() {
- @Override
- public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
- return proxy.read(TestModel.TEST_PATH);
- }
- });
+ private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Exception {
+ testExceptionOnInitialCreateTransaction(exToThrow, proxy -> proxy.read(TestModel.TEST_PATH));
}
@Test(expected = PrimaryNotFoundException.class)
- public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
+ public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Exception {
testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"));
}
@Test(expected = TimeoutException.class)
- public void testReadWhenATimeoutExceptionIsThrown() throws Throwable {
+ public void testReadWhenATimeoutExceptionIsThrown() throws Exception {
testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test",
new Exception("reason")));
}
@Test(expected = TestException.class)
- public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable {
+ public void testReadWhenAnyOtherExceptionIsThrown() throws Exception {
testReadWithExceptionOnInitialCreateTransaction(new TestException());
}
- @Test(expected = TestException.class)
- public void testReadWithPriorRecordingOperationFailure() throws Throwable {
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
-
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
-
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
-
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
-
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-
- transactionProxy.delete(TestModel.TEST_PATH);
-
- try {
- propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
- } finally {
- verify(mockActorContext, times(0)).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
- }
- }
-
@Test
- public void testReadWithPriorRecordingOperationSuccessful() throws Throwable {
+ public void testReadWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(expectedNode));
+ expectBatchedModifications(actorRef, 1);
- doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
transactionProxy.write(TestModel.TEST_PATH, expectedNode);
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
-
assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
- }
- @Test(expected=IllegalStateException.class)
- public void testReadPreConditionCheck() {
+ InOrder inOrder = Mockito.inOrder(mockActorContext);
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
+ }
+ @Test(expected = IllegalStateException.class)
+ public void testReadPreConditionCheck() {
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.read(TestModel.TEST_PATH);
}
- @Test(expected=IllegalArgumentException.class)
- public void testInvalidCreateTransactionReply() throws Throwable {
+ @Test(expected = IllegalArgumentException.class)
+ public void testInvalidCreateTransactionReply() throws Exception {
ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
- doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext).
- actorSelection(actorRef.path().toString());
+ doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext)
+ .actorSelection(actorRef.path().toString());
- doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ doReturn(primaryShardInfoReply(getSystem(), actorRef)).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
- eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY));
+ eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY),
+ any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
}
public void testExists() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDataExists());
+ doReturn(dataExistsReply(false)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
assertEquals("Exists response", false, exists);
- doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDataExists());
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
}
@Test(expected = PrimaryNotFoundException.class)
- public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
- testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() {
- @Override
- public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
- return proxy.exists(TestModel.TEST_PATH);
- }
- });
+ public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Exception {
+ testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"),
+ proxy -> proxy.exists(TestModel.TEST_PATH));
}
@Test(expected = ReadFailedException.class)
public void testExistsWithInvalidReplyMessageType() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- doReturn(Futures.successful(new Object())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
+ doReturn(Futures.successful(new Object())).when(mockActorContext)
+ .executeOperationAsync(eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
transactionProxy.exists(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
}
@Test(expected = TestException.class)
- public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable {
+ public void testExistsWithAsyncRemoteOperatonFailure() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
+ doReturn(Futures.failed(new TestException())).when(mockActorContext)
+ .executeOperationAsync(eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
}
- @Test(expected = TestException.class)
- public void testExistsWithPriorRecordingOperationFailure() throws Throwable {
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
-
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
-
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
-
- doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDataExists());
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
-
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-
- transactionProxy.delete(TestModel.TEST_PATH);
-
- try {
- propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
- } finally {
- verify(mockActorContext, times(0)).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDataExists());
- }
- }
-
@Test
- public void testExistsWithPriorRecordingOperationSuccessful() throws Throwable {
+ public void testExistsWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ expectBatchedModifications(actorRef, 1);
- doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDataExists());
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
assertEquals("Exists response", true, exists);
- }
-
- @Test(expected=IllegalStateException.class)
- public void testExistsPreConditionCheck() {
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ InOrder inOrder = Mockito.inOrder(mockActorContext);
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
- transactionProxy.exists(TestModel.TEST_PATH);
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
}
- private void verifyRecordingOperationFutures(List<Future<Object>> futures,
- Class<?>... expResultTypes) throws Exception {
- assertEquals("getRecordingOperationFutures size", expResultTypes.length, futures.size());
-
- int i = 0;
- for( Future<Object> future: futures) {
- assertNotNull("Recording operation Future is null", future);
-
- Class<?> expResultType = expResultTypes[i++];
- if(Throwable.class.isAssignableFrom(expResultType)) {
- try {
- Await.result(future, Duration.create(5, TimeUnit.SECONDS));
- fail("Expected exception from recording operation Future");
- } catch(Exception e) {
- // Expected
- }
- } else {
- assertEquals("Recording operation Future result type", expResultType,
- Await.result(future, Duration.create(5, TimeUnit.SECONDS)).getClass());
- }
- }
+ @Test(expected = IllegalStateException.class)
+ public void testExistsPreConditionCheck() {
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
+ transactionProxy.exists(TestModel.TEST_PATH);
}
@Test
public void testWrite() throws Exception {
+ dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ expectBatchedModifications(actorRef, 1);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- verify(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
-
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- WriteDataReply.class);
+ verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), false);
}
@Test
- public void testWriteAfterAsyncRead() throws Throwable {
- ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem());
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public void testWriteAfterAsyncRead() throws Exception {
+ ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem(),
+ DefaultShardStrategy.DEFAULT_SHARD);
Promise<Object> createTxPromise = akka.dispatch.Futures.promise();
doReturn(createTxPromise).when(mockActorContext).executeOperationAsync(
eq(getSystem().actorSelection(actorRef.path())),
- eqCreateTransaction(memberName, READ_WRITE));
+ eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
+
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ expectBatchedModificationsReady(actorRef);
final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
-
- final TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
+ final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
final CountDownLatch readComplete = new CountDownLatch(1);
final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
}
@Override
- public void onFailure(Throwable t) {
- caughtEx.set(t);
+ public void onFailure(Throwable failure) {
+ caughtEx.set(failure);
readComplete.countDown();
}
});
Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS);
- if(caughtEx.get() != null) {
- throw caughtEx.get();
+ if (caughtEx.get() != null) {
+ Throwables.propagateIfInstanceOf(caughtEx.get(), Exception.class);
+ Throwables.propagate(caughtEx.get());
}
- verify(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ // This sends the batched modification.
+ transactionProxy.ready();
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- WriteDataReply.class);
+ verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), true);
}
- @Test(expected=IllegalStateException.class)
+ @Test(expected = IllegalStateException.class)
public void testWritePreConditionCheck() {
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_ONLY);
-
- transactionProxy.write(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
+ transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
}
- @Test(expected=IllegalStateException.class)
+ @Test(expected = IllegalStateException.class)
public void testWriteAfterReadyPreConditionCheck() {
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.ready();
- transactionProxy.write(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME));
+ transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
}
@Test
public void testMerge() throws Exception {
+ dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
+ expectBatchedModifications(actorRef, 1);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
- verify(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
-
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- MergeDataReply.class);
+ verifyOneBatchedModification(actorRef, new MergeModification(TestModel.TEST_PATH, nodeToWrite), false);
}
@Test
public void testDelete() throws Exception {
+ dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- doReturn(deleteSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDeleteData());
+ expectBatchedModifications(actorRef, 1);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.delete(TestModel.TEST_PATH);
- verify(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedDeleteData());
-
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- DeleteDataReply.class);
- }
-
- private void verifyCohortFutures(ThreePhaseCommitCohortProxy proxy,
- Object... expReplies) throws Exception {
- assertEquals("getReadyOperationFutures size", expReplies.length,
- proxy.getCohortFutures().size());
-
- int i = 0;
- for( Future<ActorSelection> future: proxy.getCohortFutures()) {
- assertNotNull("Ready operation Future is null", future);
-
- Object expReply = expReplies[i++];
- if(expReply instanceof ActorSelection) {
- ActorSelection actual = Await.result(future, Duration.create(5, TimeUnit.SECONDS));
- assertEquals("Cohort actor path", expReply, actual);
- } else {
- // Expecting exception.
- try {
- Await.result(future, Duration.create(5, TimeUnit.SECONDS));
- fail("Expected exception from ready operation Future");
- } catch(Exception e) {
- // Expected
- }
- }
- }
+ verifyOneBatchedModification(actorRef, new DeleteModification(TestModel.TEST_PATH), false);
}
@Test
- public void testReady() throws Exception {
+ public void testReadWrite() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
+ expectBatchedModifications(actorRef, 1);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
transactionProxy.read(TestModel.TEST_PATH);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
-
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ transactionProxy.read(TestModel.TEST_PATH);
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ transactionProxy.read(TestModel.TEST_PATH);
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- WriteDataReply.class);
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
- verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
+ verifyBatchedModifications(batchedModifications.get(0), false,
+ new WriteModification(TestModel.TEST_PATH, nodeToWrite));
}
- private ActorRef testCompatibilityWithHeliumVersion(short version) throws Exception {
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(),
- READ_WRITE, version);
+ @Test
+ public void testReadyWithReadWrite() throws Exception {
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readSerializedDataReply(testNode, version)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- doReturn(writeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(testNode, version));
+ expectBatchedModificationsReady(actorRef, true);
- doReturn(mergeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedMergeData(testNode, version));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
- doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
+ transactionProxy.read(TestModel.TEST_PATH);
- doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
- eq(actorRef.path().toString()));
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(TestModel.TEST_PATH).
- get(5, TimeUnit.SECONDS);
+ assertTrue(ready instanceof SingleCommitCohortProxy);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
- assertEquals("Response NormalizedNode", testNode, readOptional.get());
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
- transactionProxy.write(TestModel.TEST_PATH, testNode);
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
- transactionProxy.merge(TestModel.TEST_PATH, testNode);
+ verifyBatchedModifications(batchedModifications.get(0), true, true,
+ new WriteModification(TestModel.TEST_PATH, nodeToWrite));
- DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ assertEquals("getTotalMessageCount", 1, batchedModifications.get(0).getTotalMessagesSent());
+ }
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ @Test
+ public void testReadyWithNoModifications() throws Exception {
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- ShardTransactionMessages.WriteDataReply.class, ShardTransactionMessages.MergeDataReply.class);
+ expectBatchedModificationsReady(actorRef, true);
- verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
- return actorRef;
- }
+ transactionProxy.read(TestModel.TEST_PATH);
- @Test
- public void testCompatibilityWithBaseHeliumVersion() throws Exception {
- ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.BASE_HELIUM_VERSION);
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- verify(mockActorContext).resolvePath(eq(actorRef.path().toString()),
- eq(actorRef.path().toString()));
- }
+ assertTrue(ready instanceof SingleCommitCohortProxy);
- @Test
- public void testCompatibilityWithHeliumR1Version() throws Exception {
- ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.HELIUM_1_VERSION);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
- verify(mockActorContext, Mockito.never()).resolvePath(eq(actorRef.path().toString()),
- eq(actorRef.path().toString()));
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
+
+ verifyBatchedModifications(batchedModifications.get(0), true, true);
}
@Test
- public void testReadyWithRecordingOperationFailure() throws Exception {
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
+ public void testReadyWithMultipleShardWrites() throws Exception {
+ ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk");
- doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
+ expectBatchedModificationsReady(actorRef1);
+ expectBatchedModificationsReady(actorRef2);
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
+ transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME));
+ transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+ verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef1),
+ actorSelection(actorRef2));
+ }
+
+ @Test
+ public void testReadyWithWriteOnlyAndLastBatchPending() throws Exception {
+ dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
+
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
+
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ expectBatchedModificationsReady(actorRef, true);
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ assertTrue(ready instanceof SingleCommitCohortProxy);
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
- verifyCohortFutures(proxy, TestException.class);
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 1, batchedModifications.size());
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- MergeDataReply.class, TestException.class);
+ verifyBatchedModifications(batchedModifications.get(0), true, true,
+ new WriteModification(TestModel.TEST_PATH, nodeToWrite));
}
@Test
- public void testReadyWithReplyFailure() throws Exception {
+ public void testReadyWithWriteOnlyAndLastBatchEmpty() throws Exception {
+ dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
-
- doReturn(Futures.failed(new TestException())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)),
- isA(ReadyTransaction.SERIALIZABLE_CLASS));
+ expectBatchedModificationsReady(actorRef, true);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ assertTrue(ready instanceof SingleCommitCohortProxy);
+
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 2, batchedModifications.size());
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- MergeDataReply.class);
+ verifyBatchedModifications(batchedModifications.get(0), false,
+ new WriteModification(TestModel.TEST_PATH, nodeToWrite));
- verifyCohortFutures(proxy, TestException.class);
+ verifyBatchedModifications(batchedModifications.get(1), true, true);
}
@Test
- public void testReadyWithInitialCreateTransactionFailure() throws Exception {
-
- doReturn(Futures.failed(new PrimaryNotFoundException("mock"))).when(
- mockActorContext).findPrimaryShardAsync(anyString());
+ public void testReadyWithReplyFailure() throws Exception {
+ dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+ expectFailedBatchedModifications(actorRef);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- transactionProxy.delete(TestModel.TEST_PATH);
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ assertTrue(ready instanceof SingleCommitCohortProxy);
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
-
- verifyCohortFutures(proxy, PrimaryNotFoundException.class);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, TestException.class);
}
@Test
- public void testReadyWithInvalidReplyMessageType() throws Exception {
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
+ public void testReadyWithDebugContextEnabled() throws Exception {
+ dataStoreContextBuilder.transactionDebugContextEnabled(true);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- doReturn(Futures.successful(new Object())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)),
- isA(ReadyTransaction.SERIALIZABLE_CLASS));
+ expectBatchedModificationsReady(actorRef, true);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.merge(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
-
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ assertTrue(ready instanceof DebugThreePhaseCommitCohort);
- verifyCohortFutures(proxy, IllegalArgumentException.class);
+ verifyCohortFutures((DebugThreePhaseCommitCohort)ready, new CommitTransactionReply().toSerializable());
}
@Test
- public void testGetIdentifier() {
- setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- TransactionProxy.TransactionType.READ_ONLY);
+ public void testReadyWithLocalTransaction() throws Exception {
+ ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
- Object id = transactionProxy.getIdentifier();
- assertNotNull("getIdentifier returned null", id);
- assertTrue("Invalid identifier: " + id, id.toString().startsWith(memberName));
- }
+ doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
- @Test
- public void testClose() throws Exception{
- ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, createDataTree()))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), eqSerializedReadData());
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
- READ_WRITE);
+ expectReadyLocalTransaction(shardActorRef, true);
- transactionProxy.read(TestModel.TEST_PATH);
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.close();
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ assertTrue(ready instanceof SingleCommitCohortProxy);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
+ }
- verify(mockActorContext).sendOperationAsync(
- eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
- }
-
-
- /**
- * Method to test a local Tx actor. The Tx paths are matched to decide if the
- * Tx actor is local or not. This is done by mocking the Tx actor path
- * and the caller paths and ensuring that the paths have the remote-address format
- *
- * Note: Since the default akka provider for test is not a RemoteActorRefProvider,
- * the paths returned for the actors for all the tests are not qualified remote paths.
- * Hence are treated as non-local/remote actors. In short, all tests except
- * few below run for remote actors
- *
- * @throws Exception
- */
@Test
- public void testLocalTxActorRead() throws Exception {
- ActorSystem actorSystem = getSystem();
- ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
+ public void testReadyWithLocalTransactionWithFailure() throws Exception {
+ ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
- doReturn(actorSystem.actorSelection(shardActorRef.path())).
- when(mockActorContext).actorSelection(shardActorRef.path().toString());
+ doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
- doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ DataTree mockDataTree = createDataTree();
+ DataTreeModification mockModification = mockDataTree.takeSnapshot().newModification();
+ doThrow(new RuntimeException("mock")).when(mockModification).ready();
- String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
- CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
- .setTransactionId("txn-1")
- .setTransactionActorPath(actorPath)
- .build();
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, mockDataTree))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
- doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
- executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
- eqCreateTransaction(memberName, READ_ONLY));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- doReturn(true).when(mockActorContext).isPathLocal(actorPath);
+ expectReadyLocalTransaction(shardActorRef, true);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,READ_ONLY);
-
- // negative test case with null as the reply
- doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqReadData());
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
- TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ assertTrue(ready instanceof SingleCommitCohortProxy);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, RuntimeException.class);
+ }
- assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
+ private void testWriteOnlyTxWithFindPrimaryShardFailure(Exception toThrow) throws Exception {
+ doReturn(Futures.failed(toThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
- // test case with node as read data reply
- NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqReadData());
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
+ transactionProxy.delete(TestModel.TEST_PATH);
- // test for local data exists
- doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDataExists());
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
+ assertTrue(ready instanceof SingleCommitCohortProxy);
- assertEquals("Exists response", true, exists);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, toThrow.getClass());
}
@Test
- public void testLocalTxActorWrite() throws Exception {
- ActorSystem actorSystem = getSystem();
- ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
-
- doReturn(actorSystem.actorSelection(shardActorRef.path())).
- when(mockActorContext).actorSelection(shardActorRef.path().toString());
+ public void testWriteOnlyTxWithPrimaryNotFoundException() throws Exception {
+ testWriteOnlyTxWithFindPrimaryShardFailure(new PrimaryNotFoundException("mock"));
+ }
- doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ @Test
+ public void testWriteOnlyTxWithNotInitializedException() throws Exception {
+ testWriteOnlyTxWithFindPrimaryShardFailure(new NotInitializedException("mock"));
+ }
- String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
- CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
- .setTransactionId("txn-1")
- .setTransactionActorPath(actorPath)
- .build();
+ @Test
+ public void testWriteOnlyTxWithNoShardLeaderException() throws Exception {
+ testWriteOnlyTxWithFindPrimaryShardFailure(new NoShardLeaderException("mock"));
+ }
- doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
- executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
- eqCreateTransaction(memberName, WRITE_ONLY));
+ @Test
+ public void testReadyWithInvalidReplyMessageType() throws Exception {
+ dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
+ ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- doReturn(true).when(mockActorContext).isPathLocal(actorPath);
+ ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk");
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef1)), isA(BatchedModifications.class), any(Timeout.class));
- doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ expectBatchedModificationsReady(actorRef2);
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- verify(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME));
+ transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- //testing local merge
- doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqMergeData(nodeToWrite));
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+ assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
- verify(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqMergeData(nodeToWrite));
+ verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef2),
+ IllegalArgumentException.class);
+ }
+ @Test
+ public void testGetIdentifier() {
+ setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- //testing local delete
- doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDeleteData());
+ Object id = transactionProxy.getIdentifier();
+ assertNotNull("getIdentifier returned null", id);
+ assertTrue("Invalid identifier: " + id, id.toString().contains(memberName));
+ }
- transactionProxy.delete(TestModel.TEST_PATH);
+ @Test
+ public void testClose() throws Exception {
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- verify(mockActorContext).executeOperationAsync(any(ActorSelection.class), eqDeleteData());
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
- WriteDataReply.class, MergeDataReply.class, DeleteDataReply.class);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
- // testing ready
- doReturn(readyTxReply(shardActorRef.path().toString())).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), isA(ReadyTransaction.class));
+ transactionProxy.read(TestModel.TEST_PATH);
- DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ transactionProxy.close();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
+ verify(mockActorContext).sendOperationAsync(
+ eq(actorSelection(actorRef)), isA(CloseTransaction.class));
+ }
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ private interface TransactionProxyOperation {
+ void run(TransactionProxy transactionProxy);
+ }
- verifyCohortFutures(proxy, getSystem().actorSelection(shardActorRef.path()));
+ private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef) {
+ return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION);
}
- private static interface TransactionProxyOperation {
- void run(TransactionProxy transactionProxy);
+ private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef, DataTree dataTree) {
+ return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION,
+ dataTree);
}
private void throttleOperation(TransactionProxyOperation operation) {
throttleOperation(operation, 1, true);
}
- private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){
+ private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound) {
+ throttleOperation(operation, outstandingOpsLimit, shardFound, TimeUnit.MILLISECONDS.toNanos(
+ mockActorContext.getDatastoreContext().getOperationTimeoutInMillis()));
+ }
+
+ private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound,
+ long expectedCompletionTime) {
ActorSystem actorSystem = getSystem();
ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
- doReturn(outstandingOpsLimit).when(mockActorContext).getTransactionOutstandingOperationLimit();
+ // Note that we setting batchedModificationCount to one less than what we need because in TransactionProxy
+ // we now allow one extra permit to be allowed for ready
+ doReturn(dataStoreContextBuilder.operationTimeoutInSeconds(2)
+ .shardBatchedModificationCount(outstandingOpsLimit - 1).build()).when(mockActorContext)
+ .getDatastoreContext();
+
+ doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
- doReturn(actorSystem.actorSelection(shardActorRef.path())).
- when(mockActorContext).actorSelection(shardActorRef.path().toString());
+ if (shardFound) {
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+ .findPrimaryShardAsync(eq("cars"));
- if(shardFound) {
- doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
} else {
doReturn(Futures.failed(new Exception("not found")))
.when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
}
- String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
- CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
- .setTransactionId("txn-1")
- .setTransactionActorPath(actorPath)
- .build();
+ doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+ eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE),
+ any(Timeout.class));
- doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
- executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
- eqCreateTransaction(memberName, READ_WRITE));
-
- doReturn(true).when(mockActorContext).isPathLocal(actorPath);
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
long start = System.nanoTime();
long end = System.nanoTime();
- Assert.assertTrue(String.format("took less time than expected %s was %s",
- TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()),
- (end-start)), (end - start) > TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()));
+ Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
+ expectedCompletionTime, end - start),
+ end - start > expectedCompletionTime && end - start < expectedCompletionTime * 2);
}
- private void completeOperation(TransactionProxyOperation operation){
+ private void completeOperation(TransactionProxyOperation operation) {
completeOperation(operation, true);
}
- private void completeOperation(TransactionProxyOperation operation, boolean shardFound){
+ private void completeOperation(TransactionProxyOperation operation, boolean shardFound) {
ActorSystem actorSystem = getSystem();
ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
- doReturn(1).when(mockActorContext).getTransactionOutstandingOperationLimit();
+ doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
- doReturn(actorSystem.actorSelection(shardActorRef.path())).
- when(mockActorContext).actorSelection(shardActorRef.path().toString());
-
- if(shardFound) {
- doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
- when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ if (shardFound) {
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
} else {
- doReturn(Futures.failed(new Exception("not found")))
- .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+ doReturn(Futures.failed(new PrimaryNotFoundException("test"))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
}
- String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
- CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
- .setTransactionId("txn-1")
- .setTransactionActorPath(actorPath)
- .build();
+ ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
+ String actorPath = txActorRef.path().toString();
+ CreateTransactionReply createTransactionReply = new CreateTransactionReply(actorPath, nextTransactionId(),
+ DataStoreVersions.CURRENT_VERSION);
- doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
- executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
- eqCreateTransaction(memberName, READ_WRITE));
+ doReturn(actorSystem.actorSelection(actorPath)).when(mockActorContext).actorSelection(actorPath);
- doReturn(true).when(mockActorContext).isPathLocal(actorPath);
+ doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).executeOperationAsync(
+ eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE),
+ any(Timeout.class));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
long start = System.nanoTime();
long end = System.nanoTime();
- Assert.assertTrue(String.format("took more time than expected %s was %s",
- TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()),
- (end-start)), (end - start) <= TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()));
+ long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+ .getOperationTimeoutInMillis());
+ Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
+ expected, end - start), end - start <= expected);
}
- public void testWriteThrottling(boolean shardFound){
+ private void completeOperationLocal(TransactionProxyOperation operation, DataTree dataTree) {
+ ActorSystem actorSystem = getSystem();
+ ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
+
+ doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, dataTree))).when(mockActorContext)
+ .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ long start = System.nanoTime();
+
+ operation.run(transactionProxy);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- }
- }, 1, shardFound);
+ long end = System.nanoTime();
+
+ long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+ .getOperationTimeoutInMillis());
+ Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s", expected, end - start),
+ end - start <= expected);
+ }
+
+ private static DataTree createDataTree() {
+ DataTree dataTree = mock(DataTree.class);
+ DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
+ DataTreeModification dataTreeModification = mock(DataTreeModification.class);
+
+ doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
+ doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
+
+ return dataTree;
}
+ private static DataTree createDataTree(NormalizedNode<?, ?> readResponse) {
+ DataTree dataTree = mock(DataTree.class);
+ DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
+ DataTreeModification dataTreeModification = mock(DataTreeModification.class);
+
+ doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
+ doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
+ doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
+
+ return dataTree;
+ }
+
+
@Test
- public void testWriteThrottlingWhenShardFound(){
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ public void testWriteCompletionForLocalShard() {
+ completeOperationLocal(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- }
- });
+ }, createDataTree());
+ }
+
+ @Test
+ public void testWriteThrottlingWhenShardFound() {
+ throttleOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ expectIncompleteBatchedModifications();
+
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ });
}
@Test
- public void testWriteThrottlingWhenShardNotFound(){
+ public void testWriteThrottlingWhenShardNotFound() {
// Confirm that there is no throttling when the Shard is not found
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ completeOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ expectBatchedModifications(2);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- }
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
}, false);
}
@Test
- public void testWriteCompletion(){
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ public void testWriteCompletion() {
+ completeOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqSerializedWriteData(nodeToWrite));
+ expectBatchedModifications(2);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
- }
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
});
-
}
@Test
- public void testMergeThrottlingWhenShardFound(){
+ public void testMergeThrottlingWhenShardFound() {
+ throttleOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ expectIncompleteBatchedModifications();
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqMergeData(nodeToMerge));
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
-
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- }
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
});
}
@Test
- public void testMergeThrottlingWhenShardNotFound(){
-
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ public void testMergeThrottlingWhenShardNotFound() {
+ completeOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqMergeData(nodeToMerge));
+ expectBatchedModifications(2);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- }
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
}, false);
}
@Test
- public void testMergeCompletion(){
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ public void testMergeCompletion() {
+ completeOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqMergeData(nodeToMerge));
+ expectBatchedModifications(2);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
- }
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
});
}
@Test
- public void testDeleteThrottlingWhenShardFound(){
+ public void testMergeCompletionForLocalShard() {
+ completeOperationLocal(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDeleteData());
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
- transactionProxy.delete(TestModel.TEST_PATH);
+ transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+
+ }, createDataTree());
+ }
- transactionProxy.delete(TestModel.TEST_PATH);
- }
+
+ @Test
+ public void testDeleteThrottlingWhenShardFound() {
+
+ throttleOperation(transactionProxy -> {
+ expectIncompleteBatchedModifications();
+
+ transactionProxy.delete(TestModel.TEST_PATH);
+
+ transactionProxy.delete(TestModel.TEST_PATH);
});
}
@Test
- public void testDeleteThrottlingWhenShardNotFound(){
+ public void testDeleteThrottlingWhenShardNotFound() {
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDeleteData());
+ completeOperation(transactionProxy -> {
+ expectBatchedModifications(2);
- transactionProxy.delete(TestModel.TEST_PATH);
+ transactionProxy.delete(TestModel.TEST_PATH);
- transactionProxy.delete(TestModel.TEST_PATH);
- }
+ transactionProxy.delete(TestModel.TEST_PATH);
}, false);
}
@Test
- public void testDeleteCompletion(){
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDeleteData());
+ public void testDeleteCompletionForLocalShard() {
+ completeOperationLocal(transactionProxy -> {
+
+ transactionProxy.delete(TestModel.TEST_PATH);
+
+ transactionProxy.delete(TestModel.TEST_PATH);
+ }, createDataTree());
+
+ }
+
+ @Test
+ public void testDeleteCompletion() {
+ completeOperation(transactionProxy -> {
+ expectBatchedModifications(2);
- transactionProxy.delete(TestModel.TEST_PATH);
+ transactionProxy.delete(TestModel.TEST_PATH);
- transactionProxy.delete(TestModel.TEST_PATH);
- }
+ transactionProxy.delete(TestModel.TEST_PATH);
});
}
@Test
- public void testReadThrottlingWhenShardFound(){
+ public void testReadThrottlingWhenShardFound() {
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqReadData());
+ throttleOperation(transactionProxy -> {
+ doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqReadData());
- transactionProxy.read(TestModel.TEST_PATH);
+ transactionProxy.read(TestModel.TEST_PATH);
- transactionProxy.read(TestModel.TEST_PATH);
- }
+ transactionProxy.read(TestModel.TEST_PATH);
});
}
@Test
- public void testReadThrottlingWhenShardNotFound(){
+ public void testReadThrottlingWhenShardNotFound() {
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqReadData());
+ completeOperation(transactionProxy -> {
+ doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqReadData());
- transactionProxy.read(TestModel.TEST_PATH);
+ transactionProxy.read(TestModel.TEST_PATH);
- transactionProxy.read(TestModel.TEST_PATH);
- }
+ transactionProxy.read(TestModel.TEST_PATH);
}, false);
}
@Test
- public void testReadCompletion(){
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ public void testReadCompletion() {
+ completeOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqReadData());
+ doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqReadData(), any(Timeout.class));
- transactionProxy.read(TestModel.TEST_PATH);
+ transactionProxy.read(TestModel.TEST_PATH);
- transactionProxy.read(TestModel.TEST_PATH);
- }
+ transactionProxy.read(TestModel.TEST_PATH);
});
}
@Test
- public void testExistsThrottlingWhenShardFound(){
+ public void testReadCompletionForLocalShard() {
+ final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ completeOperationLocal(transactionProxy -> {
+ transactionProxy.read(TestModel.TEST_PATH);
+
+ transactionProxy.read(TestModel.TEST_PATH);
+ }, createDataTree(nodeToRead));
+
+ }
+
+ @Test
+ public void testReadCompletionForLocalShardWhenExceptionOccurs() {
+ completeOperationLocal(transactionProxy -> {
+ transactionProxy.read(TestModel.TEST_PATH);
+
+ transactionProxy.read(TestModel.TEST_PATH);
+ }, createDataTree());
+
+ }
+
+ @Test
+ public void testExistsThrottlingWhenShardFound() {
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDataExists());
+ throttleOperation(transactionProxy -> {
+ doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqDataExists());
- transactionProxy.exists(TestModel.TEST_PATH);
+ transactionProxy.exists(TestModel.TEST_PATH);
- transactionProxy.exists(TestModel.TEST_PATH);
- }
+ transactionProxy.exists(TestModel.TEST_PATH);
});
}
@Test
- public void testExistsThrottlingWhenShardNotFound(){
+ public void testExistsThrottlingWhenShardNotFound() {
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDataExists());
+ completeOperation(transactionProxy -> {
+ doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqDataExists());
- transactionProxy.exists(TestModel.TEST_PATH);
+ transactionProxy.exists(TestModel.TEST_PATH);
- transactionProxy.exists(TestModel.TEST_PATH);
- }
+ transactionProxy.exists(TestModel.TEST_PATH);
}, false);
}
@Test
- public void testExistsCompletion(){
- completeOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqDataExists());
+ public void testExistsCompletion() {
+ completeOperation(transactionProxy -> {
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+ any(ActorSelection.class), eqDataExists(), any(Timeout.class));
- transactionProxy.exists(TestModel.TEST_PATH);
+ transactionProxy.exists(TestModel.TEST_PATH);
- transactionProxy.exists(TestModel.TEST_PATH);
- }
+ transactionProxy.exists(TestModel.TEST_PATH);
});
}
@Test
- public void testReadyThrottling(){
+ public void testExistsCompletionForLocalShard() {
+ final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ completeOperationLocal(transactionProxy -> {
+ transactionProxy.exists(TestModel.TEST_PATH);
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ transactionProxy.exists(TestModel.TEST_PATH);
+ }, createDataTree(nodeToRead));
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ }
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), any(ReadyTransaction.class));
+ @Test
+ public void testExistsCompletionForLocalShardWhenExceptionOccurs() {
+ completeOperationLocal(transactionProxy -> {
+ transactionProxy.exists(TestModel.TEST_PATH);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ transactionProxy.exists(TestModel.TEST_PATH);
+ }, createDataTree());
- transactionProxy.ready();
- }
+ }
+
+ @Test
+ public void testReadyThrottling() {
+
+ throttleOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ expectBatchedModifications(1);
+
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+ transactionProxy.ready();
});
}
@Test
- public void testReadyThrottlingWithTwoTransactionContexts(){
+ public void testReadyThrottlingWithTwoTransactionContexts() {
+ throttleOperation(transactionProxy -> {
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
+
+ expectBatchedModifications(2);
+
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+ // Trying to write to Cars will cause another transaction context to get created
+ transactionProxy.write(CarsModel.BASE_PATH, carsNode);
+
+ // Now ready should block for both transaction contexts
+ transactionProxy.ready();
+ }, 1, true, TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+ .getOperationTimeoutInMillis()) * 2);
+ }
+
+ private void testModificationOperationBatching(TransactionType type) throws Exception {
+ int shardBatchedModificationCount = 3;
+ dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
+
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), type);
+
+ expectBatchedModifications(actorRef, shardBatchedModificationCount);
+
+ YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
+ NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
+ NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+
+ YangInstanceIdentifier writePath3 = TestModel.INNER_LIST_PATH;
+ NormalizedNode<?, ?> writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+
+ YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
+ NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ YangInstanceIdentifier mergePath2 = TestModel.OUTER_LIST_PATH;
+ NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+
+ YangInstanceIdentifier mergePath3 = TestModel.INNER_LIST_PATH;
+ NormalizedNode<?, ?> mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+
+ YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH;
+ YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH;
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, type);
+
+ transactionProxy.write(writePath1, writeNode1);
+ transactionProxy.write(writePath2, writeNode2);
+ transactionProxy.delete(deletePath1);
+ transactionProxy.merge(mergePath1, mergeNode1);
+ transactionProxy.merge(mergePath2, mergeNode2);
+ transactionProxy.write(writePath3, writeNode3);
+ transactionProxy.merge(mergePath3, mergeNode3);
+ transactionProxy.delete(deletePath2);
+
+ // This sends the last batch.
+ transactionProxy.ready();
+
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 3, batchedModifications.size());
+
+ verifyBatchedModifications(batchedModifications.get(0), false, new WriteModification(writePath1, writeNode1),
+ new WriteModification(writePath2, writeNode2), new DeleteModification(deletePath1));
+
+ verifyBatchedModifications(batchedModifications.get(1), false, new MergeModification(mergePath1, mergeNode1),
+ new MergeModification(mergePath2, mergeNode2), new WriteModification(writePath3, writeNode3));
+
+ verifyBatchedModifications(batchedModifications.get(2), true, true,
+ new MergeModification(mergePath3, mergeNode3), new DeleteModification(deletePath2));
+
+ assertEquals("getTotalMessageCount", 3, batchedModifications.get(2).getTotalMessagesSent());
+ }
+
+ @Test
+ public void testReadWriteModificationOperationBatching() throws Exception {
+ testModificationOperationBatching(READ_WRITE);
+ }
+
+ @Test
+ public void testWriteOnlyModificationOperationBatching() throws Exception {
+ testModificationOperationBatching(WRITE_ONLY);
+ }
+
+ @Test
+ public void testOptimizedWriteOnlyModificationOperationBatching() throws Exception {
+ dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
+ testModificationOperationBatching(WRITE_ONLY);
+ }
+
+ @Test
+ public void testModificationOperationBatchingWithInterleavedReads() throws Exception {
+
+ int shardBatchedModificationCount = 10;
+ dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
+
+ ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
+
+ expectBatchedModifications(actorRef, shardBatchedModificationCount);
+
+ final YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
+ final NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
+ NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+
+ final YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
+ final NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+
+ YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH;
+ NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+
+ final YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
+
+ doReturn(readDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(writePath2), any(Timeout.class));
+
+ doReturn(readDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(mergePath2), any(Timeout.class));
+
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
+
+ transactionProxy.write(writePath1, writeNode1);
+ transactionProxy.write(writePath2, writeNode2);
+
+ Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
+
+ assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
+
+ transactionProxy.merge(mergePath1, mergeNode1);
+ transactionProxy.merge(mergePath2, mergeNode2);
+
+ readOptional = transactionProxy.read(mergePath2).get(5, TimeUnit.SECONDS);
+
+ transactionProxy.delete(deletePath);
+
+ Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
+ assertEquals("Exists response", true, exists);
+
+ assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertEquals("Response NormalizedNode", mergeNode2, readOptional.get());
+
+ List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
+ assertEquals("Captured BatchedModifications count", 3, batchedModifications.size());
+
+ verifyBatchedModifications(batchedModifications.get(0), false, new WriteModification(writePath1, writeNode1),
+ new WriteModification(writePath2, writeNode2));
+
+ verifyBatchedModifications(batchedModifications.get(1), false, new MergeModification(mergePath1, mergeNode1),
+ new MergeModification(mergePath2, mergeNode2));
+
+ verifyBatchedModifications(batchedModifications.get(2), false, new DeleteModification(deletePath));
+
+ InOrder inOrder = Mockito.inOrder(mockActorContext);
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
+
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(writePath2), any(Timeout.class));
+
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
+
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqReadData(mergePath2), any(Timeout.class));
+
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
+
+ inOrder.verify(mockActorContext).executeOperationAsync(
+ eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
+ }
+
+ @Test
+ public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException,
+ java.util.concurrent.TimeoutException {
+ SchemaContext schemaContext = SchemaContextHelper.full();
+ Configuration configuration = mock(Configuration.class);
+ doReturn(configuration).when(mockActorContext).getConfiguration();
+ doReturn(schemaContext).when(mockActorContext).getSchemaContext();
+ doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames();
+
+ NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
+
+ setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
+ setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));
+
+ doReturn(MemberName.forName(memberName)).when(mockActorContext).getCurrentMemberName();
+
+ doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
+
+ Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
- throttleOperation(new TransactionProxyOperation() {
- @Override
- public void run(TransactionProxy transactionProxy) {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
+ assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+
+ NormalizedNode<?, ?> normalizedNode = readOptional.get();
+
+ assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
+
+ @SuppressWarnings("unchecked")
+ Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
- doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(nodeToWrite));
+ for (NormalizedNode<?,?> node : collection) {
+ assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
+ }
+
+ assertTrue("Child with QName = " + TestModel.TEST_QNAME + " not found",
+ NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME) != null);
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), eqWriteData(carsNode));
+ assertEquals(expectedNode1, NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME));
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), any(ReadyTransaction.class));
+ assertTrue("Child with QName = " + CarsModel.BASE_QNAME + " not found",
+ NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME) != null);
- transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+ assertEquals(expectedNode2, NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME));
+ }
- transactionProxy.write(TestModel.TEST_PATH, carsNode);
- transactionProxy.ready();
- }
- }, 2, true);
+ private void setUpReadData(String shardName, NormalizedNode<?, ?> expectedNode) {
+ ActorSystem actorSystem = getSystem();
+ ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
+
+ doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+ .actorSelection(shardActorRef.path().toString());
+
+ doReturn(primaryShardInfoReply(getSystem(), shardActorRef)).when(mockActorContext)
+ .findPrimaryShardAsync(eq(shardName));
+
+ ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
+
+ doReturn(actorSystem.actorSelection(txActorRef.path())).when(mockActorContext)
+ .actorSelection(txActorRef.path().toString());
+
+ doReturn(Futures.successful(createTransactionReply(txActorRef, DataStoreVersions.CURRENT_VERSION)))
+ .when(mockActorContext).executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
+ eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
+
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class));
}
}