bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/ApplicationPeer.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.bgp.rib.impl;
   9
  10 import static com.google.common.base.Verify.verify;
  11 import static java.util.Objects.requireNonNull;
  12 import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBIN_NID;
  13 import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ADJRIBOUT_NID;
  14 import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID;
  15 import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.ROUTES_NID;
  16 import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID;
  17
  18 import com.google.common.cache.CacheBuilder;
  19 import com.google.common.cache.CacheLoader;
  20 import com.google.common.cache.LoadingCache;
  21 import com.google.common.util.concurrent.FluentFuture;
  22 import com.google.common.util.concurrent.FutureCallback;
  23 import com.google.common.util.concurrent.MoreExecutors;
  24 import java.util.ArrayList;
  25 import java.util.HashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29 import org.opendaylight.mdsal.common.api.CommitInfo;
  30 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  31 import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
  32 import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
  33 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  34 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  35 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
  36 import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
  37 import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
  38 import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
  39 import org.opendaylight.protocol.bgp.rib.impl.state.BGPSessionStateImpl;
  40 import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils;
  41 import org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers;
  42 import org.opendaylight.protocol.bgp.rib.spi.RouterIds;
  43 import org.opendaylight.protocol.bgp.rib.spi.state.BGPSessionState;
  44 import org.opendaylight.protocol.bgp.rib.spi.state.BGPTimersState;
  45 import org.opendaylight.protocol.bgp.rib.spi.state.BGPTransportState;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressNoZone;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.SendReceive;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.ApplicationRibId;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerRole;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.RouteTarget;
  53 import org.opendaylight.yangtools.concepts.Registration;
  54 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  55 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  56 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  57 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
  58 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 /**
  63  * Application Peer is a special case of BGP peer. It serves as an interface
  64  * for user to advertise user routes to ODL and through ODL to other BGP peers.
  65  *
  66  * <p>
  67  * This peer has it's own RIB, where it stores all user routes. This RIB is
  68  * located in configurational datastore. Routes are added through RESTCONF.
  69  *
  70  * <p>
  71  * They are then processed as routes from any other peer, through AdjRib,
  72  * EffectiveRib,LocRib and if they are advertised further, through AdjRibOut.
  73  *
  74  * <p>
  75  * For purposed of import policies such as Best Path Selection, application
  76  * peer needs to have a BGP-ID that is configurable.
  77  */
  78 public class ApplicationPeer extends AbstractPeer implements DOMDataTreeChangeListener {
  79     private static final Logger LOG = LoggerFactory.getLogger(ApplicationPeer.class);
  80     private static final String APP_PEER_GROUP = "application-peers";
  81
  82     private final LoadingCache<NodeIdentifierWithPredicates, YangInstanceIdentifier> tablesIId =
  83         CacheBuilder.newBuilder().build(new CacheLoader<NodeIdentifierWithPredicates, YangInstanceIdentifier>() {
  84             @Override
  85             public YangInstanceIdentifier load(final NodeIdentifierWithPredicates key) {
  86                 return peerRibOutIId.node(RIBNodeIdentifiers.TABLES_NID).node(key);
  87             }
  88         });
  89
  90     private final YangInstanceIdentifier adjRibsInId;
  91     private final YangInstanceIdentifier peerRibOutIId;
  92     private final BGPTableTypeRegistryConsumer tableTypeRegistry;
  93     private EffectiveRibInWriter effectiveRibInWriter;
  94     private AdjRibInWriter adjRibInWriter;
  95     private Registration registration;
  96     private final Set<NodeIdentifierWithPredicates> supportedTables = new HashSet<>();
  97     private final BGPSessionStateImpl bgpSessionState = new BGPSessionStateImpl();
  98     private Registration trackerRegistration;
  99     private YangInstanceIdentifier peerPath;
 100
 101     @Override
 102     public List<RouteTarget> getMemberships() {
 103         return List.of();
 104     }
 105
 106     @FunctionalInterface
 107     interface RegisterAppPeerListener {
 108         /**
 109          * Register Application Peer Change Listener once AdjRibIn has been successfully initialized.
 110          */
 111         void register();
 112     }
 113
 114     public ApplicationPeer(
 115             final BGPTableTypeRegistryConsumer tableTypeRegistry,
 116             final ApplicationRibId applicationRibId, final Ipv4AddressNoZone ipAddress, final RIB rib) {
 117         super(rib, applicationRibId.getValue(), APP_PEER_GROUP, PeerRole.Internal,
 118                 new IpAddressNoZone(ipAddress), Set.of());
 119         this.tableTypeRegistry = requireNonNull(tableTypeRegistry);
 120         final RIB targetRib = requireNonNull(rib);
 121         peerId = RouterIds.createPeerId(ipAddress);
 122
 123         final YangInstanceIdentifier peerRib = targetRib.getYangRibId().node(PEER_NID)
 124             .node(IdentifierUtils.domPeerId(peerId));
 125         adjRibsInId = peerRib.node(ADJRIBIN_NID).node(TABLES_NID).toOptimized();
 126         peerRibOutIId = peerRib.node(ADJRIBOUT_NID).node(TABLES_NID).toOptimized();
 127     }
 128
 129     public synchronized void instantiateServiceInstance(final DataTreeChangeExtension dataTreeChangeService,
 130             final DOMDataTreeIdentifier appPeerDOMId) {
 131         setActive(true);
 132         final var localTables = rib.getLocalTablesKeys();
 133         for (var localTable : localTables) {
 134             final var tableSupport = rib.getRibSupportContext().getRIBSupport(localTable);
 135             if (tableSupport != null) {
 136                 supportedTables.add(tableSupport.tablesKey());
 137             } else {
 138                 LOG.warn("Ignoring unsupported table {}", localTable);
 139             }
 140         }
 141         setAdvertizedGracefulRestartTableTypes(List.of());
 142
 143         createDomChain();
 144         adjRibInWriter = AdjRibInWriter.create(rib.getYangRibId(), PeerRole.Internal, this);
 145         final RIBSupportContextRegistry context = rib.getRibSupportContext();
 146         peerPath = createPeerPath(peerId);
 147         adjRibInWriter = adjRibInWriter.transform(peerId, peerPath, context, localTables, Map.of(),
 148             () -> {
 149                 synchronized (this) {
 150                     if (getDomChain() != null) {
 151                         registration = dataTreeChangeService.registerTreeChangeListener(appPeerDOMId, this);
 152                     }
 153                 }
 154             });
 155
 156         final var chain = rib.createPeerDOMChain();
 157         chain.addCallback(this);
 158
 159         effectiveRibInWriter = new EffectiveRibInWriter(this, rib, chain, peerPath, localTables, tableTypeRegistry,
 160             new ArrayList<>(), rtCache);
 161         effectiveRibInWriter.init();
 162         bgpSessionState.registerMessagesCounter(this);
 163         trackerRegistration = rib.getPeerTracker().registerPeer(this);
 164     }
 165
 166     @Override
 167     public void onInitialData() {
 168         // FIXME: we really want to (under a synchronized block) to ensure adj-rib-in is completely empty here.
 169         //        Unfortunately that bit is already being done somewhere else. The entire the tables are being created
 170         //        elsewhere and therefore we need to reign in lifecycle first
 171     }
 172
 173     /**
 174      * Routes come from application RIB that is identified by (configurable) name.
 175      * Each route is pushed into AdjRibsInWriter with it's whole context. In this
 176      * method, it doesn't matter if the routes are removed or added, this will
 177      * be determined in LocRib.
 178      */
 179     @Override
 180     public synchronized void onDataTreeChanged(final List<DataTreeCandidate> changes) {
 181         final DOMTransactionChain chain = getDomChain();
 182         if (chain == null) {
 183             LOG.trace("Skipping data changed called to Application Peer. Change : {}", changes);
 184             return;
 185         }
 186         final DOMDataTreeWriteTransaction tx = chain.newWriteOnlyTransaction();
 187         LOG.debug("Received data change to ApplicationRib {}", changes);
 188         for (final DataTreeCandidate tc : changes) {
 189             LOG.debug("Modification Type {}", tc.getRootNode().modificationType());
 190             final YangInstanceIdentifier path = tc.getRootPath();
 191             final PathArgument lastArg = path.getLastPathArgument();
 192             verify(lastArg instanceof NodeIdentifierWithPredicates,
 193                     "Unexpected type %s in path %s", lastArg.getClass(), path);
 194             final NodeIdentifierWithPredicates tableKey = (NodeIdentifierWithPredicates) lastArg;
 195             if (!supportedTables.contains(tableKey)) {
 196                 LOG.trace("Skipping received data change for non supported family {}.", tableKey);
 197                 continue;
 198             }
 199             for (final DataTreeCandidateNode child : tc.getRootNode().childNodes()) {
 200                 final PathArgument childIdentifier = child.name();
 201                 final YangInstanceIdentifier tableId = adjRibsInId.node(tableKey).node(childIdentifier);
 202                 switch (child.modificationType()) {
 203                     case DELETE:
 204                     case DISAPPEARED:
 205                         LOG.trace("App peer -> AdjRibsIn path delete: {}", childIdentifier);
 206                         tx.delete(LogicalDatastoreType.OPERATIONAL, tableId);
 207                         break;
 208                     case UNMODIFIED:
 209                         // No-op
 210                         break;
 211                     case SUBTREE_MODIFIED:
 212                         if (ROUTES_NID.equals(childIdentifier)) {
 213                             processRoutesTable(child, tableId, tx, tableId);
 214                         } else {
 215                             processWrite(child, tableId, tx);
 216                         }
 217                         break;
 218                     case WRITE:
 219                     case APPEARED:
 220                         processWrite(child, tableId, tx);
 221                         break;
 222                     default:
 223                         break;
 224                 }
 225             }
 226         }
 227         tx.commit().addCallback(new FutureCallback<CommitInfo>() {
 228             @Override
 229             public void onSuccess(final CommitInfo result) {
 230                 LOG.trace("Successful commit");
 231             }
 232
 233             @Override
 234             public void onFailure(final Throwable trw) {
 235                 LOG.error("Failed commit", trw);
 236             }
 237         }, MoreExecutors.directExecutor());
 238     }
 239
 240     private static void processWrite(final DataTreeCandidateNode child, final YangInstanceIdentifier tableId,
 241             final DOMDataTreeWriteTransaction tx) {
 242         final var dataAfter = child.dataAfter();
 243         if (dataAfter != null) {
 244             LOG.trace("App peer -> AdjRibsIn path : {}", tableId);
 245             LOG.trace("App peer -> AdjRibsIn data : {}", dataAfter);
 246             tx.put(LogicalDatastoreType.OPERATIONAL, tableId, dataAfter);
 247         }
 248     }
 249
 250     private synchronized void processRoutesTable(final DataTreeCandidateNode node,
 251             final YangInstanceIdentifier identifier, final DOMDataTreeWriteTransaction tx,
 252             final YangInstanceIdentifier routeTableIdentifier) {
 253         for (var child : node.childNodes()) {
 254             final YangInstanceIdentifier childIdentifier = identifier.node(child.name());
 255             switch (child.modificationType()) {
 256                 case DELETE:
 257                     LOG.trace("App peer -> AdjRibsIn path delete: {}", childIdentifier);
 258                     tx.delete(LogicalDatastoreType.OPERATIONAL, childIdentifier);
 259                     break;
 260                 case UNMODIFIED:
 261                     // No-op
 262                     break;
 263                 case SUBTREE_MODIFIED:
 264                     // For be ables to use DELETE when we remove specific routes as we do when we remove the whole
 265                     // routes, we need to go deeper three levels
 266                     if (!routeTableIdentifier.equals(childIdentifier.getParent().getParent().getParent())) {
 267                         processRoutesTable(child, childIdentifier, tx, routeTableIdentifier);
 268                     } else {
 269                         processRouteWrite(child, childIdentifier, tx);
 270                     }
 271                     break;
 272                 case WRITE:
 273                     processRouteWrite(child, childIdentifier, tx);
 274                     break;
 275                 default:
 276                     break;
 277             }
 278         }
 279     }
 280
 281     private static void processRouteWrite(final DataTreeCandidateNode child,
 282             final YangInstanceIdentifier childIdentifier, final DOMDataTreeWriteTransaction tx) {
 283         final var dataAfter = child.dataAfter();
 284         if (dataAfter != null) {
 285             LOG.trace("App peer -> AdjRibsIn path : {}", childIdentifier);
 286             LOG.trace("App peer -> AdjRibsIn data : {}", dataAfter);
 287             tx.put(LogicalDatastoreType.OPERATIONAL, childIdentifier, dataAfter);
 288         }
 289     }
 290
 291     @Override
 292     public synchronized FluentFuture<? extends CommitInfo> close() {
 293         setActive(false);
 294         if (registration != null) {
 295             registration.close();
 296             registration = null;
 297         }
 298         if (adjRibInWriter != null) {
 299             adjRibInWriter.releaseChain();
 300         }
 301         if (effectiveRibInWriter != null) {
 302             effectiveRibInWriter.close();
 303         }
 304         final FluentFuture<? extends CommitInfo> future = removePeer(peerPath);
 305         closeDomChain();
 306         if (trackerRegistration != null) {
 307             trackerRegistration.close();
 308             trackerRegistration = null;
 309         }
 310         return future;
 311     }
 312
 313     @Override
 314     public boolean supportsAddPathSupported(final TablesKey tableKey) {
 315         return false;
 316     }
 317
 318     @Override
 319     public SendReceive getSupportedAddPathTables(final TablesKey tableKey) {
 320         return null;
 321     }
 322
 323     @Override
 324     public boolean supportsTable(final TablesKey tableKey) {
 325         return rib.supportsTable(tableKey);
 326     }
 327
 328     @Override
 329     public YangInstanceIdentifier getRibOutIId(final NodeIdentifierWithPredicates tablekey) {
 330         return tablesIId.getUnchecked(tablekey);
 331     }
 332
 333     @Override
 334     public void onFailure(final Throwable cause) {
 335         LOG.error("Transaction chain failed.", cause);
 336     }
 337
 338     @Override
 339     public BGPSessionState getBGPSessionState() {
 340         return bgpSessionState;
 341     }
 342
 343     @Override
 344     public BGPTimersState getBGPTimersState() {
 345         return bgpSessionState;
 346     }
 347
 348     @Override
 349     public BGPTransportState getBGPTransportState() {
 350         return bgpSessionState;
 351     }
 352 }