From: Robert Varga Date: Tue, 29 Jan 2019 11:20:48 +0000 (+0100) Subject: Update RIB-based constants X-Git-Tag: release/neon~9 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=0dc7177745cd5f4e55479a09f8e4fdee901aefcd;p=bgpcep.git Update RIB-based constants There are QNames which we are using all over the place, make sure we concentrate them in a utility holder. Also ensure constants are suffixed, so we can import them concurrently. Change-Id: Ie6618aeea776e8278cd7762560636d46ac64bb88 Signed-off-by: Robert Varga --- diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AbstractPeer.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AbstractPeer.java index 4d0eb7b810..664eda9e45 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AbstractPeer.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AbstractPeer.java @@ -7,6 +7,8 @@ */ package org.opendaylight.protocol.bgp.rib.impl; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; + import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.MoreExecutors; @@ -140,8 +142,7 @@ abstract class AbstractPeer extends BGPPeerStateImpl implements BGPRouteEntryImp } synchronized YangInstanceIdentifier createPeerPath() { - return this.rib.getYangRibId().node(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib - .rev180329.bgp.rib.rib.Peer.QNAME).node(IdentifierUtils.domPeerId(this.peerId)); + return this.rib.getYangRibId().node(PEER_NID).node(IdentifierUtils.domPeerId(this.peerId)); } @Override diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibInWriter.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibInWriter.java index 5b90ff2696..6eee3e6a7d 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibInWriter.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibInWriter.java @@ -8,11 +8,12 @@ package org.opendaylight.protocol.bgp.rib.impl; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBOUT; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.EFFRIBIN; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBOUT_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.EFFRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_NID; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Optional; @@ -47,6 +48,8 @@ import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContext; import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry; import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils; import org.opendaylight.protocol.bgp.rib.spi.PeerRoleUtil; +import org.opendaylight.protocol.bgp.rib.spi.RIBNormalizedNodes; +import org.opendaylight.protocol.bgp.rib.spi.RIBQNames; import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.SendReceive; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.update.attributes.MpReachNlri; @@ -56,14 +59,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib. import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.SupportedTables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Attributes; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; -import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; @@ -84,27 +85,20 @@ final class AdjRibInWriter { private static final Logger LOG = LoggerFactory.getLogger(AdjRibInWriter.class); - @VisibleForTesting - static final LeafNode ATTRIBUTES_UPTODATE_FALSE = ImmutableNodes.leafNode(QName.create(Attributes.QNAME, - "uptodate"), Boolean.FALSE); - @VisibleForTesting - static final QName PEER_ID_QNAME = QName.create(Peer.QNAME, "peer-id").intern(); - private static final LeafNode ATTRIBUTES_UPTODATE_TRUE = - ImmutableNodes.leafNode(ATTRIBUTES_UPTODATE_FALSE.getNodeType(), Boolean.TRUE); private static final QName PEER_ROLE_QNAME = QName.create(Peer.QNAME, "peer-role").intern(); - private static final NodeIdentifier PEER_ID = NodeIdentifier.create(PEER_ID_QNAME); + private static final NodeIdentifier PEER_ID = NodeIdentifier.create(RIBQNames.PEER_ID_QNAME); private static final NodeIdentifier PEER_ROLE = NodeIdentifier.create(PEER_ROLE_QNAME); private static final NodeIdentifier PEER_TABLES = NodeIdentifier.create(SupportedTables.QNAME); private static final QName SEND_RECEIVE = QName.create(SupportedTables.QNAME, "send-receive").intern(); // FIXME: is there a utility method to construct this? - private static final MapNode EMPTY_TABLES = ImmutableNodes.mapNodeBuilder(TABLES).build(); + private static final MapNode EMPTY_TABLES = ImmutableNodes.mapNodeBuilder(TABLES_NID).build(); private static final ContainerNode EMPTY_ADJRIBIN = Builders.containerBuilder() - .withNodeIdentifier(ADJRIBIN).addChild(EMPTY_TABLES).build(); + .withNodeIdentifier(ADJRIBIN_NID).addChild(EMPTY_TABLES).build(); private static final ContainerNode EMPTY_EFFRIBIN = Builders.containerBuilder() - .withNodeIdentifier(EFFRIBIN).addChild(EMPTY_TABLES).build(); + .withNodeIdentifier(EFFRIBIN_NID).addChild(EMPTY_TABLES).build(); private static final ContainerNode EMPTY_ADJRIBOUT = Builders.containerBuilder() - .withNodeIdentifier(ADJRIBOUT).addChild(EMPTY_TABLES).build(); + .withNodeIdentifier(ADJRIBOUT_NID).addChild(EMPTY_TABLES).build(); private final Map tables; private final YangInstanceIdentifier ribPath; @@ -213,14 +207,14 @@ final class AdjRibInWriter { final DOMDataWriteTransaction tx, final Builder tb) { // We will use table keys very often, make sure they are optimized final InstanceIdentifierBuilder idb = YangInstanceIdentifier.builder(newPeerPath - .node(EMPTY_ADJRIBIN.getIdentifier()).node(TABLES)); + .node(EMPTY_ADJRIBIN.getIdentifier()).node(TABLES_NID)); idb.nodeWithKey(instanceIdentifierKey.getNodeType(), instanceIdentifierKey.getKeyValues()); final TableContext ctx = new TableContext(rs, idb.build()); ctx.createEmptyTableStructure(tx); - tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(ATTRIBUTES) - .node(ATTRIBUTES_UPTODATE_FALSE.getNodeType()), ATTRIBUTES_UPTODATE_FALSE); + tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(ATTRIBUTES_NID).node(UPTODATE_NID), + RIBNormalizedNodes.ATTRIBUTES_UPTODATE_FALSE); LOG.debug("Created table instance {}", ctx.getTableId()); tb.put(tableKey, ctx); } @@ -239,7 +233,7 @@ final class AdjRibInWriter { } tx.put(LogicalDatastoreType.OPERATIONAL, newPeerPath.node(PEER_TABLES).node(supTablesKey), tt.build()); rs.createEmptyTableStructure(tx, newPeerPath.node(EMPTY_ADJRIBOUT.getIdentifier()) - .node(TABLES).node(instanceIdentifierKey)); + .node(TABLES_NID).node(instanceIdentifierKey)); } private void createEmptyPeerStructure(final PeerId newPeerId, @@ -266,8 +260,8 @@ final class AdjRibInWriter { void markTableUptodate(final TablesKey tableTypes) { final DOMDataWriteTransaction tx = this.chain.getDomChain().newWriteOnlyTransaction(); final TableContext ctx = this.tables.get(tableTypes); - tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(ATTRIBUTES) - .node(ATTRIBUTES_UPTODATE_TRUE.getNodeType()), ATTRIBUTES_UPTODATE_TRUE); + tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(ATTRIBUTES_NID).node(UPTODATE_NID), + RIBNormalizedNodes.ATTRIBUTES_UPTODATE_TRUE); tx.commit().addCallback(new FutureCallback() { @Override public void onSuccess(final CommitInfo result) { diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibOutListener.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibOutListener.java index b67e4d1847..88c44770a5 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibOutListener.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibOutListener.java @@ -8,8 +8,9 @@ package org.opendaylight.protocol.bgp.rib.impl; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBOUT; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBOUT_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import java.util.Collection; import java.util.Collections; @@ -40,7 +41,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mess import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.update.message.WithdrawnRoutes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.update.message.WithdrawnRoutesBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.common.QName; @@ -88,8 +88,8 @@ final class AdjRibOutListener implements ClusteredDOMDataTreeChangeListener, Pre this.codecs = registry.getCodecs(this.support); this.mpSupport = mpSupport; this.tablesKey = requireNonNull(tablesKey); - final YangInstanceIdentifier adjRibOutId = ribId.node(Peer.QNAME).node(IdentifierUtils.domPeerId(peerId)) - .node(ADJRIBOUT).node(TABLES).node(RibSupportUtils.toYangTablesKey(tablesKey)); + final YangInstanceIdentifier adjRibOutId = ribId.node(PEER_NID).node(IdentifierUtils.domPeerId(peerId)) + .node(ADJRIBOUT_NID).node(TABLES_NID).node(RibSupportUtils.toYangTablesKey(tablesKey)); /* * After listener registration should always be executed ODTC. Even when empty table is present * in data store. Within this first ODTC execution we should advertise present routes and than diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/ApplicationPeer.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/ApplicationPeer.java index ccc646aab4..a2d9c39b6a 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/ApplicationPeer.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/ApplicationPeer.java @@ -8,9 +8,10 @@ package org.opendaylight.protocol.bgp.rib.impl; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import com.google.common.base.Verify; import com.google.common.cache.CacheBuilder; @@ -130,9 +131,9 @@ public class ApplicationPeer extends AbstractPeer implements ClusteredDOMDataTre this.tableTypeRegistry = requireNonNull(tableTypeRegistry); final RIB targetRib = requireNonNull(rib); this.rawIdentifier = InetAddresses.forString(ipAddress.getValue()).getAddress(); - this.adjRibsInId = targetRib.getYangRibId().node(Peer.QNAME) + this.adjRibsInId = targetRib.getYangRibId().node(PEER_NID) .node(IdentifierUtils.domPeerId(RouterIds.createPeerId(ipAddress))) - .node(ADJRIBIN).node(TABLES); + .node(ADJRIBIN_NID).node(TABLES_NID); this.peerId = RouterIds.createPeerId(ipAddress); this.peerIId = getInstanceIdentifier().child(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns .yang.bgp.rib.rev180329.bgp.rib.rib.Peer.class, new PeerKey(this.peerId)); @@ -204,7 +205,7 @@ public class ApplicationPeer extends AbstractPeer implements ClusteredDOMDataTre // No-op break; case SUBTREE_MODIFIED: - if (ROUTES.equals(childIdentifier)) { + if (ROUTES_NID.equals(childIdentifier)) { processRoutesTable(child, tableId, tx, tableId); break; } diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/EffectiveRibInWriter.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/EffectiveRibInWriter.java index 460e2c9aa8..0c78b7784f 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/EffectiveRibInWriter.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/EffectiveRibInWriter.java @@ -9,11 +9,11 @@ package org.opendaylight.protocol.bgp.rib.impl; import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.EFFRIBIN; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.EFFRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -109,7 +109,7 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn .xml.ns.yang.bgp.message.rev180329.path.attributes.AttributesBuilder() .setCommunities(STALE_LLGR_COMMUNUTIES) .build(); - private static final ChoiceNode EMPTY_ROUTES = Builders.choiceBuilder().withNodeIdentifier(ROUTES).build(); + private static final ChoiceNode EMPTY_ROUTES = Builders.choiceBuilder().withNodeIdentifier(ROUTES_NID).build(); private final RIBSupportContextRegistry registry; private final YangInstanceIdentifier peerIId; @@ -141,7 +141,7 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn this.registry = requireNonNull(rib.getRibSupportContext()); this.chain = requireNonNull(chain); this.peerIId = requireNonNull(peerIId); - this.effRibTables = this.peerIId.node(EFFRIBIN); + this.effRibTables = this.peerIId.node(EFFRIBIN_NID); this.prefixesInstalled = buildPrefixesTables(tables); this.prefixesReceived = buildPrefixesTables(tables); this.ribPolicies = requireNonNull(rib.getRibPolicies()); @@ -155,7 +155,7 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn public void init() { final DOMDataTreeIdentifier treeId = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, - this.peerIId.node(ADJRIBIN).node(TABLES)); + this.peerIId.node(ADJRIBIN_NID).node(TABLES_NID)); LOG.debug("Registered Effective RIB on {}", this.peerIId); this.reg = requireNonNull(this.service).registerDataTreeChangeListener(treeId, this); } @@ -312,10 +312,10 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn final YangInstanceIdentifier effectiveTablePath, final DataTreeCandidateNode table) { LOG.debug("Modify Effective Table {}", effectiveTablePath); - final DataTreeCandidateNode modifiedAttrs = table.getModifiedChild(ATTRIBUTES); + final DataTreeCandidateNode modifiedAttrs = table.getModifiedChild(ATTRIBUTES_NID); if (modifiedAttrs != null) { final Optional> attrsAfter = modifiedAttrs.getDataAfter(); - final YangInstanceIdentifier effAttrsPath = effectiveTablePath.node(ATTRIBUTES); + final YangInstanceIdentifier effAttrsPath = effectiveTablePath.node(ATTRIBUTES_NID); if (attrsAfter.isPresent()) { tx.put(LogicalDatastoreType.OPERATIONAL, effAttrsPath, attrsAfter.get()); } else { @@ -323,7 +323,7 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn } } - final DataTreeCandidateNode modifiedRoutes = table.getModifiedChild(ROUTES); + final DataTreeCandidateNode modifiedRoutes = table.getModifiedChild(ROUTES_NID); if (modifiedRoutes != null) { final RIBSupport ribSupport = ribContext.getRibSupport(); switch (modifiedRoutes.getModificationType()) { @@ -331,13 +331,13 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn case WRITE: deleteRoutesBefore(tx, ribSupport, effectiveTablePath, modifiedRoutes); // XXX: YANG Tools seems to have an issue stacking DELETE with child WRITE - tx.put(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ROUTES), EMPTY_ROUTES); + tx.put(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ROUTES_NID), EMPTY_ROUTES); writeRoutesAfter(tx, ribSupport, effectiveTablePath, modifiedRoutes.getDataAfter()); break; case DELETE: case DISAPPEARED: deleteRoutesBefore(tx, ribSupport, effectiveTablePath, modifiedRoutes); - tx.delete(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ROUTES)); + tx.delete(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ROUTES_NID)); break; case SUBTREE_MODIFIED: for (DataTreeCandidateNode modifiedRoute : ribSupport.changedRoutes(modifiedRoutes)) { @@ -364,14 +364,14 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn final MapEntryNode tableAfter = extractMapEntry(maybeTableAfter); ribContext.createEmptyTableStructure(tx, effectiveTablePath); - final Optional> maybeAttrsAfter = tableAfter.getChild(ATTRIBUTES); + final Optional> maybeAttrsAfter = tableAfter.getChild(ATTRIBUTES_NID); if (maybeAttrsAfter.isPresent()) { final ContainerNode attrsAfter = extractContainer(maybeAttrsAfter); - tx.put(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ATTRIBUTES), attrsAfter); + tx.put(LogicalDatastoreType.OPERATIONAL, effectiveTablePath.node(ATTRIBUTES_NID), attrsAfter); } writeRoutesAfter(tx, ribContext.getRibSupport(), effectiveTablePath, - NormalizedNodes.findNode(tableAfter, ROUTES)); + NormalizedNodes.findNode(tableAfter, ROUTES_NID)); } } @@ -380,7 +380,7 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn final Optional> tableBefore) { // Routes are special in that we need to process the to keep our counters accurate final Optional> maybeRoutesBefore = findRoutesMap(ribSupport, - NormalizedNodes.findNode(tableBefore, ROUTES)); + NormalizedNodes.findNode(tableBefore, ROUTES_NID)); if (maybeRoutesBefore.isPresent()) { onRoutesDeleted(ribSupport, effectiveTablePath, extractMap(maybeRoutesBefore).getValue()); } @@ -561,12 +561,12 @@ final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesIn } private YangInstanceIdentifier effectiveTablePath(final NodeIdentifierWithPredicates tableKey) { - return this.effRibTables.node(TABLES).node(tableKey); + return this.effRibTables.node(TABLES_NID).node(tableKey); } private static YangInstanceIdentifier routeMapPath(final RIBSupport ribSupport, final YangInstanceIdentifier tablePath) { - return concat(tablePath.node(ROUTES), ribSupport.relativeRoutesPath()); + return concat(tablePath.node(ROUTES_NID), ribSupport.relativeRoutesPath()); } private static Optional> findRoutesMap(final RIBSupport ribSupport, diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/RIBImpl.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/RIBImpl.java index 2fb185b919..c6a8d2606d 100755 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/RIBImpl.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/RIBImpl.java @@ -8,10 +8,11 @@ package org.opendaylight.protocol.bgp.rib.impl; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import com.google.common.base.MoreObjects; import com.google.common.collect.ImmutableSet; @@ -61,7 +62,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib. import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.RibKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes; @@ -146,7 +146,7 @@ public final class RIBImpl extends BGPRIBStateImpl implements RIB, TransactionCh this.ribPolicies = requireNonNull(ribPolicies); this.codecsRegistry = codecsRegistry; this.ribContextRegistry = RIBSupportContextRegistryImpl.create(extensions, this.codecsRegistry); - final InstanceIdentifierBuilder yangRibIdBuilder = YangInstanceIdentifier.builder().node(BGPRIB).node(RIB); + final InstanceIdentifierBuilder yangRibIdBuilder = YangInstanceIdentifier.builder().node(BGPRIB_NID).node(RIB_NID); this.yangRibId = yangRibIdBuilder.nodeWithKey(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()).build(); this.bestPathSelectionStrategies = requireNonNull(bestPathSelectionStrategies); this.ribId = ribId; @@ -166,7 +166,7 @@ public final class RIBImpl extends BGPRIBStateImpl implements RIB, TransactionCh if (ribSupport != null) { final MapEntryNode emptyTable = ribSupport.emptyTable(); final InstanceIdentifierBuilder tableId = YangInstanceIdentifier - .builder(this.yangRibId.node(LOCRIB).node(TABLES)).node(emptyTable.getIdentifier()); + .builder(this.yangRibId.node(LOCRIB_NID).node(TABLES_NID)).node(emptyTable.getIdentifier()); tx.put(LogicalDatastoreType.OPERATIONAL, tableId.build(), emptyTable); try { @@ -341,21 +341,21 @@ public final class RIBImpl extends BGPRIBStateImpl implements RIB, TransactionCh this.domChain = this.domDataBroker.createTransactionChain(this); LOG.debug("Instantiating RIB table {} at {}", this.ribId, this.yangRibId); - final ContainerNode bgpRib = Builders.containerBuilder().withNodeIdentifier(BGPRIB) - .addChild(ImmutableNodes.mapNodeBuilder(RIB).build()).build(); + final ContainerNode bgpRib = Builders.containerBuilder().withNodeIdentifier(BGPRIB_NID) + .addChild(ImmutableNodes.mapNodeBuilder(RIB_NID).build()).build(); final MapEntryNode ribInstance = Builders.mapEntryBuilder().withNodeIdentifier( new NodeIdentifierWithPredicates(Rib.QNAME, RIB_ID_QNAME, this.ribId.getValue())) .addChild(ImmutableNodes.leafNode(RIB_ID_QNAME, this.ribId.getValue())) - .addChild(ImmutableNodes.mapNodeBuilder(Peer.QNAME).build()) - .addChild(Builders.containerBuilder().withNodeIdentifier(LOCRIB) - .addChild(ImmutableNodes.mapNodeBuilder(TABLES).build()) + .addChild(ImmutableNodes.mapNodeBuilder(PEER_NID).build()) + .addChild(Builders.containerBuilder().withNodeIdentifier(LOCRIB_NID) + .addChild(ImmutableNodes.mapNodeBuilder(TABLES_NID).build()) .build()).build(); final DOMDataWriteTransaction trans = this.domChain.newWriteOnlyTransaction(); // merge empty BgpRib + Rib, to make sure the top-level parent structure is present - trans.merge(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(BGPRIB), bgpRib); + trans.merge(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(BGPRIB_NID), bgpRib); trans.put(LogicalDatastoreType.OPERATIONAL, this.yangRibId, ribInstance); try { diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/AppPeer.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/AppPeer.java index 64f7f9d859..1245f90d13 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/AppPeer.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/config/AppPeer.java @@ -6,7 +6,7 @@ * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.protocol.bgp.rib.impl.config; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import com.google.common.base.Preconditions; import com.google.common.base.Strings; @@ -132,7 +132,7 @@ public final class AppPeer implements PeerBean, BGPPeerStateConsumer { this.isServiceInstantiated = true; final YangInstanceIdentifier yangIId = YangInstanceIdentifier.builder().node(APPRIB) .nodeWithKey(ApplicationRib.QNAME, APP_ID_QNAME, this.appRibId.getValue()) - .node(TABLES).node(TABLES).build(); + .node(TABLES_NID).node(TABLES_NID).build(); this.applicationPeer.instantiateServiceInstance(this.dataTreeChangeService, new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, yangIId)); } diff --git a/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibsInWriterTest.java b/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibsInWriterTest.java index a92eee84e8..76208da89a 100644 --- a/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibsInWriterTest.java +++ b/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/AdjRibsInWriterTest.java @@ -8,12 +8,17 @@ package org.opendaylight.protocol.bgp.rib.impl; import static org.junit.Assert.assertNotNull; -import static org.mockito.Matchers.any; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_NID; import com.google.common.collect.Sets; import com.google.common.util.concurrent.FluentFuture; @@ -32,17 +37,16 @@ import org.opendaylight.protocol.bgp.rib.impl.spi.PeerTransactionChain; import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContext; import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry; import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils; +import org.opendaylight.protocol.bgp.rib.spi.RIBNormalizedNodes; +import org.opendaylight.protocol.bgp.rib.spi.RIBQNames; import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.SendReceive; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerRole; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Rib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.AdjRibIn; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.SupportedTables; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Attributes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.Ipv4AddressFamily; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.UnicastSubsequentAddressFamily; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -88,9 +92,9 @@ public class AdjRibsInWriterTest { public void testTransform() { this.writer = AdjRibInWriter.create(YangInstanceIdentifier.of(Rib.QNAME), PeerRole.Ebgp, this.ptc); assertNotNull(this.writer); - final YangInstanceIdentifier peerPath = YangInstanceIdentifier.builder().node(Rib.QNAME) + final YangInstanceIdentifier peerPath = YangInstanceIdentifier.builder().node(RIB_NID) .node(Peer.QNAME).nodeWithKey(Peer.QNAME, - AdjRibInWriter.PEER_ID_QNAME, this.peerIp).build(); + RIBQNames.PEER_ID_QNAME, this.peerIp).build(); this.writer.transform(new PeerId(this.peerIp), peerPath, this.registry, this.tableTypes, ADD_PATH_TABLE_MAPS); verifyPeerSkeletonInsertedCorrectly(peerPath); // verify supported tables were inserted for ipv4 @@ -100,11 +104,11 @@ public class AdjRibsInWriterTest { } private void verifyUptodateSetToFalse(final YangInstanceIdentifier peerPath) { - final YangInstanceIdentifier path = peerPath.node(AdjRibIn.QNAME) - .node(Tables.QNAME).node(RibSupportUtils.toYangTablesKey(K4)) - .node(Attributes.QNAME).node(AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE.getNodeType()); + final YangInstanceIdentifier path = peerPath.node(ADJRIBIN_NID) + .node(TABLES_NID).node(RibSupportUtils.toYangTablesKey(K4)) + .node(ATTRIBUTES_NID).node(UPTODATE_NID); verify(this.tx).merge(eq(LogicalDatastoreType.OPERATIONAL), eq(path), - eq(AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE)); + eq(RIBNormalizedNodes.ATTRIBUTES_UPTODATE_FALSE)); } private void verifyPeerSkeletonInsertedCorrectly(final YangInstanceIdentifier peerPath) { diff --git a/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/SynchronizationAndExceptionTest.java b/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/SynchronizationAndExceptionTest.java index f4682dc3a1..ad69e1e60d 100644 --- a/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/SynchronizationAndExceptionTest.java +++ b/bgp/rib-impl/src/test/java/org/opendaylight/protocol/bgp/rib/impl/SynchronizationAndExceptionTest.java @@ -5,7 +5,6 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.protocol.bgp.rib.impl; import static org.mockito.ArgumentMatchers.any; @@ -16,7 +15,13 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.internal.verification.VerificationModeFactory.times; -import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ATTRIBUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_NID; import com.google.common.base.Optional; import com.google.common.collect.ImmutableList; @@ -51,6 +56,7 @@ import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode; import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory; import org.opendaylight.protocol.bgp.parser.BgpExtendedMessageUtil; import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl; +import org.opendaylight.protocol.bgp.rib.spi.RIBQNames; import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; @@ -80,15 +86,11 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mult import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.CParameters1Builder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.GracefulRestartCapabilityBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.mp.capabilities.MultiprotocolCapabilityBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerRole; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.RibId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.AdjRibIn; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Attributes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.BgpId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.BgpOrigin; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.Ipv4AddressFamily; @@ -110,13 +112,13 @@ public class SynchronizationAndExceptionTest extends AbstractAddPathTest { private static final int LOCAL_PORT = 12345; private static final String RIB_ID = "1.1.1.2"; private static final YangInstanceIdentifier PEER_PATH = YangInstanceIdentifier.builder() - .node(BgpRib.QNAME).node(Rib.QNAME) + .node(BGPRIB_NID).node(RIB_NID) .nodeWithKey(Rib.QNAME, QName.create(Rib.QNAME, "id").intern(), RIB_ID) - .node(Peer.QNAME).nodeWithKey(Peer.QNAME, AdjRibInWriter.PEER_ID_QNAME, "bgp://1.1.1.2").build(); - private static final YangInstanceIdentifier TABLE_PATH = PEER_PATH.node(AdjRibIn.QNAME).node(Tables.QNAME) + .node(PEER_NID).nodeWithKey(Peer.QNAME, RIBQNames.PEER_ID_QNAME, "bgp://1.1.1.2").build(); + private static final YangInstanceIdentifier TABLE_PATH = PEER_PATH.node(ADJRIBIN_NID).node(TABLES_NID) .node(RibSupportUtils.toYangTablesKey(new TablesKey(Ipv4AddressFamily.class, - UnicastSubsequentAddressFamily.class))).node(Attributes.QNAME) - .node(QName.create(Attributes.QNAME, "uptodate")); + UnicastSubsequentAddressFamily.class))).node(ATTRIBUTES_NID) + .node(UPTODATE_NID); private final IpAddress neighbor = new IpAddress(new Ipv4Address(LOCAL_IP)); private final BgpTableType ipv4tt = new BgpTableTypeImpl(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class); @@ -255,7 +257,7 @@ public class SynchronizationAndExceptionTest extends AbstractAddPathTest { any(YangInstanceIdentifier.class), any(NormalizedNode.class)); verify(this.tx).delete(eq(LogicalDatastoreType.OPERATIONAL), eq(PEER_PATH)); verify(this.tx, times(0)).merge(eq(LogicalDatastoreType.OPERATIONAL), eq(TABLE_PATH), - eq(ImmutableNodes.leafNode(ATTRIBUTES_UPTODATE_FALSE.getNodeType(), Boolean.TRUE))); + eq(ImmutableNodes.leafNode(UPTODATE_NID, Boolean.TRUE))); } @Test @@ -301,7 +303,7 @@ public class SynchronizationAndExceptionTest extends AbstractAddPathTest { any(YangInstanceIdentifier.class), any(NormalizedNode.class)); verify(this.tx).merge(eq(LogicalDatastoreType.OPERATIONAL), eq(TABLE_PATH), - eq(ImmutableNodes.leafNode(ATTRIBUTES_UPTODATE_FALSE.getNodeType(), Boolean.TRUE))); + eq(ImmutableNodes.leafNode(UPTODATE_NID, Boolean.TRUE))); verify(this.tx, times(0)).delete(eq(LogicalDatastoreType.OPERATIONAL), eq(PEER_PATH)); } } diff --git a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/AbstractRIBSupport.java b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/AbstractRIBSupport.java index 7217bf62bf..a4f98215e0 100644 --- a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/AbstractRIBSupport.java +++ b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/AbstractRIBSupport.java @@ -9,11 +9,11 @@ package org.opendaylight.protocol.bgp.rib.spi; import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES; -import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID; import com.google.common.annotations.Beta; import com.google.common.cache.CacheBuilder; @@ -178,13 +178,13 @@ public abstract class AbstractRIBSupport< this.rdNid = NodeIdentifier.create(QName.create(destContainerQname, "route-distinguisher").intern()); this.routeDefaultYii = YangInstanceIdentifier.builder() - .node(BGPRIB) - .node(RIB) - .node(RIB) - .node(LOCRIB) - .node(TABLES) - .node(TABLES) - .node(ROUTES) + .node(BGPRIB_NID) + .node(RIB_NID) + .node(RIB_NID) + .node(LOCRIB_NID) + .node(TABLES_NID) + .node(TABLES_NID) + .node(ROUTES_NID) .node(this.routesContainerIdentifier) .node(this.routesListIdentifier) .node(this.routesListIdentifier).build(); @@ -390,7 +390,7 @@ public abstract class AbstractRIBSupport< @Override public final YangInstanceIdentifier routesPath(final YangInstanceIdentifier routesTablePaths) { - return routesYangInstanceIdentifier(routesTablePaths.node(ROUTES)); + return routesYangInstanceIdentifier(routesTablePaths.node(ROUTES_NID)); } @Override @@ -408,7 +408,7 @@ public abstract class AbstractRIBSupport< @Override public final void deleteRoutes(final DOMDataWriteTransaction tx, final YangInstanceIdentifier tablePath, final ContainerNode nlri) { - deleteRoutes(tx, tablePath, nlri, ROUTES); + deleteRoutes(tx, tablePath, nlri, ROUTES_NID); } @Override @@ -416,7 +416,7 @@ public abstract class AbstractRIBSupport< final YangInstanceIdentifier tablePath, final ContainerNode nlri, final ContainerNode attributes) { - return putRoutes(tx, tablePath, nlri, attributes, ROUTES); + return putRoutes(tx, tablePath, nlri, attributes, ROUTES_NID); } @Override diff --git a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNodeIdentifiers.java b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNodeIdentifiers.java index feac49cfe5..1ee16c312e 100644 --- a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNodeIdentifiers.java +++ b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNodeIdentifiers.java @@ -11,6 +11,7 @@ import com.google.common.annotations.Beta; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.LocRib; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.AdjRibIn; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.AdjRibOut; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.peer.EffectiveRibIn; @@ -24,15 +25,19 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent */ @Beta public final class RIBNodeIdentifiers { - public static final NodeIdentifier BGPRIB = NodeIdentifier.create(BgpRib.QNAME); - public static final NodeIdentifier RIB = NodeIdentifier.create(Rib.QNAME); - public static final NodeIdentifier ADJRIBIN = NodeIdentifier.create(AdjRibIn.QNAME); - public static final NodeIdentifier ADJRIBOUT = NodeIdentifier.create(AdjRibOut.QNAME); - public static final NodeIdentifier EFFRIBIN = NodeIdentifier.create(EffectiveRibIn.QNAME); - public static final NodeIdentifier LOCRIB = NodeIdentifier.create(LocRib.QNAME); - public static final NodeIdentifier TABLES = NodeIdentifier.create(Tables.QNAME); - public static final NodeIdentifier ROUTES = NodeIdentifier.create(Routes.QNAME); - public static final NodeIdentifier ATTRIBUTES = NodeIdentifier.create(Attributes.QNAME); + public static final NodeIdentifier BGPRIB_NID = NodeIdentifier.create(BgpRib.QNAME); + public static final NodeIdentifier RIB_NID = NodeIdentifier.create(Rib.QNAME); + public static final NodeIdentifier PEER_NID = NodeIdentifier.create(Peer.QNAME); + + public static final NodeIdentifier ADJRIBIN_NID = NodeIdentifier.create(AdjRibIn.QNAME); + public static final NodeIdentifier ADJRIBOUT_NID = NodeIdentifier.create(AdjRibOut.QNAME); + public static final NodeIdentifier EFFRIBIN_NID = NodeIdentifier.create(EffectiveRibIn.QNAME); + public static final NodeIdentifier LOCRIB_NID = NodeIdentifier.create(LocRib.QNAME); + public static final NodeIdentifier TABLES_NID = NodeIdentifier.create(Tables.QNAME); + public static final NodeIdentifier ROUTES_NID = NodeIdentifier.create(Routes.QNAME); + public static final NodeIdentifier ATTRIBUTES_NID = NodeIdentifier.create(Attributes.QNAME); + + public static final NodeIdentifier UPTODATE_NID = NodeIdentifier.create(RIBQNames.UPTODATE_QNAME); private RIBNodeIdentifiers() { diff --git a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java new file mode 100644 index 0000000000..a10a327892 --- /dev/null +++ b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.protocol.bgp.rib.spi; + +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_NID; + +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; + +/** + * Utility constant {@link NormalizedNode}s. + */ +public final class RIBNormalizedNodes { + public static final LeafNode ATTRIBUTES_UPTODATE_FALSE = ImmutableNodes.leafNode( + UPTODATE_NID, Boolean.FALSE); + public static final LeafNode ATTRIBUTES_UPTODATE_TRUE = ImmutableNodes.leafNode( + UPTODATE_NID, Boolean.TRUE); + + private RIBNormalizedNodes() { + + } +} diff --git a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBQNames.java b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBQNames.java new file mode 100644 index 0000000000..fb4a236902 --- /dev/null +++ b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBQNames.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.protocol.bgp.rib.spi; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Attributes; +import org.opendaylight.yangtools.yang.common.QName; + +/** + * Utility constant {@link QName}s for various RIB constructs which are not covered by generated DTOs' QNAME constants. + */ +public final class RIBQNames { + public static final QName UPTODATE_QNAME = QName.create(Attributes.QNAME, "uptodate").intern(); + public static final QName PEER_ID_QNAME = QName.create(Peer.QNAME, "peer-id").intern(); + + private RIBQNames() { + + } +} diff --git a/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/IdentifierUtilsTest.java b/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/IdentifierUtilsTest.java index 60567fd29b..49e4052783 100644 --- a/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/IdentifierUtilsTest.java +++ b/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/IdentifierUtilsTest.java @@ -8,12 +8,14 @@ package org.opendaylight.protocol.bgp.rib.spi; import static org.junit.Assert.assertEquals; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID; +import static org.opendaylight.protocol.bgp.rib.spi.RIBQNames.PEER_ID_QNAME; import com.google.common.collect.ImmutableMap; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.LocRib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey; @@ -24,7 +26,6 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; public class IdentifierUtilsTest { - private static final QName PEER_ID_QNAME = QName.create(Peer.QNAME, "peer-id").intern(); private static final QName TABLES_KEY_QNAME = QName.create(Tables.QNAME, "tables-key").intern(); private static final TablesKey TK = new TablesKey(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class); private static final PeerId PEER_ID = new PeerId("127.0.0.1"); @@ -36,9 +37,9 @@ public class IdentifierUtilsTest { private static final YangInstanceIdentifier YII_TABLE; static { - YII_PEER = YangInstanceIdentifier.builder().node(BgpRib.QNAME).node(Peer.QNAME) + YII_PEER = YangInstanceIdentifier.builder().node(BGPRIB_NID).node(PEER_NID) .nodeWithKey(Peer.QNAME, PEER_ID_QNAME, PEER_ID.getValue()).build(); - YII_TABLE = YangInstanceIdentifier.builder().node(LocRib.QNAME).node(Tables.QNAME) + YII_TABLE = YangInstanceIdentifier.builder().node(LOCRIB_NID).node(Tables.QNAME) .nodeWithKey(Tables.QNAME, TABLES_KEY_QNAME, TK).build(); }