Examples with CreateTransactionReply org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply used on opensource projects

Example 1 with CreateTransactionReply

use of org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply in project controller by opendaylight.

the class ShardTest method testCreateTransaction.

@Test
public void testCreateTransaction() {
    new ShardTestKit(getSystem()) {

        {
            final ActorRef shard = actorFactory.createActor(newShardProps(), "testCreateTransaction");
            waitUntilLeader(shard);
            shard.tell(new UpdateSchemaContext(TestModel.createTestContext()), getRef());
            shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(), DataStoreVersions.CURRENT_VERSION).toSerializable(), getRef());
            final CreateTransactionReply reply = expectMsgClass(duration("3 seconds"), CreateTransactionReply.class);
            final String path = reply.getTransactionPath().toString();
            assertTrue("Unexpected transaction path " + path, path.startsWith(String.format("akka://test/user/testCreateTransaction/shard-%s-%s:ShardTransactionTest@0:", shardID.getShardName(), shardID.getMemberName().getName())));
        }
    };
}

Example 2 with CreateTransactionReply

use of org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply in project controller by opendaylight.

the class ShardTest method testCreateTransactionOnChain.

@Test
public void testCreateTransactionOnChain() {
    new ShardTestKit(getSystem()) {

        {
            final ActorRef shard = actorFactory.createActor(newShardProps(), "testCreateTransactionOnChain");
            waitUntilLeader(shard);
            shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(), DataStoreVersions.CURRENT_VERSION).toSerializable(), getRef());
            final CreateTransactionReply reply = expectMsgClass(duration("3 seconds"), CreateTransactionReply.class);
            final String path = reply.getTransactionPath().toString();
            assertTrue("Unexpected transaction path " + path, path.startsWith(String.format("akka://test/user/testCreateTransactionOnChain/shard-%s-%s:ShardTransactionTest@0:", shardID.getShardName(), shardID.getMemberName().getName())));
        }
    };
}

Example 3 with CreateTransactionReply

use of org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply in project controller by opendaylight.

the class Shard method createTransaction.

@SuppressWarnings("checkstyle:IllegalCatch")
private void createTransaction(final CreateTransaction createTransaction) {
    try {
        if (TransactionType.fromInt(createTransaction.getTransactionType()) != TransactionType.READ_ONLY && failIfIsolatedLeader(getSender())) {
            return;
        }
        ActorRef transactionActor = createTransaction(createTransaction.getTransactionType(), createTransaction.getTransactionId());
        getSender().tell(new CreateTransactionReply(Serialization.serializedActorPath(transactionActor), createTransaction.getTransactionId(), createTransaction.getVersion()).toSerializable(), getSelf());
    } catch (Exception e) {
        getSender().tell(new Failure(e), getSelf());
    }
}

Example 4 with CreateTransactionReply

use of org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply in project controller by opendaylight.

the class ShardTest method testBatchedModificationsOnTransactionChain.

@Test
public void testBatchedModificationsOnTransactionChain() throws Exception {
    new ShardTestKit(getSystem()) {

        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()), "testBatchedModificationsOnTransactionChain");
            waitUntilLeader(shard);
            final LocalHistoryIdentifier historyId = nextHistoryId();
            final TransactionIdentifier transactionID1 = new TransactionIdentifier(historyId, 0);
            final TransactionIdentifier transactionID2 = new TransactionIdentifier(historyId, 1);
            final FiniteDuration duration = duration("5 seconds");
            // Send a BatchedModifications to start a chained write
            // transaction and ready it.
            final ContainerNode containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
            final YangInstanceIdentifier path = TestModel.TEST_PATH;
            shard.tell(newBatchedModifications(transactionID1, path, containerNode, true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);
            // Create a read Tx on the same chain.
            shard.tell(new CreateTransaction(transactionID2, TransactionType.READ_ONLY.ordinal(), DataStoreVersions.CURRENT_VERSION).toSerializable(), getRef());
            final CreateTransactionReply createReply = expectMsgClass(duration("3 seconds"), CreateTransactionReply.class);
            getSystem().actorSelection(createReply.getTransactionPath()).tell(new ReadData(path, DataStoreVersions.CURRENT_VERSION), getRef());
            final ReadDataReply readReply = expectMsgClass(duration("3 seconds"), ReadDataReply.class);
            assertEquals("Read node", containerNode, readReply.getNormalizedNode());
            // Commit the write transaction.
            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply.fromSerializable(expectMsgClass(duration, CanCommitTransactionReply.class));
            assertEquals("Can commit", true, canCommitReply.getCanCommit());
            shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);
            // Verify data in the data store.
            final NormalizedNode<?, ?> actualNode = readStore(shard, path);
            assertEquals("Stored node", containerNode, actualNode);
        }
    };
}

Example 5 with CreateTransactionReply

use of org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply in project controller by opendaylight.

the class TransactionProxyTest method completeOperation.

private void completeOperation(final TransactionProxyOperation operation, final boolean shardFound) {
    ActorSystem actorSystem = getSystem();
    ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
    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));
    } else {
        doReturn(Futures.failed(new PrimaryNotFoundException("test"))).when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
    }
    ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
    String actorPath = txActorRef.path().toString();
    CreateTransactionReply createTransactionReply = new CreateTransactionReply(actorPath, nextTransactionId(), DataStoreVersions.CURRENT_VERSION);
    doReturn(actorSystem.actorSelection(actorPath)).when(mockActorContext).actorSelection(actorPath);
    doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
    TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
    long start = System.nanoTime();
    operation.run(transactionProxy);
    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);
}