X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=bgp%2Frib-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fprotocol%2Fbgp%2Frib%2Fimpl%2FLocRibWriter.java;h=0519a9a930d436bbc46a8ecfd1ae33765c744658;hb=1e5834827493f0cd8b201c754e700f1347b75249;hp=3b0ed261e57790e91a3ff66e994585c160011440;hpb=3e400cfa9611d6b338b4aeef15e6f4c374fc8742;p=bgpcep.git diff --git a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/LocRibWriter.java b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/LocRibWriter.java index 3b0ed261e5..0519a9a930 100644 --- a/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/LocRibWriter.java +++ b/bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/LocRibWriter.java @@ -7,13 +7,15 @@ */ package org.opendaylight.protocol.bgp.rib.impl; +import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.SIMPLE_ROUTING_POLICY_NID; +import static org.opendaylight.protocol.bgp.rib.spi.PeerRoleUtil.PEER_ROLE_NID; + +import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.primitives.UnsignedInteger; -import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.Map; -import java.util.Map.Entry; import javax.annotation.Nonnull; import javax.annotation.concurrent.NotThreadSafe; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; @@ -22,28 +24,42 @@ import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService; import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier; import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; +import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode; +import org.opendaylight.protocol.bgp.mode.api.RouteEntry; +import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry; +import org.opendaylight.protocol.bgp.rib.spi.CacheDisconnectedPeers; +import org.opendaylight.protocol.bgp.rib.spi.ExportPolicyPeerTracker; +import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils; +import org.opendaylight.protocol.bgp.rib.spi.PeerExportGroup; +import org.opendaylight.protocol.bgp.rib.spi.PeerRoleUtil; import org.opendaylight.protocol.bgp.rib.spi.RIBSupport; import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils; +import org.opendaylight.protocol.bgp.rib.spi.RouterIds; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerRole; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.SimpleRoutingPolicy; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.LocRib; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.Peer; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.peer.EffectiveRibIn; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.peer.SupportedTables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.tables.Attributes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.tables.Routes; -import org.opendaylight.yangtools.yang.binding.util.BindingReflections; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.BindingMapping; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; 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.YangInstanceIdentifier.PathArgument; -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.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -52,153 +68,222 @@ final class LocRibWriter implements AutoCloseable, DOMDataTreeChangeListener { private static final Logger LOG = LoggerFactory.getLogger(LocRibWriter.class); + private static final LeafNode ATTRIBUTES_UPTODATE_TRUE = ImmutableNodes.leafNode(QName.create(Attributes.QNAME, "uptodate"), Boolean.TRUE); + private static final NodeIdentifier EFFRIBIN_NID = new NodeIdentifier(EffectiveRibIn.QNAME); + private static final NodeIdentifier TABLES_NID = new NodeIdentifier(Tables.QNAME); + private static final NodeIdentifier PEER_TABLES = new NodeIdentifier(SupportedTables.QNAME); + private final Map routeEntries = new HashMap<>(); - private final YangInstanceIdentifier target; + private final YangInstanceIdentifier locRibTarget; private final DOMTransactionChain chain; private final ExportPolicyPeerTracker peerPolicyTracker; private final NodeIdentifier attributesIdentifier; private final Long ourAs; private final RIBSupport ribSupport; + private final NodeIdentifierWithPredicates tableKey; + private final TablesKey localTablesKey; + private final ListenerRegistration reg; + private final CacheDisconnectedPeers cacheDisconnectedPeers; + private final PathSelectionMode pathSelectionMode; - LocRibWriter(final RIBSupport ribSupport, final DOMTransactionChain chain, final YangInstanceIdentifier target, final Long ourAs, - final DOMDataTreeChangeService service, final PolicyDatabase pd) { + private LocRibWriter(final RIBSupportContextRegistry registry, final DOMTransactionChain chain, final YangInstanceIdentifier target, final Long ourAs, + final DOMDataTreeChangeService service, final PolicyDatabase pd, final TablesKey tablesKey, final CacheDisconnectedPeers cacheDisconnectedPeers, + @Nonnull final PathSelectionMode pathSelectionMode) { this.chain = Preconditions.checkNotNull(chain); - this.target = Preconditions.checkNotNull(target); + this.tableKey = RibSupportUtils.toYangTablesKey(tablesKey); + this.localTablesKey = tablesKey; + this.locRibTarget = YangInstanceIdentifier.create(target.node(LocRib.QNAME).node(Tables.QNAME).node(this.tableKey).getPathArguments()); this.ourAs = Preconditions.checkNotNull(ourAs); - this.attributesIdentifier = ribSupport.routeAttributesIdentifier(); - this.peerPolicyTracker = new ExportPolicyPeerTracker(service, target, pd); - this.ribSupport = ribSupport; - - service.registerDataTreeChangeListener(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, target), this); - } + this.ribSupport = registry.getRIBSupportContext(tablesKey).getRibSupport(); + this.attributesIdentifier = this.ribSupport.routeAttributesIdentifier(); + this.peerPolicyTracker = new ExportPolicyPeerTrackerImpl(pd, this.localTablesKey); + this.cacheDisconnectedPeers = cacheDisconnectedPeers; + this.pathSelectionMode = pathSelectionMode; - public static LocRibWriter create(@Nonnull final RIBSupport ribSupport, @Nonnull final TablesKey tablesKey, @Nonnull final DOMTransactionChain chain, @Nonnull final YangInstanceIdentifier target, - @Nonnull final AsNumber ourAs, @Nonnull final DOMDataTreeChangeService service, @Nonnull final PolicyDatabase pd) { + final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction(); + tx.merge(LogicalDatastoreType.OPERATIONAL, this.locRibTarget.node(Routes.QNAME), this.ribSupport.emptyRoutes()); + tx.merge(LogicalDatastoreType.OPERATIONAL, this.locRibTarget.node(Attributes.QNAME).node(ATTRIBUTES_UPTODATE_TRUE.getNodeType()), ATTRIBUTES_UPTODATE_TRUE); + tx.submit(); - final YangInstanceIdentifier tableId = target.node(Peer.QNAME).node(Peer.QNAME).node(EffectiveRibIn.QNAME).node(Tables.QNAME).node(RibSupportUtils.toYangTablesKey(tablesKey)); + final YangInstanceIdentifier tableId = target.node(Peer.QNAME).node(Peer.QNAME); - final QName list = BindingReflections.findQName(ribSupport.routesListClass()); - final YangInstanceIdentifier routeId = tableId.node(Routes.QNAME).node(BindingReflections.findQName(ribSupport.routesContainerClass())).node(list); + this.reg = service.registerDataTreeChangeListener(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, tableId), this); + } - return new LocRibWriter(ribSupport, chain, routeId, ourAs.getValue(), service, pd); + public static LocRibWriter create(@Nonnull final RIBSupportContextRegistry registry, @Nonnull final TablesKey tablesKey, @Nonnull final DOMTransactionChain chain, + @Nonnull final YangInstanceIdentifier target, @Nonnull final AsNumber ourAs, @Nonnull final DOMDataTreeChangeService service, @Nonnull final PolicyDatabase pd, + final CacheDisconnectedPeers cacheDisconnectedPeers, @Nonnull final PathSelectionMode pathSelectionStrategy) { + return new LocRibWriter(registry, chain, target, ourAs.getValue(), service, pd, tablesKey, cacheDisconnectedPeers, pathSelectionStrategy); } @Override public void close() { - this.peerPolicyTracker.close(); + this.reg.close(); + // FIXME: wait for the chain to close? unfortunately RIBImpl is the listener, so that may require some work + this.chain.close(); + } + + @Nonnull + private RouteEntry createEntry(final PathArgument routeId) { + final RouteEntry ret = this.pathSelectionMode.createRouteEntry(ribSupport.isComplexRoute()); + this.routeEntries.put(routeId, ret); + LOG.trace("Created new entry for {}", routeId); + return ret; + } + + @Override + public void onDataTreeChanged(final Collection changes) { + LOG.trace("Received data change {} to LocRib {}", changes, this); + + final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction(); + try { + /* + * We use two-stage processing here in hopes that we avoid duplicate + * calculations when multiple peers have changed a particular entry. + */ + final Map toUpdate = update(tx, changes); + + // Now walk all updated entries + walkThrough(tx, toUpdate); + } catch (final Exception e) { + LOG.error("Failed to completely propagate updates {}, state is undefined", changes, e); + } finally { + tx.submit(); + } } - private static void printChildren(final DataTreeCandidateNode root) { - LOG.debug("Candidate node {} type {} identifier {}", root, root.getModificationType(), root.getIdentifier()); - if (ModificationType.WRITE.equals(root.getModificationType())) { - LOG.debug("Data after {}", root.getDataAfter()); + private Map update(final DOMDataWriteTransaction tx, final Collection changes) { + final Map ret = new HashMap<>(); + + for (final DataTreeCandidate tc : changes) { + final YangInstanceIdentifier rootPath = tc.getRootPath(); + final DataTreeCandidateNode rootNode = tc.getRootNode(); + final NodeIdentifierWithPredicates peerKey = IdentifierUtils.peerKey(rootPath); + final PeerId peerId = IdentifierUtils.peerId(peerKey); + filterOutPeerRole(peerId, rootNode, rootPath); + filterOutChangesToSupportedTables(peerId, rootNode); + filterOutAnyChangeOutsideEffRibsIn(peerId, rootNode, ret, rootPath, tx); } - if (root.getChildNodes().isEmpty()) { + + return ret; + } + + private void filterOutAnyChangeOutsideEffRibsIn(final PeerId peerId, final DataTreeCandidateNode rootNode, + final Map ret, final YangInstanceIdentifier rootPath, final DOMDataWriteTransaction tx) { + final DataTreeCandidateNode ribIn = rootNode.getModifiedChild(EFFRIBIN_NID); + if (ribIn == null) { + LOG.trace("Skipping change {}", rootNode.getIdentifier()); return; } - for (final DataTreeCandidateNode child : root.getChildNodes()) { - printChildren(child); + final DataTreeCandidateNode table = ribIn.getModifiedChild(TABLES_NID).getModifiedChild(this.tableKey); + if (table == null) { + LOG.trace("Skipping change {}", rootNode.getIdentifier()); + return; } + initializeTableWithExistentRoutes(table, peerId, rootPath, tx); + updateNodes(table, peerId, tx, ret); } - @Override - public void onDataTreeChanged(final Collection changes) { - LOG.trace("Received data change to LocRib {}", Arrays.toString(changes.toArray())); - /* - * We use two-stage processing here in hopes that we avoid duplicate - * calculations when multiple peers have changed a particular entry. - */ - final Map toUpdate = new HashMap<>(); - for (final DataTreeCandidate tc : changes) { - printChildren(tc.getRootNode()); + private void filterOutChangesToSupportedTables(final PeerId peerIdOfNewPeer, final DataTreeCandidateNode rootNode) { + final DataTreeCandidateNode tablesChange = rootNode.getModifiedChild(PEER_TABLES); + if (tablesChange != null) { + this.peerPolicyTracker.onTablesChanged(peerIdOfNewPeer, tablesChange); + } + } - final YangInstanceIdentifier path = tc.getRootPath(); - final PathArgument routeId = path.getLastPathArgument(); - final NodeIdentifierWithPredicates peerKey = IdentifierUtils.peerKey(path); - final PeerId peerId = IdentifierUtils.peerId(peerKey); - final UnsignedInteger routerId = RouterIds.routerIdForPeerId(peerId); + private void initializeTableWithExistentRoutes(final DataTreeCandidateNode table, final PeerId peerIdOfNewPeer, final YangInstanceIdentifier rootPath, + final DOMDataWriteTransaction tx) { + if (!table.getDataBefore().isPresent() && this.peerPolicyTracker.isTableSupported(peerIdOfNewPeer)) { + LOG.debug("Peer {} table has been created, inserting existent routes", peerIdOfNewPeer); + final PeerRole newPeerRole = this.peerPolicyTracker.getRole(IdentifierUtils.peerPath(rootPath)); + final PeerExportGroup peerGroup = this.peerPolicyTracker.getPeerGroup(newPeerRole); + this.routeEntries.entrySet().forEach(entry -> entry.getValue().writeRoute(peerIdOfNewPeer, entry.getKey(), rootPath, peerGroup, + this.localTablesKey, this.peerPolicyTracker, this.ribSupport, this.cacheDisconnectedPeers, tx)); + } + } + + private void filterOutPeerRole(final PeerId peerId, final DataTreeCandidateNode rootNode, final YangInstanceIdentifier rootPath) { + final DataTreeCandidateNode roleChange = rootNode.getModifiedChild(PEER_ROLE_NID); + if (roleChange != null) { + if (rootNode.getModificationType() != ModificationType.DELETE) { + this.cacheDisconnectedPeers.reconnected(peerId); + } + + // Check for removal + final Optional> maybePeerRole = roleChange.getDataAfter(); + final YangInstanceIdentifier peerPath = IdentifierUtils.peerPath(rootPath); + LOG.debug("Data Changed for Peer role {} path {}, dataBefore {}, dataAfter {}", roleChange.getIdentifier(), + peerPath , roleChange.getDataBefore(), maybePeerRole); + final PeerRole role = PeerRoleUtil.roleForChange(maybePeerRole); + SimpleRoutingPolicy srp = getSimpleRoutingPolicy(rootNode); + if(PeerRole.Internal == role || SimpleRoutingPolicy.AnnounceNone == srp) { + return; + } + this.peerPolicyTracker.peerRoleChanged(peerPath, role); + } + } + + private SimpleRoutingPolicy getSimpleRoutingPolicy(final DataTreeCandidateNode rootNode) { + final DataTreeCandidateNode statusChange = rootNode.getModifiedChild(SIMPLE_ROUTING_POLICY_NID); + if (statusChange != null) { + final Optional> maybePeerStatus = statusChange.getDataAfter(); + if (maybePeerStatus.isPresent()) { + return SimpleRoutingPolicy.valueOf(BindingMapping.getClassName((String) (maybePeerStatus.get()).getValue())); + } + } + return null; + } + + private void updateNodes(final DataTreeCandidateNode table, final PeerId peerId, final DOMDataWriteTransaction tx, + final Map routes) { + for (final DataTreeCandidateNode child : table.getChildNodes()) { + LOG.debug("Modification type {}", child.getModificationType()); + if ((Attributes.QNAME).equals(child.getIdentifier().getNodeType())) { + if (child.getDataAfter().isPresent()) { + // putting uptodate attribute in + LOG.trace("Uptodate found for {}", child.getDataAfter()); + tx.put(LogicalDatastoreType.OPERATIONAL, this.locRibTarget.node(child.getIdentifier()), child.getDataAfter().get()); + } + continue; + } + updateRoutesEntries(child, peerId, routes); + } + } + private void updateRoutesEntries(final DataTreeCandidateNode child, final PeerId peerId, final Map routes) { + final UnsignedInteger routerId = RouterIds.routerIdForPeerId(peerId); + final Collection modifiedRoutes = this.ribSupport.changedRoutes(child); + for (final DataTreeCandidateNode route : modifiedRoutes) { + final PathArgument routeId = route.getIdentifier(); RouteEntry entry = this.routeEntries.get(routeId); - if (tc.getRootNode().getDataAfter().isPresent()) { + final Optional> maybeData = route.getDataAfter(); + final Optional> maybeDataBefore = route.getDataBefore(); + if (maybeData.isPresent()) { if (entry == null) { - entry = new RouteEntry(); - this.routeEntries.put(routeId, entry); - LOG.trace("Created new entry for {}", routeId); + entry = createEntry(routeId); } - - final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes.findNode(tc.getRootNode().getDataAfter(), this.ribSupport.routeAttributesIdentifier()).orNull(); - entry.addRoute(routerId, advertisedAttrs); - LOG.trace("Added route from {} attributes{}", routerId, advertisedAttrs); - } else if (entry != null && entry.removeRoute(routerId)) { + entry.addRoute(routerId, this.ribSupport.extractPathId(maybeData.get()), this.attributesIdentifier, maybeData.get()); + } else if (entry != null && entry.removeRoute(routerId, this.ribSupport.extractPathId(maybeDataBefore.get()))) { this.routeEntries.remove(routeId); - entry = null; LOG.trace("Removed route from {}", routerId); } - + final RouteUpdateKey routeUpdateKey = new RouteUpdateKey(peerId, routeId); LOG.debug("Updated route {} entry {}", routeId, entry); - toUpdate.put(new RouteUpdateKey(peerId, routeId), entry); + routes.put(routeUpdateKey, entry); } + } - final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction(); - - // Now walk all updated entries - for (final Entry e : toUpdate.entrySet()) { + private void walkThrough(final DOMDataWriteTransaction tx, final Map toUpdate) { + for (final Map.Entry e : toUpdate.entrySet()) { LOG.trace("Walking through {}", e); final RouteEntry entry = e.getValue(); - final NormalizedNode value; - - if (entry != null) { - if (!entry.selectBest(this.ourAs)) { - // Best path has not changed, no need to do anything else. Proceed to next route. - LOG.trace("Continuing"); - continue; - } - value = entry.bestValue(e.getKey().getRouteId()); - LOG.trace("Selected best value {}", value); - } else { - value = null; - } - - if (value != null) { - LOG.debug("Write route to LocRib {}", value); - tx.put(LogicalDatastoreType.OPERATIONAL, this.target.node(e.getKey().getRouteId()), value); - } else { - LOG.debug("Delete route from LocRib {}", entry); - tx.delete(LogicalDatastoreType.OPERATIONAL, this.target.node(e.getKey().getRouteId())); - } - /* - * We need to keep track of routers and populate adj-ribs-out, too. If we do not, we need to - * expose from which client a particular route was learned from in the local RIB, and have - * the listener perform filtering. - * - * We walk the policy set in order to minimize the amount of work we do for multiple peers: - * if we have two eBGP peers, for example, there is no reason why we should perform the translation - * multiple times. - */ - for (final PeerRole role : PeerRole.values()) { - final PeerExportGroup peerGroup = this.peerPolicyTracker.getPeerGroup(role); - if (peerGroup != null) { - final ContainerNode attributes = null; - final PeerId peerId = e.getKey().getPeerId(); - final ContainerNode effectiveAttributes = peerGroup.effectiveAttributes(peerId, attributes); - - for (final Entry pid : peerGroup.getPeers()) { - // This points to adj-rib-out for a particular peer/table combination - final YangInstanceIdentifier routeTarget = pid.getValue().node(e.getKey().getRouteId()); - - if (effectiveAttributes != null && value != null && !peerId.equals(pid.getKey())) { - LOG.debug("Write route to AdjRibsOut {}", value); - tx.put(LogicalDatastoreType.OPERATIONAL, routeTarget, value); - tx.put(LogicalDatastoreType.OPERATIONAL, routeTarget.node(this.attributesIdentifier), effectiveAttributes); - } else { - tx.delete(LogicalDatastoreType.OPERATIONAL, routeTarget); - } - } - } + if (!entry.selectBest(this.ourAs)) { + LOG.trace("Best path has not changed, continuing"); + continue; } + entry.updateRoute(this.localTablesKey, this.peerPolicyTracker, this.locRibTarget, this.ribSupport, this.cacheDisconnectedPeers, + tx, e.getKey().getRouteId()); } - - tx.submit(); } }