public class BindingDOMRpcProviderServiceAdapter {
- private static final Set<YangInstanceIdentifier> GLOBAL = ImmutableSet.of(YangInstanceIdentifier.builder().build());
+ private static final Set<YangInstanceIdentifier> GLOBAL = ImmutableSet.of(YangInstanceIdentifier.EMPTY);
private final BindingToNormalizedNodeCodec codec;
private final DOMRpcProviderService domRpcRegistry;
package org.opendaylight.controller.cluster.datastore.node;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeGetter;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
public class NormalizedNodeToNodeCodecTest {
private SchemaContext schemaContext;
NormalizedNodeGetter normalizedNodeGetter = new NormalizedNodeGetter(id);
new NormalizedNodeNavigator(normalizedNodeGetter).navigate(
- PathUtils.toString(YangInstanceIdentifier.builder().build()), documentOne);
+ PathUtils.toString(YangInstanceIdentifier.EMPTY), documentOne);
// Validate the value of id can be retrieved from the normalized node
NormalizedNode<?, ?> output = normalizedNodeGetter.getOutput();
@NotThreadSafe
public class ShardDataTree extends ShardDataTreeTransactionParent {
private static final Logger LOG = LoggerFactory.getLogger(ShardDataTree.class);
- private static final YangInstanceIdentifier ROOT_PATH = YangInstanceIdentifier.builder().build();
private final Map<String, ShardDataTreeTransactionChain> transactionChains = new HashMap<>();
private final ShardDataTreeChangeListenerPublisher treeChangeListenerPublisher;
}
private Optional<DataTreeCandidate> readCurrentData() {
- final Optional<NormalizedNode<?, ?>> currentState = dataTree.takeSnapshot().readNode(ROOT_PATH);
+ final Optional<NormalizedNode<?, ?>> currentState = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY);
return currentState.isPresent() ? Optional.of(DataTreeCandidates.fromNormalizedNode(
- ROOT_PATH, currentState.get())) : Optional.<DataTreeCandidate>absent();
+ YangInstanceIdentifier.EMPTY, currentState.get())) : Optional.<DataTreeCandidate>absent();
}
public Entry<ListenerRegistration<DOMDataTreeChangeListener>, Optional<DataTreeCandidate>> registerTreeChangeListener(
* Date: 8/6/14
*/
public class ShardReadTransaction extends ShardTransaction {
- private static final YangInstanceIdentifier DATASTORE_ROOT = YangInstanceIdentifier.builder().build();
-
private final AbstractShardDataTreeTransaction<?> transaction;
public ShardReadTransaction(AbstractShardDataTreeTransaction<?> transaction, ActorRef shardActor,
final ActorRef sender = getSender();
final ActorRef self = getSelf();
- final Optional<NormalizedNode<?, ?>> result = transaction.getSnapshot().readNode(DATASTORE_ROOT);
+ final Optional<NormalizedNode<?, ?>> result = transaction.getSnapshot().readNode(YangInstanceIdentifier.EMPTY);
byte[] serialized = SerializationUtils.serializeNormalizedNode(result.get());
sender.tell(new CaptureSnapshotReply(serialized), self);
* @author Thomas Pantelis
*/
class ShardSnapshotCohort implements RaftActorSnapshotCohort {
-
- private static final YangInstanceIdentifier DATASTORE_ROOT = YangInstanceIdentifier.builder().build();
-
- private int createSnapshotTransactionCounter;
private final ShardTransactionActorFactory transactionActorFactory;
private final ShardDataTree store;
- private final Logger log;
private final String logId;
+ private final Logger log;
+
+ private int createSnapshotTransactionCounter;
ShardSnapshotCohort(ShardTransactionActorFactory transactionActorFactory, ShardDataTree store,
Logger log, String logId) {
NormalizedNode<?, ?> node = SerializationUtils.deserializeNormalizedNode(snapshotBytes);
// delete everything first
- transaction.getSnapshot().delete(DATASTORE_ROOT);
+ transaction.getSnapshot().delete(YangInstanceIdentifier.EMPTY);
// Add everything from the remote node back
- transaction.getSnapshot().write(DATASTORE_ROOT, node);
+ transaction.getSnapshot().write(YangInstanceIdentifier.EMPTY, node);
syncCommitTransaction(transaction);
} catch (InterruptedException | ExecutionException e) {
log.error("{}: An exception occurred when applying snapshot", logId, e);
configDomStore), futureExecutor)) {
DOMDataReadWriteTransaction dataTxn = dataBroker.newReadWriteTransaction();
- dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
- dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
- dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build());
+ dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
+ dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
+ dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
verify(configDomStore, never()).newReadWriteTransaction();
verify(operationalDomStore, times(1)).newReadWriteTransaction();
- dataTxn.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
+ dataTxn.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
verify(configDomStore, times(1)).newReadWriteTransaction();
verify(operationalDomStore, times(1)).newReadWriteTransaction();
configDomStore), futureExecutor)) {
DOMDataWriteTransaction dataTxn = dataBroker.newWriteOnlyTransaction();
- dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
- dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
+ dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
+ dataTxn.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
verify(configDomStore, never()).newWriteOnlyTransaction();
verify(operationalDomStore, times(1)).newWriteOnlyTransaction();
- dataTxn.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
+ dataTxn.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
verify(configDomStore, times(1)).newWriteOnlyTransaction();
verify(operationalDomStore, times(1)).newWriteOnlyTransaction();
configDomStore), futureExecutor)) {
DOMDataReadOnlyTransaction dataTxn = dataBroker.newReadOnlyTransaction();
- dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build());
- dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build());
+ dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
+ dataTxn.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
verify(configDomStore, never()).newReadOnlyTransaction();
verify(operationalDomStore, times(1)).newReadOnlyTransaction();
- dataTxn.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.builder().build());
+ dataTxn.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY);
verify(configDomStore, times(1)).newReadOnlyTransaction();
verify(operationalDomStore, times(1)).newReadOnlyTransaction();
}) {
DOMDataReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
- domDataReadWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build());
+ domDataReadWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
domDataReadWriteTransaction.submit();
}) {
DOMDataReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
- domDataReadWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
- domDataReadWriteTransaction.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
+ domDataReadWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
+ domDataReadWriteTransaction.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
domDataReadWriteTransaction.submit();
verify(mockChain, never()).newWriteOnlyTransaction();
- domDataWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().build(), mock(NormalizedNode.class));
+ domDataWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY, mock(NormalizedNode.class));
}
}
writeToStore(testStore, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- final NormalizedNode<?, ?> root = readStore(testStore, YangInstanceIdentifier.builder().build());
+ final NormalizedNode<?, ?> root = readStore(testStore, YangInstanceIdentifier.EMPTY);
InMemorySnapshotStore.addSnapshot(shardID.toString(), Snapshot.create(
SerializationUtils.serializeNormalizedNode(root),
final DataTreeCandidateTip mockCandidate = mock(DataTreeCandidateTip.class, name);
final DataTreeCandidateNode mockCandidateNode = mock(DataTreeCandidateNode.class, name + "-node");
doReturn(ModificationType.UNMODIFIED).when(mockCandidateNode).getModificationType();
- doReturn(YangInstanceIdentifier.builder().build()).when(mockCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.EMPTY).when(mockCandidate).getRootPath();
doReturn(mockCandidateNode).when(mockCandidate).getRootNode();
return mockCandidate;
}
@Override
public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
- createdData.put(YangInstanceIdentifier.builder().build(), CompositeModel.createDocumentOne(CompositeModel.createTestContext()));
+ createdData.put(YangInstanceIdentifier.EMPTY, CompositeModel.createDocumentOne(CompositeModel.createTestContext()));
return createdData;
}
@Override
public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
- updatedData.put(YangInstanceIdentifier.builder().build(), CompositeModel.createTestContainer());
+ updatedData.put(YangInstanceIdentifier.EMPTY, CompositeModel.createTestContainer());
return updatedData;
}
@Override
public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getOriginalData() {
- originalData.put(YangInstanceIdentifier.builder().build(), CompositeModel.createFamily());
+ originalData.put(YangInstanceIdentifier.EMPTY, CompositeModel.createFamily());
return originalData;
}
ShardDataTree dataTree = new ShardDataTree(SchemaContextHelper.full(), TreeType.OPERATIONAL);
AbstractShardTest.writeToStore(dataTree, CarsModel.BASE_PATH, carsNode);
NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree.getDataTree(),
- YangInstanceIdentifier.builder().build());
+ YangInstanceIdentifier.EMPTY);
Snapshot carsSnapshot = Snapshot.create(SerializationUtils.serializeNormalizedNode(root),
Collections.<ReplicatedLogEntry>emptyList(), 2, 1, 2, 1, 1, "member-1");
NormalizedNode<?, ?> peopleNode = PeopleModel.create();
dataTree = new ShardDataTree(SchemaContextHelper.full(), TreeType.OPERATIONAL);
AbstractShardTest.writeToStore(dataTree, PeopleModel.BASE_PATH, peopleNode);
- root = AbstractShardTest.readStore(dataTree.getDataTree(), YangInstanceIdentifier.builder().build());
+ root = AbstractShardTest.readStore(dataTree.getDataTree(), YangInstanceIdentifier.EMPTY);
Snapshot peopleSnapshot = Snapshot.create(SerializationUtils.serializeNormalizedNode(root),
Collections.<ReplicatedLogEntry>emptyList(), 2, 1, 2, 1, 1, "member-1");
@Test
public void testWrite() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
localTransactionContext.executeModification(new WriteModification(yangInstanceIdentifier, normalizedNode));
verify(readWriteTransaction).write(yangInstanceIdentifier, normalizedNode);
@Test
public void testMerge() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
localTransactionContext.executeModification(new MergeModification(yangInstanceIdentifier, normalizedNode));
verify(readWriteTransaction).merge(yangInstanceIdentifier, normalizedNode);
@Test
public void testDelete() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
localTransactionContext.executeModification(new DeleteModification(yangInstanceIdentifier));
verify(readWriteTransaction).delete(yangInstanceIdentifier);
}
@Test
public void testRead() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
doReturn(Futures.immediateCheckedFuture(Optional.of(normalizedNode))).when(readWriteTransaction).read(yangInstanceIdentifier);
localTransactionContext.executeRead(new ReadData(yangInstanceIdentifier, DataStoreVersions.CURRENT_VERSION),
@Test
public void testExists() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
doReturn(Futures.immediateCheckedFuture(true)).when(readWriteTransaction).exists(yangInstanceIdentifier);
localTransactionContext.executeRead(new DataExists(yangInstanceIdentifier, DataStoreVersions.CURRENT_VERSION),
SettableFuture.<Boolean>create());
@Test
public void testReadyWithWriteError() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
RuntimeException error = new RuntimeException("mock");
doThrow(error).when(readWriteTransaction).write(yangInstanceIdentifier, normalizedNode);
@Test
public void testReadyWithMergeError() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
RuntimeException error = new RuntimeException("mock");
doThrow(error).when(readWriteTransaction).merge(yangInstanceIdentifier, normalizedNode);
@Test
public void testReadyWithDeleteError() {
- YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
RuntimeException error = new RuntimeException("mock");
doThrow(error).when(readWriteTransaction).delete(yangInstanceIdentifier);
writeToStore(store, TestModel.TEST_PATH, container);
- final YangInstanceIdentifier root = YangInstanceIdentifier.builder().build();
+ final YangInstanceIdentifier root = YangInstanceIdentifier.EMPTY;
final NormalizedNode<?,?> expected = readStore(store, root);
final Snapshot snapshot = Snapshot.create(SerializationUtils.serializeNormalizedNode(expected),
final String transactionID = "tx1";
final MutableCompositeModification modification = new MutableCompositeModification();
- modification.addModification(new DeleteModification(YangInstanceIdentifier.builder().build()));
+ modification.addModification(new DeleteModification(YangInstanceIdentifier.EMPTY));
final ShardDataTreeCohort cohort = mock(ShardDataTreeCohort.class, "cohort1");
doReturn(Futures.immediateFuture(Boolean.TRUE)).when(cohort).canCommit();
doReturn(Futures.immediateFuture(Boolean.TRUE)).when(cohort).preCommit();
waitUntilLeader(shard);
writeToStore(shard, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- final NormalizedNode<?,?> expectedRoot = readStore(shard, YangInstanceIdentifier.builder().build());
+ final NormalizedNode<?,?> expectedRoot = readStore(shard, YangInstanceIdentifier.EMPTY);
// Trigger creation of a snapshot by ensuring
final RaftActorContext raftActorContext = ((TestShard) shard.underlyingActor()).getRaftActorContext();
commitTransaction(store, putTransaction);
- final NormalizedNode<?, ?> expected = readStore(store, YangInstanceIdentifier.builder().build());
+ final NormalizedNode<?, ?> expected = readStore(store, YangInstanceIdentifier.EMPTY);
final DataTreeModification writeTransaction = store.takeSnapshot().newModification();
- writeTransaction.delete(YangInstanceIdentifier.builder().build());
- writeTransaction.write(YangInstanceIdentifier.builder().build(), expected);
+ writeTransaction.delete(YangInstanceIdentifier.EMPTY);
+ writeTransaction.write(YangInstanceIdentifier.EMPTY, expected);
commitTransaction(store, writeTransaction);
- final NormalizedNode<?, ?> actual = readStore(store, YangInstanceIdentifier.builder().build());
+ final NormalizedNode<?, ?> actual = readStore(store, YangInstanceIdentifier.EMPTY);
assertEquals(expected, actual);
}
}
private void testOnReceiveReadData(final ActorRef transaction) {
- transaction.tell(new ReadData(YangInstanceIdentifier.builder().build(),
- DataStoreVersions.CURRENT_VERSION),getRef());
+ transaction.tell(new ReadData(YangInstanceIdentifier.EMPTY,
+ DataStoreVersions.CURRENT_VERSION), getRef());
ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);
}
private void testOnReceiveDataExistsPositive(final ActorRef transaction) {
- transaction.tell(new DataExists(YangInstanceIdentifier.builder().build(),
- DataStoreVersions.CURRENT_VERSION),getRef());
+ transaction.tell(new DataExists(YangInstanceIdentifier.EMPTY,
+ DataStoreVersions.CURRENT_VERSION), getRef());
DataExistsReply reply = expectMsgClass(duration("5 seconds"), DataExistsReply.class);
ImmutableNodes.containerNode(TestModel.TEST_QNAME));
NormalizedNode<?,?> expectedRoot = ShardTest.readStore(store.getDataTree(),
- YangInstanceIdentifier.builder().build());
+ YangInstanceIdentifier.EMPTY);
final ActorRef transaction = newTransactionActor(TransactionType.READ_ONLY, readOnlyTransaction(),
"testOnReceiveCreateSnapshot");
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
- YangInstanceIdentifier.builder().build()).get(5, TimeUnit.SECONDS);
+ YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.builder().build()), any(Timeout.class));
+ eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class));
}
}
writeToStore(store, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- YangInstanceIdentifier root = YangInstanceIdentifier.builder().build();
+ YangInstanceIdentifier root = YangInstanceIdentifier.EMPTY;
NormalizedNode<?,?> expected = readStore(store, root);
NormalizedNodeMessages.Container encode = codec.encode(expected);
NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
- Optional<NormalizedNode<?, ?>> optional = NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.builder().build(),
+ Optional<NormalizedNode<?, ?>> optional = NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.EMPTY,
ImmutableList.of(
Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode1, schemaContext)),
Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode2, schemaContext))),
DOMStoreWriteTransaction writeTransaction = store.newWriteOnlyTransaction();
- writeTransaction.merge(YangInstanceIdentifier.builder().node(moduleNode.getNodeType()).build(), moduleNode);
+ writeTransaction.merge(YangInstanceIdentifier.of(moduleNode.getNodeType()), moduleNode);
DOMStoreThreePhaseCommitCohort ready = writeTransaction.ready();
DOMStoreReadTransaction readTransaction = store.newReadOnlyTransaction();
CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read = readTransaction
- .read(YangInstanceIdentifier.builder().build());
+ .read(YangInstanceIdentifier.EMPTY);
Optional<NormalizedNode<?, ?>> nodeOptional = read.checkedGet();
for (DataSchemaNode c : input.getChildNodes()) {
for (UnknownSchemaNode extension : c.getUnknownSchemaNodes()) {
if (CONTEXT_REFERENCE.equals(extension.getNodeType())) {
- final YangInstanceIdentifier keyId = YangInstanceIdentifier.builder().node(c.getQName()).build();
+ final YangInstanceIdentifier keyId = YangInstanceIdentifier.of(c.getQName());
return new RoutedDOMRpcRoutingTableEntry(rpcDef, keyId, implementations);
}
}
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
- private static final YangInstanceIdentifier ROOT = YangInstanceIdentifier.builder().build();
private final DOMRpcIdentifier rpcId;
private GlobalDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId, final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
@Override
protected CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final NormalizedNode<?, ?> input) {
- return getImplementations(ROOT).get(0).invokeRpc(rpcId, input);
+ return getImplementations(YangInstanceIdentifier.EMPTY).get(0).invokeRpc(rpcId, input);
}
@Override