Examples with WriteModification org.opendaylight.controller.cluster.datastore.modification.WriteModification used on opensource projects

Example 6 with WriteModification

use of org.opendaylight.controller.cluster.datastore.modification.WriteModification in project controller by opendaylight.

the class AbstractShardTest method newBatchedModifications.

static BatchedModifications newBatchedModifications(final TransactionIdentifier transactionID, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data, final boolean ready, final boolean doCommitOnReady, final int messagesSent) {
    final BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
    batched.addModification(new WriteModification(path, data));
    batched.setReady(ready);
    batched.setDoCommitOnReady(doCommitOnReady);
    batched.setTotalMessagesSent(messagesSent);
    return batched;
}

Example 7 with WriteModification

use of org.opendaylight.controller.cluster.datastore.modification.WriteModification in project controller by opendaylight.

the class AbstractShardTest method prepareBatchedModifications.

protected static BatchedModifications prepareBatchedModifications(final TransactionIdentifier transactionID, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data, final boolean doCommitOnReady) {
    final MutableCompositeModification modification = new MutableCompositeModification();
    modification.addModification(new WriteModification(path, data));
    return prepareBatchedModifications(transactionID, modification, doCommitOnReady);
}

Example 8 with WriteModification

use of org.opendaylight.controller.cluster.datastore.modification.WriteModification in project controller by opendaylight.

the class TransactionChainProxyTest method testChainedReadWriteTransactions.

/**
 * Tests 2 successive chained read-write transactions and verifies the second transaction isn't
 * initiated until the first one completes its read future.
 */
@Test
@SuppressWarnings("checkstyle:IllegalCatch")
public void testChainedReadWriteTransactions() throws Exception {
    try (TransactionChainProxy txChainProxy = new TransactionChainProxy(mockComponentFactory, historyId)) {
        ActorRef txActorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
        expectBatchedModifications(txActorRef1, 1);
        Promise<Object> readyReplyPromise1 = akka.dispatch.Futures.promise();
        doReturn(readyReplyPromise1.future()).when(mockActorContext).executeOperationAsync(eq(actorSelection(txActorRef1)), isA(BatchedModifications.class), any(Timeout.class));
        DOMStoreWriteTransaction writeTx1 = txChainProxy.newReadWriteTransaction();
        NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
        writeTx1.write(TestModel.TEST_PATH, writeNode1);
        writeTx1.ready();
        verifyOneBatchedModification(txActorRef1, new WriteModification(TestModel.TEST_PATH, writeNode1), true);
        String tx2MemberName = "mock-member";
        ActorRef shardActorRef2 = setupActorContextWithoutInitialCreateTransaction(getSystem());
        ActorRef txActorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE, DataStoreVersions.CURRENT_VERSION, tx2MemberName, shardActorRef2);
        expectBatchedModifications(txActorRef2, 1);
        final NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
        final DOMStoreWriteTransaction writeTx2 = txChainProxy.newReadWriteTransaction();
        final AtomicReference<Exception> caughtEx = new AtomicReference<>();
        final CountDownLatch write2Complete = new CountDownLatch(1);
        new Thread(() -> {
            try {
                writeTx2.write(TestModel.OUTER_LIST_PATH, writeNode2);
            } catch (Exception e) {
                caughtEx.set(e);
            } finally {
                write2Complete.countDown();
            }
        }).start();
        assertEquals("Tx 2 write should've completed", true, write2Complete.await(5, TimeUnit.SECONDS));
        if (caughtEx.get() != null) {
            throw caughtEx.get();
        }
        try {
            verify(mockActorContext, never()).executeOperationAsync(eq(getSystem().actorSelection(shardActorRef2.path())), eqCreateTransaction(tx2MemberName, READ_WRITE));
        } catch (AssertionError e) {
            fail("Tx 2 should not have initiated until the Tx 1's ready future completed");
        }
        readyReplyPromise1.success(readyTxReply(txActorRef1.path().toString()).value().get().get());
        verify(mockActorContext, timeout(5000)).executeOperationAsync(eq(getSystem().actorSelection(shardActorRef2.path())), eqCreateTransaction(tx2MemberName, READ_WRITE), any(Timeout.class));
    }
}

Example 9 with WriteModification

use of org.opendaylight.controller.cluster.datastore.modification.WriteModification in project controller by opendaylight.

the class TransactionChainProxyTest method testChainedWriteOnlyTransactions.

/**
 * Tests 2 successive chained write-only transactions and verifies the second transaction isn't
 * initiated until the first one completes its read future.
 */
@Test
@SuppressWarnings("checkstyle:IllegalCatch")
public void testChainedWriteOnlyTransactions() throws Exception {
    dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
    try (TransactionChainProxy txChainProxy = new TransactionChainProxy(mockComponentFactory, historyId)) {
        ActorRef txActorRef1 = setupActorContextWithoutInitialCreateTransaction(getSystem());
        Promise<Object> batchedReplyPromise1 = akka.dispatch.Futures.promise();
        doReturn(batchedReplyPromise1.future()).when(mockActorContext).executeOperationAsync(eq(actorSelection(txActorRef1)), isA(BatchedModifications.class), any(Timeout.class));
        DOMStoreWriteTransaction writeTx1 = txChainProxy.newWriteOnlyTransaction();
        NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
        writeTx1.write(TestModel.TEST_PATH, writeNode1);
        writeTx1.ready();
        verify(mockActorContext, times(1)).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
        verifyOneBatchedModification(txActorRef1, new WriteModification(TestModel.TEST_PATH, writeNode1), true);
        ActorRef txActorRef2 = setupActorContextWithoutInitialCreateTransaction(getSystem());
        expectBatchedModifications(txActorRef2, 1);
        final NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
        final DOMStoreWriteTransaction writeTx2 = txChainProxy.newWriteOnlyTransaction();
        final AtomicReference<Exception> caughtEx = new AtomicReference<>();
        final CountDownLatch write2Complete = new CountDownLatch(1);
        new Thread(() -> {
            try {
                writeTx2.write(TestModel.OUTER_LIST_PATH, writeNode2);
            } catch (Exception e) {
                caughtEx.set(e);
            } finally {
                write2Complete.countDown();
            }
        }).start();
        assertEquals("Tx 2 write should've completed", true, write2Complete.await(5, TimeUnit.SECONDS));
        if (caughtEx.get() != null) {
            throw caughtEx.get();
        }
        try {
            verify(mockActorContext, times(1)).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
        } catch (AssertionError e) {
            fail("Tx 2 should not have initiated until the Tx 1's ready future completed");
        }
        batchedReplyPromise1.success(readyTxReply(txActorRef1.path().toString()).value().get().get());
        // Tx 2 should've proceeded to find the primary shard.
        verify(mockActorContext, timeout(5000).times(2)).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
    }
}

Example 10 with WriteModification

use of org.opendaylight.controller.cluster.datastore.modification.WriteModification in project controller by opendaylight.

the class TransactionProxyTest method testWriteAfterAsyncRead.

@Test
@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), any(Timeout.class));
    doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
    expectBatchedModificationsReady(actorRef);
    final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
    final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
    final CountDownLatch readComplete = new CountDownLatch(1);
    final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
    com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH), new FutureCallback<Optional<NormalizedNode<?, ?>>>() {

        @Override
        public void onSuccess(final Optional<NormalizedNode<?, ?>> result) {
            try {
                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
            } catch (Exception e) {
                caughtEx.set(e);
            } finally {
                readComplete.countDown();
            }
        }

        @Override
        public void onFailure(final Throwable failure) {
            caughtEx.set(failure);
            readComplete.countDown();
        }
    }, MoreExecutors.directExecutor());
    createTxPromise.success(createTransactionReply(actorRef, DataStoreVersions.CURRENT_VERSION));
    Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS);
    final Throwable t = caughtEx.get();
    if (t != null) {
        Throwables.propagateIfPossible(t, Exception.class);
        throw new RuntimeException(t);
    }
    // This sends the batched modification.
    transactionProxy.ready();
    verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), true);
}