X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=bgp%2Frib-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fprotocol%2Fbgp%2Frib%2Fimpl%2FLocRibWriter.java;h=3cbd173c11b78eaa91231ea076e590824f3bb973;hb=d7a1cb6b14d397b673bbff9183e51178388b7423;hp=0c6481d3fb644b155aeee44bfafcfa2daa05d627;hpb=51bae8d30025bcf95b2a4a6f5627a31da8580bf6;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 0c6481d3fb..3cbd173c11 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 @@ -13,24 +13,30 @@ import com.google.common.primitives.UnsignedInteger; import java.util.Collection; import java.util.HashMap; import java.util.Map; -import java.util.Map.Entry; +import java.util.Set; import javax.annotation.Nonnull; import javax.annotation.concurrent.NotThreadSafe; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener; +import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener; 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.impl.stats.UnsignedInt32Counter; +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.RIBSupport; import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber; +import org.opendaylight.protocol.bgp.rib.spi.RouterIds; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.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.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.AdjRibOut; 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.rib.Tables; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey; @@ -42,7 +48,6 @@ 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.tree.DataTreeCandidate; @@ -52,208 +57,173 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; @NotThreadSafe -final class LocRibWriter implements AutoCloseable, DOMDataTreeChangeListener { +final class LocRibWriter implements AutoCloseable, ClusteredDOMDataTreeChangeListener { 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 ROUTES_IDENTIFIER = new NodeIdentifier(Routes.QNAME); - private static final NodeIdentifier EFFRIBIN_NID = new NodeIdentifier(EffectiveRibIn.QNAME); - private static final NodeIdentifier TABLES_NID = new NodeIdentifier(Tables.QNAME); - private final Map routeEntries = new HashMap<>(); + private final Map routeEntries = new HashMap<>(); private final YangInstanceIdentifier locRibTarget; private final DOMTransactionChain chain; - private final ExportPolicyPeerTracker peerPolicyTracker; + private final ExportPolicyPeerTracker exportPolicyPeerTracker; private final NodeIdentifier attributesIdentifier; private final Long ourAs; private final RIBSupport ribSupport; - private final NodeIdentifierWithPredicates tableKey; - private final RIBSupportContextRegistry registry; + private final TablesKey localTablesKey; private final ListenerRegistration reg; + private final PathSelectionMode pathSelectionMode; + private final UnsignedInt32Counter routeCounter; - LocRibWriter(final RIBSupportContextRegistry registry, final DOMTransactionChain chain, final YangInstanceIdentifier target, final Long ourAs, - final DOMDataTreeChangeService service, final PolicyDatabase pd, final TablesKey tablesKey) { + private LocRibWriter(final RIBSupportContextRegistry registry, final DOMTransactionChain chain, final YangInstanceIdentifier target, + final Long ourAs, final DOMDataTreeChangeService service, final ExportPolicyPeerTracker exportPolicyPeerTracker, final TablesKey tablesKey, + @Nonnull final PathSelectionMode pathSelectionMode, final UnsignedInt32Counter routeCounter) { this.chain = Preconditions.checkNotNull(chain); - this.tableKey = RibSupportUtils.toYangTablesKey(tablesKey); - this.locRibTarget = YangInstanceIdentifier.create(target.node(LocRib.QNAME).node(Tables.QNAME).node(this.tableKey).getPathArguments()); + final NodeIdentifierWithPredicates tableKey = RibSupportUtils.toYangTablesKey(tablesKey); + this.localTablesKey = tablesKey; + this.locRibTarget = YangInstanceIdentifier.create(target.node(LocRib.QNAME).node(Tables.QNAME).node(tableKey).getPathArguments()); this.ourAs = Preconditions.checkNotNull(ourAs); - this.registry = registry; - this.ribSupport = this.registry.getRIBSupportContext(tablesKey).getRibSupport(); + this.ribSupport = registry.getRIBSupportContext(tablesKey).getRibSupport(); this.attributesIdentifier = this.ribSupport.routeAttributesIdentifier(); - this.peerPolicyTracker = new ExportPolicyPeerTracker(pd); + this.exportPolicyPeerTracker = exportPolicyPeerTracker; + this.pathSelectionMode = pathSelectionMode; + this.routeCounter = routeCounter; 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); - - this.reg = service.registerDataTreeChangeListener(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, tableId), this); + final YangInstanceIdentifier tableId = target.node(Peer.QNAME).node(Peer.QNAME).node(EffectiveRibIn.QNAME).node(Tables.QNAME).node(tableKey); + final DOMDataTreeIdentifier wildcard = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, tableId); + this.reg = service.registerDataTreeChangeListener(wildcard, this); } - 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) { - return new LocRibWriter(registry, chain, target, ourAs.getValue(), service, pd, tablesKey); + 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 ExportPolicyPeerTracker ep, + @Nonnull final PathSelectionMode pathSelectionStrategy, @Nonnull final UnsignedInt32Counter routeCounter) { + return new LocRibWriter(registry, chain, target, ourAs.getValue(), service, ep, tablesKey, pathSelectionStrategy, routeCounter); } @Override public void close() { this.reg.close(); - // FIXME: wipe the local rib // FIXME: wait for the chain to close? unfortunately RIBImpl is the listener, so that may require some work this.chain.close(); } - @Nonnull private AbstractRouteEntry createEntry(final PathArgument routeId) { - final AbstractRouteEntry ret = this.ribSupport.isComplexRoute() ? new ComplexRouteEntry() : new SimpleRouteEntry(); - + @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; } + /** + * We use two-stage processing here in hopes that we avoid duplicate + * calculations when multiple peers have changed a particular entry. + * + * @param changes on supported table + */ @Override public void onDataTreeChanged(final Collection changes) { - LOG.trace("Received data change to LocRib {}", 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); + final Map toUpdate = update(tx, changes); - // Now walk all updated entries - walkThrough(tx, toUpdate); - } catch (Exception e) { + if (!toUpdate.isEmpty()) { + walkThrough(tx, toUpdate.entrySet()); + } + } catch (final Exception e) { LOG.error("Failed to completely propagate updates {}, state is undefined", changes, e); } finally { tx.submit(); } } - private Map update(final DOMDataWriteTransaction tx, - final Collection changes) { - final Map ret = new HashMap<>(); - - for (final DataTreeCandidate tc : changes) { - // call out peer-role has changed + private Map update(final DOMDataWriteTransaction tx, final Collection changes) { + final Map ret = new HashMap<>(); + changes.forEach(tc -> { + final DataTreeCandidateNode table = tc.getRootNode(); final YangInstanceIdentifier rootPath = tc.getRootPath(); - final DataTreeCandidateNode rootNode = tc.getRootNode(); - final DataTreeCandidateNode roleChange = rootNode.getModifiedChild(AbstractPeerRoleTracker.PEER_ROLE_NID); - if (roleChange != null) { - this.peerPolicyTracker.onDataTreeChanged(roleChange, IdentifierUtils.peerPath(rootPath)); - } - // filter out any change outside EffRibsIn - final DataTreeCandidateNode ribIn = rootNode.getModifiedChild(EFFRIBIN_NID); - if (ribIn == null) { - LOG.debug("Skipping change {}", tc.getRootNode()); - continue; - } - final DataTreeCandidateNode table = ribIn.getModifiedChild(TABLES_NID).getModifiedChild(this.tableKey); - if (table == null) { - LOG.debug("Skipping change {}", tc.getRootNode()); - continue; - } - final NodeIdentifierWithPredicates peerKey = IdentifierUtils.peerKey(rootPath); - final PeerId peerId = IdentifierUtils.peerId(peerKey); - final UnsignedInteger routerId = RouterIds.routerIdForPeerId(peerId); - for (final DataTreeCandidateNode child : table.getChildNodes()) { - 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; - } - for (final DataTreeCandidateNode route : this.ribSupport.changedRoutes(child)) { - final PathArgument routeId = route.getIdentifier(); - AbstractRouteEntry entry = this.routeEntries.get(routeId); + final PeerId peerId = IdentifierUtils.peerKeyToPeerId(rootPath); + initializeTableWithExistentRoutes(table, peerId, rootPath, tx); + updateNodes(table, peerId, tx, ret); + }); + return ret; + } - final Optional> maybeData = route.getDataAfter(); - if (maybeData.isPresent()) { - if (entry == null) { - entry = createEntry(routeId); - } + private void initializeTableWithExistentRoutes(final DataTreeCandidateNode table, final PeerId peerIdOfNewPeer, final YangInstanceIdentifier rootPath, + final DOMDataWriteTransaction tx) { + if (!table.getDataBefore().isPresent() && this.exportPolicyPeerTracker.isTableSupported(peerIdOfNewPeer)) { + LOG.debug("Peer {} table has been created, inserting existent routes", peerIdOfNewPeer); + final PeerRole newPeerRole = this.exportPolicyPeerTracker.getRole(IdentifierUtils.peerPath(rootPath)); + final PeerExportGroup peerGroup = this.exportPolicyPeerTracker.getPeerGroup(newPeerRole); + this.routeEntries.entrySet().forEach(entry -> entry.getValue().writeRoute(peerIdOfNewPeer, entry.getKey(), + rootPath.getParent().getParent().getParent(), peerGroup, this.localTablesKey, this.exportPolicyPeerTracker, this.ribSupport, tx)); + } + } - entry.addRoute(routerId, this.attributesIdentifier, maybeData.get()); - } else if (entry != null && entry.removeRoute(routerId)) { - this.routeEntries.remove(routeId); - entry = null; - LOG.trace("Removed route from {}", routerId); - } - LOG.debug("Updated route {} entry {}", routeId, entry); - ret.put(new RouteUpdateKey(peerId, routeId), entry); + 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); } - - return ret; } - private void walkThrough(final DOMDataWriteTransaction tx, final Map toUpdate) { - for (final Entry e : toUpdate.entrySet()) { - LOG.trace("Walking through {}", e); - final AbstractRouteEntry entry = e.getValue(); - final RouteUpdateKey key = e.getKey(); - 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; + 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 = this.ribSupport.createRouteKeyPathArgument(route.getIdentifier()); + RouteEntry entry = this.routeEntries.get(routeId); + final Optional> maybeData = route.getDataAfter(); + final Optional> maybeDataBefore = route.getDataBefore(); + if (maybeData.isPresent()) { + if (entry == null) { + entry = createEntry(routeId); } - value = entry.createValue(key.getRouteId()); - LOG.trace("Selected best value {}", value); - } else { - value = null; - } - - final YangInstanceIdentifier writePath = this.ribSupport.routePath(this.locRibTarget.node(ROUTES_IDENTIFIER), key.getRouteId()); - if (value != null) { - LOG.debug("Write route to LocRib {}", value); - tx.put(LogicalDatastoreType.OPERATIONAL, writePath, value); - } else { - LOG.debug("Delete route from LocRib {}", entry); - tx.delete(LogicalDatastoreType.OPERATIONAL, writePath); + 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); + LOG.trace("Removed route from {}", routerId); } - fillAdjRibsOut(tx, entry, value, key); + final RouteUpdateKey routeUpdateKey = new RouteUpdateKey(peerId, routeId); + LOG.debug("Updated route {} entry {}", routeId, entry); + routes.put(routeUpdateKey, entry); } + updateRouteCounter(); } - private void fillAdjRibsOut(final DOMDataWriteTransaction tx, final AbstractRouteEntry entry, final NormalizedNode value, final RouteUpdateKey key) { - /* - * 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 = entry == null ? null : entry.attributes(); - final PeerId peerId = key.getPeerId(); - final ContainerNode effectiveAttributes = peerGroup.effectiveAttributes(peerId, attributes); - for (final Entry pid : peerGroup.getPeers()) { - final YangInstanceIdentifier routeTarget = this.ribSupport.routePath(pid.getValue().node(AdjRibOut.QNAME).node(Tables.QNAME).node(this.tableKey).node(ROUTES_IDENTIFIER), key.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 { - LOG.trace("Removing {} from transaction", routeTarget); - tx.delete(LogicalDatastoreType.OPERATIONAL, routeTarget); - } - } + /** + * Update the statistic of loc-rib route + */ + private void updateRouteCounter() { + routeCounter.setCount(this.routeEntries.size()); + } + + private void walkThrough(final DOMDataWriteTransaction tx, final Set> toUpdate) { + for (final Map.Entry e : toUpdate) { + LOG.trace("Walking through {}", e); + final RouteEntry entry = e.getValue(); + + if (!entry.selectBest(this.ourAs)) { + LOG.trace("Best path has not changed, continuing"); + continue; } + entry.updateRoute(this.localTablesKey, this.exportPolicyPeerTracker, this.locRibTarget, this.ribSupport, tx, e.getKey().getRouteId()); } } }