bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/BGPPeer.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 java.util.Objects.requireNonNull;
  11 import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.isAnnounceNone;
  12 import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.isLearnNone;
  13
  14 import com.google.common.annotations.VisibleForTesting;
  15 import com.google.common.base.MoreObjects;
  16 import com.google.common.base.MoreObjects.ToStringHelper;
  17 import com.google.common.base.Objects;
  18 import com.google.common.collect.ImmutableMap;
  19 import com.google.common.net.InetAddresses;
  20 import com.google.common.util.concurrent.Futures;
  21 import com.google.common.util.concurrent.ListenableFuture;
  22 import java.util.ArrayList;
  23 import java.util.Arrays;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.HashSet;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Optional;
  30 import java.util.Set;
  31 import java.util.stream.Collectors;
  32 import javax.annotation.concurrent.GuardedBy;
  33 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  34 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
  35 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  36 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  37 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
  38 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  39 import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
  40 import org.opendaylight.protocol.bgp.parser.BGPError;
  41 import org.opendaylight.protocol.bgp.parser.impl.message.update.LocalPreferenceAttributeParser;
  42 import org.opendaylight.protocol.bgp.parser.spi.MessageUtil;
  43 import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
  44 import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContext;
  45 import org.opendaylight.protocol.bgp.rib.impl.state.BGPPeerStateImpl;
  46 import org.opendaylight.protocol.bgp.rib.impl.state.BGPSessionStateProvider;
  47 import org.opendaylight.protocol.bgp.rib.spi.BGPSession;
  48 import org.opendaylight.protocol.bgp.rib.spi.BGPSessionListener;
  49 import org.opendaylight.protocol.bgp.rib.spi.BGPTerminationReason;
  50 import org.opendaylight.protocol.bgp.rib.spi.ExportPolicyPeerTracker;
  51 import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils;
  52 import org.opendaylight.protocol.bgp.rib.spi.Peer;
  53 import org.opendaylight.protocol.bgp.rib.spi.RouterIds;
  54 import org.opendaylight.protocol.bgp.rib.spi.state.BGPAfiSafiState;
  55 import org.opendaylight.protocol.bgp.rib.spi.state.BGPErrorHandlingState;
  56 import org.opendaylight.protocol.bgp.rib.spi.state.BGPSessionState;
  57 import org.opendaylight.protocol.bgp.rib.spi.state.BGPTimersState;
  58 import org.opendaylight.protocol.bgp.rib.spi.state.BGPTransportState;
  59 import org.opendaylight.protocol.concepts.AbstractRegistration;
  60 import org.opendaylight.protocol.util.Ipv4Util;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev171207.ipv4.prefixes.DestinationIpv4Builder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev171207.ipv4.prefixes.destination.ipv4.Ipv4Prefixes;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev171207.ipv4.prefixes.destination.ipv4.Ipv4PrefixesBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev171207.update.attributes.mp.reach.nlri.advertized.routes.destination.type.DestinationIpv4CaseBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.Update;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.Attributes;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.AttributesBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.update.message.Nlri;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.BgpAddPathTableType;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.BgpTableType;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.RouteRefresh;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.SendReceive;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.mp.capabilities.add.path.capability.AddressFamilies;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.MpReachNlri;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.MpReachNlriBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.MpUnreachNlri;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.MpUnreachNlriBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.mp.reach.nlri.AdvertizedRoutesBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev171207.update.attributes.mp.unreach.nlri.WithdrawnRoutesBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.peer.rpc.rev171207.BgpPeerRpcService;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.peer.rpc.rev171207.PeerContext;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.PeerId;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.PeerRole;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.SimpleRoutingPolicy;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.bgp.rib.rib.PeerKey;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.rib.TablesKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.AddressFamily;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv4AddressFamily;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.SubsequentAddressFamily;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.UnicastSubsequentAddressFamily;
  92 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  93 import org.opendaylight.yangtools.yang.binding.Notification;
  94 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  95 import org.slf4j.Logger;
  96 import org.slf4j.LoggerFactory;
  97
  98 /**
  99  * Class representing a peer. We have a single instance for each peer, which provides translation from BGP events into
 100  * RIB actions.
 101  */
 102 public class BGPPeer extends BGPPeerStateImpl implements BGPSessionListener, Peer, TransactionChainListener {
 103     private static final Logger LOG = LoggerFactory.getLogger(BGPPeer.class);
 104
 105     @GuardedBy("this")
 106     private final Set<TablesKey> tables = new HashSet<>();
 107     private final RIB rib;
 108     private final String name;
 109     private final Map<TablesKey, AdjRibOutListener> adjRibOutListenerSet = new HashMap<>();
 110     private final RpcProviderRegistry rpcRegistry;
 111     private final PeerRole peerRole;
 112     private final Optional<SimpleRoutingPolicy> simpleRoutingPolicy;
 113     @GuardedBy("this")
 114     private AbstractRegistration trackerRegistration;
 115     @GuardedBy("this")
 116     private final Set<AbstractRegistration> tableRegistration = new HashSet<>();
 117     private final PeerId peerId;
 118     private final YangInstanceIdentifier peerIId;
 119     @GuardedBy("this")
 120     private BGPSession session;
 121     @GuardedBy("this")
 122     private byte[] rawIdentifier;
 123     @GuardedBy("this")
 124     private DOMTransactionChain chain;
 125     @GuardedBy("this")
 126     private AdjRibInWriter ribWriter;
 127     @GuardedBy("this")
 128     private EffectiveRibInWriter effRibInWriter;
 129     private RoutedRpcRegistration<BgpPeerRpcService> rpcRegistration;
 130     private Map<TablesKey, SendReceive> addPathTableMaps = Collections.emptyMap();
 131
 132     public BGPPeer(final IpAddress neighborAddress, final RIB rib, final PeerRole role,
 133             final SimpleRoutingPolicy peerStatus, final RpcProviderRegistry rpcRegistry,
 134             final Set<TablesKey> afiSafisAdvertized,
 135             final Set<TablesKey> afiSafisGracefulAdvertized) {
 136         //FIXME BUG-6971 Once Peer Group is implemented, pass it
 137         super(rib.getInstanceIdentifier(), null, neighborAddress, afiSafisAdvertized,
 138                 afiSafisGracefulAdvertized);
 139         this.peerRole = role;
 140         this.simpleRoutingPolicy = Optional.ofNullable(peerStatus);
 141         this.rib = requireNonNull(rib);
 142         this.name = Ipv4Util.toStringIP(neighborAddress);
 143         this.rpcRegistry = rpcRegistry;
 144         this.peerId = RouterIds.createPeerId(neighborAddress);
 145         this.peerIId = this.rib.getYangRibId().node(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
 146                 .bgp.rib.rev171207.bgp.rib.rib.Peer.QNAME).node(IdentifierUtils.domPeerId(this.peerId));
 147         this.chain = rib.createPeerChain(this);
 148     }
 149
 150     @VisibleForTesting
 151     BGPPeer(final IpAddress neighborAddress, final RIB rib, final PeerRole role,
 152             final RpcProviderRegistry rpcRegistry, final Set<TablesKey> afiSafisAdvertized,
 153             final Set<TablesKey> afiSafisGracefulAdvertized) {
 154         this(neighborAddress, rib, role, null, rpcRegistry, afiSafisAdvertized, afiSafisGracefulAdvertized);
 155     }
 156
 157     private static Attributes nextHopToAttribute(final Attributes attrs, final MpReachNlri mpReach) {
 158         if (attrs.getCNextHop() == null && mpReach.getCNextHop() != null) {
 159             final AttributesBuilder attributesBuilder = new AttributesBuilder(attrs);
 160             attributesBuilder.setCNextHop(mpReach.getCNextHop());
 161             return attributesBuilder.build();
 162         }
 163         return attrs;
 164     }
 165
 166     /**
 167      * Creates MPReach for the prefixes to be handled in the same way as linkstate routes.
 168      *
 169      * @param message Update message containing prefixes in NLRI
 170      * @return MpReachNlri with prefixes from the nlri field
 171      */
 172     private static MpReachNlri prefixesToMpReach(final Update message) {
 173         final List<Ipv4Prefixes> prefixes = message.getNlri().stream()
 174                 .map(n -> new Ipv4PrefixesBuilder().setPrefix(n.getPrefix()).setPathId(n.getPathId()).build())
 175                 .collect(Collectors.toList());
 176         final MpReachNlriBuilder b = new MpReachNlriBuilder().setAfi(Ipv4AddressFamily.class).setSafi(
 177                 UnicastSubsequentAddressFamily.class).setAdvertizedRoutes(
 178                 new AdvertizedRoutesBuilder().setDestinationType(
 179                         new DestinationIpv4CaseBuilder().setDestinationIpv4(
 180                                 new DestinationIpv4Builder().setIpv4Prefixes(prefixes).build()).build()).build());
 181         if (message.getAttributes() != null) {
 182             b.setCNextHop(message.getAttributes().getCNextHop());
 183         }
 184         return b.build();
 185     }
 186
 187     /**
 188      * Create MPUnreach for the prefixes to be handled in the same way as linkstate routes.
 189      *
 190      * @param message            Update message containing withdrawn routes
 191      * @param isAnyNlriAnnounced isAnyNlriAnnounced
 192      * @return MpUnreachNlri with prefixes from the withdrawn routes field
 193      */
 194     private static MpUnreachNlri prefixesToMpUnreach(final Update message, final boolean isAnyNlriAnnounced) {
 195         final List<Ipv4Prefixes> prefixes = new ArrayList<>();
 196         message.getWithdrawnRoutes().forEach(w -> {
 197
 198             Optional<Nlri> nlriAnounced = Optional.empty();
 199             if (isAnyNlriAnnounced) {
 200                 nlriAnounced = message.getNlri().stream().filter(n -> Objects.equal(n.getPrefix(), w.getPrefix())
 201                         && Objects.equal(n.getPathId(), w.getPathId()))
 202                         .findAny();
 203             }
 204             if (!nlriAnounced.isPresent()) {
 205                 prefixes.add(new Ipv4PrefixesBuilder().setPrefix(w.getPrefix()).setPathId(w.getPathId()).build());
 206             }
 207         });
 208         return new MpUnreachNlriBuilder().setAfi(Ipv4AddressFamily.class).setSafi(UnicastSubsequentAddressFamily.class)
 209                 .setWithdrawnRoutes(new WithdrawnRoutesBuilder().setDestinationType(new org.opendaylight.yang.gen.v1
 210                         .urn.opendaylight.params.xml.ns.yang.bgp.inet.rev171207.update.attributes.mp.unreach.nlri
 211                         .withdrawn.routes.destination.type.DestinationIpv4CaseBuilder().setDestinationIpv4(
 212                         new DestinationIpv4Builder().setIpv4Prefixes(prefixes).build()).build()).build()).build();
 213     }
 214
 215     private static Map<TablesKey, SendReceive> mapTableTypesFamilies(final List<AddressFamilies> addPathTablesType) {
 216         return ImmutableMap.copyOf(addPathTablesType.stream().collect(Collectors.toMap(af -> new TablesKey(af.getAfi(),
 217                         af.getSafi()),
 218                 BgpAddPathTableType::getSendReceive)));
 219     }
 220
 221     public synchronized void instantiateServiceInstance() {
 222         this.ribWriter = AdjRibInWriter.create(this.rib.getYangRibId(), this.peerRole, this.simpleRoutingPolicy,
 223                 this.chain);
 224         setActive(true);
 225     }
 226
 227     // FIXME ListenableFuture<?> should be used once closeServiceInstance uses wildcard too
 228     @Override
 229     public synchronized ListenableFuture<Void> close() {
 230         final ListenableFuture<Void> future = releaseConnection();
 231         this.chain.close();
 232         setActive(false);
 233         return future;
 234     }
 235
 236     @Override
 237     public void onMessage(final BGPSession session, final Notification msg) throws BGPDocumentedException {
 238         if (!(msg instanceof Update) && !(msg instanceof RouteRefresh)) {
 239             LOG.info("Ignoring unhandled message class {}", msg.getClass());
 240             return;
 241         }
 242         if (msg instanceof Update) {
 243             onUpdateMessage((Update) msg);
 244         } else {
 245             onRouteRefreshMessage((RouteRefresh) msg);
 246         }
 247     }
 248
 249     private void onRouteRefreshMessage(final RouteRefresh message) {
 250         final Class<? extends AddressFamily> rrAfi = message.getAfi();
 251         final Class<? extends SubsequentAddressFamily> rrSafi = message.getSafi();
 252
 253         final TablesKey key = new TablesKey(rrAfi, rrSafi);
 254         final AdjRibOutListener listener = this.adjRibOutListenerSet.get(key);
 255         if (listener != null) {
 256             listener.close();
 257             this.adjRibOutListenerSet.remove(key);
 258             createAdjRibOutListener(key, listener.isMpSupported());
 259         } else {
 260             LOG.info("Ignoring RouteRefresh message. Afi/Safi is not supported: {}, {}.", rrAfi, rrSafi);
 261         }
 262     }
 263
 264     /**
 265      * Check for presence of well known mandatory attribute LOCAL_PREF in Update message.
 266      *
 267      * @param message Update message
 268      */
 269     private void checkMandatoryAttributesPresence(final Update message) throws BGPDocumentedException {
 270         if (MessageUtil.isAnyNlriPresent(message)) {
 271             final Attributes attrs = message.getAttributes();
 272             if (this.peerRole == PeerRole.Ibgp && (attrs == null || attrs.getLocalPref() == null)) {
 273                 throw new BGPDocumentedException(BGPError.MANDATORY_ATTR_MISSING_MSG + "LOCAL_PREF",
 274                         BGPError.WELL_KNOWN_ATTR_MISSING,
 275                         new byte[]{LocalPreferenceAttributeParser.TYPE});
 276             }
 277         }
 278     }
 279
 280     /**
 281      * Process Update message received.
 282      * Calls {@link #checkMandatoryAttributesPresence(Update)} to check for presence of mandatory attributes.
 283      *
 284      * @param message Update message
 285      */
 286     private synchronized void onUpdateMessage(final Update message) throws BGPDocumentedException {
 287         checkMandatoryAttributesPresence(message);
 288
 289         // update AdjRibs
 290         final Attributes attrs = message.getAttributes();
 291         MpReachNlri mpReach;
 292         final boolean isAnyNlriAnnounced = message.getNlri() != null;
 293         if (isAnyNlriAnnounced) {
 294             mpReach = prefixesToMpReach(message);
 295         } else {
 296             mpReach = MessageUtil.getMpReachNlri(attrs);
 297         }
 298         if (mpReach != null) {
 299             this.ribWriter.updateRoutes(mpReach, nextHopToAttribute(attrs, mpReach));
 300         }
 301         MpUnreachNlri mpUnreach;
 302         if (message.getWithdrawnRoutes() != null) {
 303             mpUnreach = prefixesToMpUnreach(message, isAnyNlriAnnounced);
 304         } else {
 305             mpUnreach = MessageUtil.getMpUnreachNlri(attrs);
 306         }
 307         if (mpUnreach != null) {
 308             this.ribWriter.removeRoutes(mpUnreach);
 309         }
 310     }
 311
 312     @Override
 313     public synchronized void onSessionUp(final BGPSession session) {
 314         this.session = session;
 315         if (this.session instanceof BGPSessionStateProvider) {
 316             ((BGPSessionStateProvider) this.session).registerMessagesCounter(this);
 317         }
 318         final List<AddressFamilies> addPathTablesType = session.getAdvertisedAddPathTableTypes();
 319         final Set<BgpTableType> advertizedTableTypes = session.getAdvertisedTableTypes();
 320         final List<BgpTableType> advertizedGracefulRestartTableTypes = session.getAdvertisedGracefulRestartTableTypes();
 321         LOG.info("Session with peer {} went up with tables {} and Add Path tables {}", this.name,
 322                 advertizedTableTypes, addPathTablesType);
 323         this.rawIdentifier = InetAddresses.forString(session.getBgpId().getValue()).getAddress();
 324         this.tables.addAll(advertizedTableTypes.stream().map(t -> new TablesKey(t.getAfi(), t.getSafi()))
 325                 .collect(Collectors.toList()));
 326
 327         setAdvertizedGracefulRestartTableTypes(advertizedGracefulRestartTableTypes.stream()
 328                 .map(t -> new TablesKey(t.getAfi(), t.getSafi())).collect(Collectors.toList()));
 329         final boolean announceNone = isAnnounceNone(this.simpleRoutingPolicy);
 330         this.addPathTableMaps = mapTableTypesFamilies(addPathTablesType);
 331
 332         if (!announceNone) {
 333             for (final TablesKey key : this.tables) {
 334                 createAdjRibOutListener(key, true);
 335             }
 336         }
 337
 338         for(final TablesKey tablesKey :this.tables) {
 339             final ExportPolicyPeerTracker exportTracker = this.rib.getExportPolicyPeerTracker(tablesKey);
 340             if (exportTracker != null) {
 341                 this.tableRegistration.add(exportTracker.registerPeer(this.peerId, this.addPathTableMaps.get(tablesKey),
 342                         this.peerIId, this.peerRole, this.simpleRoutingPolicy));
 343             }
 344         }
 345         addBgp4Support(announceNone);
 346
 347         if (!isLearnNone(this.simpleRoutingPolicy)) {
 348             this.effRibInWriter = EffectiveRibInWriter.create(this.rib.getService(),
 349                     this.rib.createPeerChain(this),
 350                     this.peerIId, this.rib.getImportPolicyPeerTracker(),
 351                     this.rib.getRibSupportContext(),
 352                     this.peerRole,
 353                     this.tables);
 354             registerPrefixesCounters(this.effRibInWriter, this.effRibInWriter);
 355         }
 356         this.ribWriter = this.ribWriter.transform(this.peerId, this.rib.getRibSupportContext(), this.tables,
 357                 this.addPathTableMaps);
 358
 359         if (this.rpcRegistry != null) {
 360             this.rpcRegistration = this.rpcRegistry.addRoutedRpcImplementation(BgpPeerRpcService.class,
 361                     new BgpPeerRpc(this, session, this.tables));
 362             final KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib
 363                     .rev171207.bgp.rib.rib.Peer, PeerKey> path = this.rib.getInstanceIdentifier()
 364                     .child(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev171207.bgp.rib
 365                              .rib.Peer.class, new PeerKey(this.peerId));
 366             this.rpcRegistration.registerPath(PeerContext.class, path);
 367         }
 368         this.trackerRegistration = this.rib.getPeerTracker().registerPeer(this);
 369     }
 370
 371     //try to add a support for old-school BGP-4, if peer did not advertise IPv4-Unicast MP capability
 372     private void addBgp4Support(final boolean announceNone) {
 373         final TablesKey key = new TablesKey(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class);
 374         if (this.tables.add(key) && !announceNone) {
 375             createAdjRibOutListener(key, false);
 376             final ExportPolicyPeerTracker exportTracker = this.rib.getExportPolicyPeerTracker(key);
 377             if (exportTracker != null) {
 378                 this.tableRegistration.add(exportTracker.registerPeer(peerId,  null, this.peerIId,
 379                         this.peerRole, this.simpleRoutingPolicy));
 380             }
 381         }
 382     }
 383
 384     private synchronized void createAdjRibOutListener(final TablesKey key,
 385             final boolean mpSupport) {
 386         final RIBSupportContext context = this.rib.getRibSupportContext().getRIBSupportContext(key);
 387
 388         // not particularly nice
 389         if (context != null && this.session instanceof BGPSessionImpl) {
 390             final ChannelOutputLimiter limiter = ((BGPSessionImpl) this.session).getLimiter();
 391             final AdjRibOutListener adjRibOut = AdjRibOutListener.create(this.peerId, key,
 392                     this.rib.getYangRibId(), this.rib.getCodecsRegistry(), context.getRibSupport(),
 393                     this.rib.getService(), limiter, mpSupport);
 394             this.adjRibOutListenerSet.put(key, adjRibOut);
 395             registerPrefixesSentCounter(key, adjRibOut);
 396         }
 397     }
 398
 399     private ListenableFuture<Void> cleanup() {
 400         // FIXME: BUG-196: support graceful
 401         this.adjRibOutListenerSet.values().forEach(AdjRibOutListener::close);
 402         this.adjRibOutListenerSet.clear();
 403         if (this.effRibInWriter != null) {
 404             this.effRibInWriter.close();
 405         }
 406         this.tables.clear();
 407         if (this.ribWriter != null) {
 408             return this.ribWriter.removePeer();
 409         }
 410         return Futures.immediateFuture(null);
 411     }
 412
 413     @Override
 414     public void onSessionDown(final BGPSession session, final Exception e) {
 415         if (e.getMessage().equals(BGPSessionImpl.END_OF_INPUT)) {
 416             LOG.info("Session with peer {} went down", this.name);
 417         } else {
 418             LOG.info("Session with peer {} went down", this.name, e);
 419         }
 420         releaseConnection();
 421     }
 422
 423     @Override
 424     public void onSessionTerminated(final BGPSession session, final BGPTerminationReason cause) {
 425         LOG.info("Session with peer {} terminated: {}", this.name, cause);
 426         releaseConnection();
 427     }
 428
 429     @Override
 430     public String toString() {
 431         return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
 432     }
 433
 434     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 435         toStringHelper.add("name", this.name);
 436         toStringHelper.add("tables", this.tables);
 437         return toStringHelper;
 438     }
 439
 440     @Override
 441     public String getName() {
 442         return this.name;
 443     }
 444
 445     @Override
 446     public synchronized ListenableFuture<Void> releaseConnection() {
 447         if (this.rpcRegistration != null) {
 448             this.rpcRegistration.close();
 449         }
 450         closeRegistration();
 451         final ListenableFuture<Void> future = cleanup();
 452
 453         if (this.session != null) {
 454             try {
 455                 this.session.close();
 456             } catch (final Exception e) {
 457                 LOG.warn("Error closing session with peer", e);
 458             }
 459             this.session = null;
 460         }
 461
 462         resetState();
 463         return future;
 464     }
 465
 466     private void closeRegistration() {
 467         this.tableRegistration.iterator().forEachRemaining(AbstractRegistration::close);
 468         this.tableRegistration.clear();
 469         if (this.trackerRegistration != null) {
 470             this.trackerRegistration.close();
 471             this.trackerRegistration = null;
 472         }
 473     }
 474
 475     @Override
 476     public synchronized byte[] getRawIdentifier() {
 477         return Arrays.copyOf(this.rawIdentifier, this.rawIdentifier.length);
 478     }
 479
 480     @Override
 481     public PeerId getPeerId() {
 482         return this.peerId;
 483     }
 484
 485     @Override
 486     public SendReceive getSupportedAddPathTables(final TablesKey tableKey) {
 487         return this.addPathTableMaps.get(tableKey);
 488     }
 489
 490     @Override
 491     public boolean supportsTable(final TablesKey tableKey) {
 492         return this.tables.contains(tableKey);
 493     }
 494
 495     @Override
 496     public YangInstanceIdentifier getPeerRibInstanceIdentifier() {
 497         return this.peerIId;
 498     }
 499
 500     @Override
 501     public PeerRole getRole() {
 502         return this.peerRole;
 503     }
 504
 505     @Override
 506     public synchronized void onTransactionChainFailed(final TransactionChain<?, ?> chain,
 507             final AsyncTransaction<?, ?> transaction, final Throwable cause) {
 508         LOG.error("Transaction chain failed.", cause);
 509         this.chain.close();
 510         this.chain = this.rib.createPeerChain(this);
 511         this.ribWriter = AdjRibInWriter.create(this.rib.getYangRibId(), this.peerRole, this.simpleRoutingPolicy,
 512                 this.chain);
 513         releaseConnection();
 514     }
 515
 516     @Override
 517     public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
 518         LOG.debug("Transaction chain {} successful.", chain);
 519     }
 520
 521     @Override
 522     public synchronized void markUptodate(final TablesKey tablesKey) {
 523         this.ribWriter.markTableUptodate(tablesKey);
 524     }
 525
 526     @Override
 527     public BGPErrorHandlingState getBGPErrorHandlingState() {
 528         return this;
 529     }
 530
 531     @Override
 532     public BGPAfiSafiState getBGPAfiSafiState() {
 533         return this;
 534     }
 535
 536     @Override
 537     public synchronized BGPSessionState getBGPSessionState() {
 538         if (this.session instanceof BGPSessionStateProvider) {
 539             return ((BGPSessionStateProvider) this.session).getBGPSessionState();
 540         }
 541         return null;
 542     }
 543
 544     @Override
 545     public synchronized BGPTimersState getBGPTimersState() {
 546         if (this.session instanceof BGPSessionStateProvider) {
 547             return ((BGPSessionStateProvider) this.session).getBGPTimersState();
 548         }
 549         return null;
 550     }
 551
 552     @Override
 553     public synchronized BGPTransportState getBGPTransportState() {
 554         if (this.session instanceof BGPSessionStateProvider) {
 555             return ((BGPSessionStateProvider) this.session).getBGPTransportState();
 556         }
 557         return null;
 558     }
 559 }