Examples with DOMStoreWriteTransaction org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction used on opensource projects

Example 16 with DOMStoreWriteTransaction

use of org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction in project controller by opendaylight.

the class DataTreeCohortIntegrationTest method testAbortAfterCanCommit.

/**
 * FIXME: Since we invoke DOMDataTreeCommitCohort#canCommit on preCommit (as that's when we generate a
 * DataTreeCandidate) and since currently preCommit is a noop in the Shard backend (it is combined with commit),
 * we can't actually test abort after canCommit.
 */
@SuppressWarnings("unchecked")
@Test
@Ignore
public void testAbortAfterCanCommit() throws Exception {
    final DOMDataTreeCommitCohort cohortToAbort = mock(DOMDataTreeCommitCohort.class);
    final PostCanCommitStep stepToAbort = mock(PostCanCommitStep.class);
    doReturn(ThreePhaseCommitStep.NOOP_ABORT_FUTURE).when(stepToAbort).abort();
    doReturn(PostPreCommitStep.NOOP_FUTURE).when(stepToAbort).preCommit();
    doReturn(Futures.immediateCheckedFuture(stepToAbort)).when(cohortToAbort).canCommit(any(Object.class), any(Collection.class), any(SchemaContext.class));
    IntegrationTestKit kit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
    try (AbstractDataStore dataStore = kit.setupAbstractDataStore(DistributedDataStore.class, "testAbortAfterCanCommit", "test-1", "cars-1")) {
        dataStore.registerCommitCohort(TEST_ID, cohortToAbort);
        IntegrationTestKit.verifyShardState(dataStore, "test-1", state -> assertEquals("Cohort registrations", 1, state.getCommitCohortActors().size()));
        DOMStoreWriteTransaction writeTx = dataStore.newWriteOnlyTransaction();
        writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
        writeTx.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
        DOMStoreThreePhaseCommitCohort dsCohort = writeTx.ready();
        dsCohort.canCommit().get(5, TimeUnit.SECONDS);
        dsCohort.preCommit().get(5, TimeUnit.SECONDS);
        dsCohort.abort().get(5, TimeUnit.SECONDS);
        verify(stepToAbort).abort();
    }
}

Example 17 with DOMStoreWriteTransaction

use of org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction 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 18 with DOMStoreWriteTransaction

use of org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction 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 19 with DOMStoreWriteTransaction

use of org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction in project controller by opendaylight.

the class ClusterAdminRpcServiceTest method writeCarsNodeAndVerify.

private static NormalizedNode<?, ?> writeCarsNodeAndVerify(AbstractDataStore writeToStore, AbstractDataStore readFromStore) throws Exception {
    DOMStoreWriteTransaction writeTx = writeToStore.newWriteOnlyTransaction();
    NormalizedNode<?, ?> carsNode = CarsModel.create();
    writeTx.write(CarsModel.BASE_PATH, carsNode);
    DOMStoreThreePhaseCommitCohort cohort = writeTx.ready();
    Boolean canCommit = cohort.canCommit().get(7, TimeUnit.SECONDS);
    assertEquals("canCommit", TRUE, canCommit);
    cohort.preCommit().get(5, TimeUnit.SECONDS);
    cohort.commit().get(5, TimeUnit.SECONDS);
    readCarsNodeAndVerify(readFromStore, carsNode);
    return carsNode;
}

Example 20 with DOMStoreWriteTransaction

use of org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction in project controller by opendaylight.

the class NormalizedNodeAggregatorTest method getRootNode.

public static NormalizedNode<?, ?> getRootNode(NormalizedNode<?, ?> moduleNode, SchemaContext schemaContext) throws ReadFailedException, ExecutionException, InterruptedException {
    try (InMemoryDOMDataStore store = new InMemoryDOMDataStore("test", Executors.newSingleThreadExecutor())) {
        store.onGlobalContextUpdated(schemaContext);
        DOMStoreWriteTransaction writeTransaction = store.newWriteOnlyTransaction();
        writeTransaction.merge(YangInstanceIdentifier.of(moduleNode.getNodeType()), moduleNode);
        DOMStoreThreePhaseCommitCohort ready = writeTransaction.ready();
        ready.canCommit().get();
        ready.preCommit().get();
        ready.commit().get();
        DOMStoreReadTransaction readTransaction = store.newReadOnlyTransaction();
        CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read = readTransaction.read(YangInstanceIdentifier.EMPTY);
        Optional<NormalizedNode<?, ?>> nodeOptional = read.checkedGet();
        return nodeOptional.get();
    }
}