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