Java ReadDataReply类代码示例

import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply; //导入依赖的package包/类
@Test
public void testOnReceiveReadData() throws Exception {
    new JavaTestKit(getSystem()) {
        {
            testOnReceiveReadData(newTransactionActor(RO, readOnlyTransaction(), "testReadDataRO"));

            testOnReceiveReadData(newTransactionActor(RW, readWriteTransaction(), "testReadDataRW"));
        }

        private void testOnReceiveReadData(final ActorRef transaction) {
            transaction.tell(new ReadData(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION),
                    getRef());

            ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);

            assertNotNull(reply.getNormalizedNode());
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply; //导入依赖的package包/类
@Test
public void testOnReceiveReadDataWhenDataNotFound() throws Exception {
    new JavaTestKit(getSystem()) {
        {
            testOnReceiveReadDataWhenDataNotFound(
                    newTransactionActor(RO, readOnlyTransaction(), "testReadDataWhenDataNotFoundRO"));

            testOnReceiveReadDataWhenDataNotFound(
                    newTransactionActor(RW, readWriteTransaction(), "testReadDataWhenDataNotFoundRW"));
        }

        private void testOnReceiveReadDataWhenDataNotFound(final ActorRef transaction) {
            transaction.tell(new ReadData(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), getRef());

            ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);

            assertTrue(reply.getNormalizedNode() == null);
        }
    };
}
 

import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply; //导入依赖的package包/类
protected void readData(final AbstractShardDataTreeTransaction<?> transaction, final ReadData message) {
    if (checkClosed(transaction)) {
        return;
    }

    final YangInstanceIdentifier path = message.getPath();
    Optional<NormalizedNode<?, ?>> optional = transaction.getSnapshot().readNode(path);
    ReadDataReply readDataReply = new ReadDataReply(optional.orNull(), message.getVersion());
    sender().tell(readDataReply.toSerializable(), self());
}
 

import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply; //导入依赖的package包/类
protected Future<ReadDataReply> readDataReply(final NormalizedNode<?, ?> data) {
    return Futures.successful(new ReadDataReply(data, DataStoreVersions.CURRENT_VERSION));
}
 

import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply; //导入依赖的package包/类
@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);
        }
    };
}