*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.annotations.VisibleForTesting;
+import static java.util.Objects.requireNonNull;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
-import java.util.ArrayList;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
-import javax.annotation.concurrent.ThreadSafe;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
-import org.opendaylight.protocol.bgp.openconfig.spi.BGPConfigModuleTracker;
-import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigProvider;
-import org.opendaylight.protocol.bgp.rib.DefaultRibReference;
+import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
-import org.opendaylight.protocol.bgp.rib.spi.CacheDisconnectedPeers;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RibOutRefresh;
+import org.opendaylight.protocol.bgp.rib.impl.state.BGPRibStateImpl;
+import org.opendaylight.protocol.bgp.rib.spi.BGPPeerTracker;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
-import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils;
+import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
+import org.opendaylight.protocol.bgp.rib.spi.policy.BGPRibRoutingPolicy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev150305.bgp.rib.rib.loc.rib.tables.routes.Ipv4RoutesCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev150305.bgp.rib.rib.loc.rib.tables.routes.Ipv6RoutesCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.BgpRib;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.Rib;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.RibKey;
-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.rib.Tables;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.tables.Routes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
-import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.BgpTableType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.RibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.RibKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.BgpId;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
-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.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-@ThreadSafe
-public final class RIBImpl extends DefaultRibReference implements AutoCloseable, RIB, TransactionChainListener, SchemaContextListener {
+// This class is thread-safe
+public final class RIBImpl extends BGPRibStateImpl implements RIB, TransactionChainListener,
+ DOMTransactionChainListener, SchemaContextListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(RIBImpl.class);
- @VisibleForTesting
- public static final QName RIB_ID_QNAME = QName.create(Rib.QNAME, "id").intern();
- @VisibleForTesting
- public static final ContainerNode EMPTY_TABLE_ATTRIBUTES = ImmutableNodes.containerNode(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.tables.Attributes.QNAME);
+ private static final QName RIB_ID_QNAME = QName.create(Rib.QNAME, "id").intern();
private final BGPDispatcher dispatcher;
- private final DOMTransactionChain domChain;
private final AsNumber localAs;
private final BgpId bgpIdentifier;
private final Set<BgpTableType> localTables;
private final Set<TablesKey> localTablesKeys;
- private final DataBroker dataBroker;
private final DOMDataBroker domDataBroker;
+ private final DataBroker dataBroker;
private final RIBExtensionConsumerContext extensions;
private final YangInstanceIdentifier yangRibId;
private final RIBSupportContextRegistryImpl ribContextRegistry;
private final CodecsRegistryImpl codecsRegistry;
- private final DOMDataBrokerExtension service;
- private final List<LocRibWriter> locRibs = new ArrayList<>();
- private final BGPConfigModuleTracker configModuleTracker;
- private final BGPOpenConfigProvider openConfigProvider;
- private final CacheDisconnectedPeers cacheDisconnectedPeers;
+ private final BGPTableTypeRegistryConsumer tableTypeRegistry;
+ private final DOMDataBrokerExtension domService;
+ private final Map<TransactionChain, LocRibWriter> txChainToLocRibWriter = new HashMap<>();
private final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies;
- private final ImportPolicyPeerTracker importPolicyPeerTracker;
-
- public RIBImpl(final RibId ribId, final AsNumber localAs, final BgpId localBgpId, final ClusterIdentifier clusterId, final RIBExtensionConsumerContext extensions,
- final BGPDispatcher dispatcher, final BindingCodecTreeFactory codecFactory,
- final DataBroker dps, final DOMDataBroker domDataBroker, final List<BgpTableType> localTables,
- @Nonnull final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies, final GeneratedClassLoadingStrategy classStrategy,
- final BGPConfigModuleTracker moduleTracker, final BGPOpenConfigProvider openConfigProvider) {
- super(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(Preconditions.checkNotNull(ribId))));
- this.domChain = domDataBroker.createTransactionChain(this);
- this.localAs = Preconditions.checkNotNull(localAs);
- this.bgpIdentifier = Preconditions.checkNotNull(localBgpId);
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ private final RibId ribId;
+ private final BGPPeerTracker peerTracker = new BGPPeerTrackerImpl();
+ private final BGPRibRoutingPolicy ribPolicies;
+ @GuardedBy("this")
+ private ClusterSingletonServiceRegistration registration;
+ @GuardedBy("this")
+ private DOMTransactionChain domChain;
+ @GuardedBy("this")
+ private boolean isServiceInstantiated;
+ private final Map<TablesKey, RibOutRefresh> vpnTableRefresher = new HashMap<>();
+
+ public RIBImpl(
+ final BGPTableTypeRegistryConsumer tableTypeRegistry,
+ final RibId ribId,
+ final AsNumber localAs,
+ final BgpId localBgpId,
+ final RIBExtensionConsumerContext extensions,
+ final BGPDispatcher dispatcher,
+ final CodecsRegistryImpl codecsRegistry,
+ final DOMDataBroker domDataBroker,
+ final DataBroker dataBroker,
+ final BGPRibRoutingPolicy ribPolicies,
+ final List<BgpTableType> localTables,
+ final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies
+ ) {
+ super(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(requireNonNull(ribId))),
+ localBgpId, localAs);
+ this.tableTypeRegistry = requireNonNull(tableTypeRegistry);
+ this.localAs = requireNonNull(localAs);
+ this.bgpIdentifier = requireNonNull(localBgpId);
+ this.dispatcher = requireNonNull(dispatcher);
this.localTables = ImmutableSet.copyOf(localTables);
this.localTablesKeys = new HashSet<>();
- this.dataBroker = dps;
- this.domDataBroker = Preconditions.checkNotNull(domDataBroker);
- this.extensions = Preconditions.checkNotNull(extensions);
- this.codecsRegistry = CodecsRegistryImpl.create(codecFactory, classStrategy);
+ this.domDataBroker = requireNonNull(domDataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.domService = this.domDataBroker.getExtensions().get(DOMDataTreeChangeService.class);
+ this.extensions = requireNonNull(extensions);
+ this.ribPolicies = requireNonNull(ribPolicies);
+ this.codecsRegistry = codecsRegistry;
this.ribContextRegistry = RIBSupportContextRegistryImpl.create(extensions, this.codecsRegistry);
- final InstanceIdentifierBuilder yangRibIdBuilder = YangInstanceIdentifier.builder().node(BgpRib.QNAME).node(Rib.QNAME);
- this.yangRibId = yangRibIdBuilder.nodeWithKey(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()).build();
- this.configModuleTracker = moduleTracker;
- this.openConfigProvider = openConfigProvider;
- this.cacheDisconnectedPeers = new CacheDisconnectedPeersImpl();
- this.bestPathSelectionStrategies = Preconditions.checkNotNull(bestPathSelectionStrategies);
-
- LOG.debug("Instantiating RIB table {} at {}", ribId, this.yangRibId);
-
- final ContainerNode bgpRib = Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(BgpRib.QNAME))
- .addChild(ImmutableNodes.mapNodeBuilder(Rib.QNAME).build()).build();
-
- final MapEntryNode ribInstance = Builders.mapEntryBuilder().withNodeIdentifier(
- new NodeIdentifierWithPredicates(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()))
- .addChild(ImmutableNodes.leafNode(RIB_ID_QNAME, ribId.getValue()))
- .addChild(ImmutableNodes.mapNodeBuilder(Peer.QNAME).build())
- .addChild(Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(LocRib.QNAME))
- .addChild(ImmutableNodes.mapNodeBuilder(Tables.QNAME).build())
- .build()).build();
-
-
- final DOMDataWriteTransaction trans = this.domChain.newWriteOnlyTransaction();
-
- // merge empty BgpRib + Rib, to make sure the top-level parent structure is present
- trans.merge(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.builder().node(BgpRib.QNAME).build(), bgpRib);
- trans.put(LogicalDatastoreType.OPERATIONAL, yangRibIdBuilder.build(), ribInstance);
-
- try {
- trans.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
- LOG.error("Failed to initiate RIB {}", this.yangRibId, e);
- }
- final ClusterIdentifier cId = (clusterId == null) ? new ClusterIdentifier(localBgpId) : new ClusterIdentifier(clusterId);
- final PolicyDatabase policyDatabase = new PolicyDatabase(localAs.getValue(), localBgpId, cId);
- this.importPolicyPeerTracker = new ImportPolicyPeerTracker(policyDatabase);
-
- final DOMDataBrokerExtension domDatatreeChangeService = this.domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
- this.service = domDatatreeChangeService;
- LOG.debug("Effective RIB created.");
+ this.yangRibId = YangInstanceIdentifier.builder().node(BGPRIB_NID).node(RIB_NID)
+ .nodeWithKey(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()).build();
+ this.bestPathSelectionStrategies = requireNonNull(bestPathSelectionStrategies);
+ this.ribId = ribId;
for (final BgpTableType t : this.localTables) {
final TablesKey key = new TablesKey(t.getAfi(), t.getSafi());
this.localTablesKeys.add(key);
- startLocRib(key, policyDatabase);
- }
-
- if (this.configModuleTracker != null) {
- this.configModuleTracker.onInstanceCreate();
}
}
- public RIBImpl(final RibId ribId, final AsNumber localAs, final BgpId localBgpId, final ClusterIdentifier clusterId, final RIBExtensionConsumerContext extensions,
- final BGPDispatcher dispatcher, final BindingCodecTreeFactory codecFactory,
- final DataBroker dps, final DOMDataBroker domDataBroker, final List<BgpTableType> localTables,
- final Map<TablesKey, PathSelectionMode> bestPathSelectionstrategies, final GeneratedClassLoadingStrategy classStrategy) {
- this(ribId, localAs, localBgpId, clusterId, extensions, dispatcher, codecFactory,
- dps, domDataBroker, localTables, bestPathSelectionstrategies, classStrategy, null, null);
- }
-
- private void startLocRib(final TablesKey key, final PolicyDatabase pd) {
+ private synchronized void startLocRib(final TablesKey key) {
LOG.debug("Creating LocRib table for {}", key);
// create locRibWriter for each table
- final DOMDataWriteTransaction tx = this.domChain.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction tx = this.domChain.newWriteOnlyTransaction();
- final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> table = ImmutableNodes.mapEntryBuilder();
- table.withNodeIdentifier(RibSupportUtils.toYangTablesKey(key));
- table.withChild(EMPTY_TABLE_ATTRIBUTES);
+ final RIBSupport<? extends Routes, ?, ?, ?> ribSupport = this.ribContextRegistry.getRIBSupport(key);
+ if (ribSupport != null) {
+ final MapEntryNode emptyTable = ribSupport.emptyTable();
+ final InstanceIdentifierBuilder tableId = YangInstanceIdentifier
+ .builder(this.yangRibId.node(LOCRIB_NID).node(TABLES_NID)).node(emptyTable.getIdentifier());
- final NodeIdentifierWithPredicates tableKey = RibSupportUtils.toYangTablesKey(key);
- final InstanceIdentifierBuilder tableId = YangInstanceIdentifier.builder(this.yangRibId.node(LocRib.QNAME).node(Tables.QNAME));
- tableId.nodeWithKey(tableKey.getNodeType(), tableKey.getKeyValues());
- for (final Entry<QName, Object> e : tableKey.getKeyValues().entrySet()) {
- table.withChild(ImmutableNodes.leafNode(e.getKey(), e.getValue()));
+ tx.put(LogicalDatastoreType.OPERATIONAL, tableId.build(), emptyTable);
+ try {
+ tx.commit().get();
+ } catch (final InterruptedException | ExecutionException e1) {
+ LOG.error("Failed to initiate LocRIB for key {}", key, e1);
+ }
+ } else {
+ LOG.warn("There's no registered RIB Context for {}", key.getAfi());
}
+ }
- final ChoiceNode routes = this.ribContextRegistry.getRIBSupportContext(key).getRibSupport().emptyRoutes();
- table.withChild(routes);
-
- tx.put(LogicalDatastoreType.OPERATIONAL, tableId.build(), table.build());
- try {
- tx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e1) {
- LOG.error("Failed to initiate LocRIB for key {}", key, e1);
+ private synchronized <C extends Routes & DataObject & ChoiceIn<Tables>, S extends ChildOf<? super C>,
+ R extends Route & ChildOf<? super S> & Identifiable<I>, I extends Identifier<R>>
+ void createLocRibWriter(final TablesKey key) {
+ final RIBSupport<C, S, R, I> ribSupport = this.ribContextRegistry.getRIBSupport(key);
+ if (ribSupport == null) {
+ return;
}
-
+ LOG.debug("Creating LocRIB writer for key {}", key);
+ final TransactionChain txChain = createPeerChain(this);
PathSelectionMode pathSelectionStrategy = this.bestPathSelectionStrategies.get(key);
if (pathSelectionStrategy == null) {
pathSelectionStrategy = BasePathSelectionModeFactory.createBestPathSelectionStrategy();
}
- this.locRibs.add(LocRibWriter.create(this.ribContextRegistry, key, createPeerChain(this), getYangRibId(), this.localAs, getService(), pd,
- this.cacheDisconnectedPeers, pathSelectionStrategy));
+
+ final LocRibWriter<C, S, R, I> locRibWriter = LocRibWriter.create(
+ ribSupport,
+ this.tableTypeRegistry.getAfiSafiType(key).get(),
+ txChain,
+ getInstanceIdentifier(),
+ this.localAs,
+ getDataBroker(),
+ this.ribPolicies,
+ this.peerTracker,
+ pathSelectionStrategy);
+ this.vpnTableRefresher.put(key, locRibWriter);
+ registerTotalPathCounter(key, locRibWriter);
+ registerTotalPrefixesCounter(key, locRibWriter);
+ this.txChainToLocRibWriter.put(txChain, locRibWriter);
}
@Override
public String toString() {
- return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
- }
-
- protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return toStringHelper;
+ return MoreObjects.toStringHelper(this).add("bgpId", bgpIdentifier).add("localTables", localTables).toString();
}
@Override
- public synchronized void close() throws InterruptedException, ExecutionException {
- final DOMDataWriteTransaction t = this.domChain.newWriteOnlyTransaction();
- t.delete(LogicalDatastoreType.OPERATIONAL, getYangRibId());
- t.submit().get();
- this.domChain.close();
- for (final LocRibWriter locRib : this.locRibs) {
- try {
- locRib.close();
- } catch (final Exception e) {
- LOG.warn("Could not close LocalRib reference: {}", locRib, e);
- }
- }
- if (this.configModuleTracker != null) {
- this.configModuleTracker.onInstanceClose();
+ public synchronized void close() {
+ if (this.registration != null) {
+ this.registration.close();
+ this.registration = null;
}
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain in RIB {} transaction {}", getInstanceIdentifier(), transaction != null ? transaction.getIdentifier() : null, cause);
+ public synchronized void onTransactionChainFailed(final TransactionChain chain,
+ final Transaction transaction, final Throwable cause) {
+ LOG.error("Broken chain in RIB {} transaction {}",
+ getInstanceIdentifier(), transaction != null ? transaction.getIdentifier() : null, cause);
+ if (this.txChainToLocRibWriter.containsKey(chain)) {
+ final LocRibWriter locRibWriter = this.txChainToLocRibWriter.remove(chain);
+ final TransactionChain newChain = createPeerChain(this);
+ startLocRib(locRibWriter.getTableKey());
+ locRibWriter.restart(newChain);
+ this.txChainToLocRibWriter.put(newChain, locRibWriter);
+ }
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
- LOG.info("RIB {} closed successfully", getInstanceIdentifier());
+ public synchronized void onTransactionChainFailed(final DOMTransactionChain chain,
+ final DOMDataTreeTransaction transaction, final Throwable cause) {
+ LOG.error("Broken chain in RIB {} transaction {}",
+ getInstanceIdentifier(), transaction != null ? transaction.getIdentifier() : null, cause);
}
@Override
- public long getRoutesCount(final TablesKey key) {
- try (final ReadOnlyTransaction tx = this.dataBroker.newReadOnlyTransaction()) {
- final Optional<Tables> tableMaybe = tx.read(LogicalDatastoreType.OPERATIONAL,
- getInstanceIdentifier().child(LocRib.class).child(Tables.class, key)).checkedGet();
- if (tableMaybe.isPresent()) {
- final Tables table = tableMaybe.get();
- return countIpRoutes(table.getRoutes());
- }
- } catch (final ReadFailedException e) {
- LOG.debug("Failed to read tables", e);
- }
- return 0;
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
+ LOG.info("RIB {} closed successfully", getInstanceIdentifier());
}
- private int countIpRoutes(final Routes routes) {
- if (routes instanceof Ipv4RoutesCase) {
- final Ipv4RoutesCase routesCase = (Ipv4RoutesCase) routes;
- if (routesCase.getIpv4Routes() != null && routesCase.getIpv4Routes().getIpv4Route() != null) {
- return routesCase.getIpv4Routes().getIpv4Route().size();
- }
- } else if (routes instanceof Ipv6RoutesCase) {
- final Ipv6RoutesCase routesCase = (Ipv6RoutesCase) routes;
- if (routesCase.getIpv6Routes() != null && routesCase.getIpv6Routes().getIpv6Route() != null) {
- return routesCase.getIpv6Routes().getIpv6Route().size();
- }
- }
- return 0;
+ @Override
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
+ LOG.info("RIB {} closed successfully", getInstanceIdentifier());
}
+ @Override
public Set<TablesKey> getLocalTablesKeys() {
return this.localTablesKeys;
}
+ @Override
+ public boolean supportsTable(final TablesKey tableKey) {
+ return this.localTablesKeys.contains(tableKey);
+ }
+
+ @Override
+ public BGPRibRoutingPolicy getRibPolicies() {
+ return this.ribPolicies;
+ }
+
+ @Override
+ public BGPPeerTracker getPeerTracker() {
+ return this.peerTracker;
+ }
+
+ @Override
+ public void refreshTable(final TablesKey tk, final PeerId peerId) {
+ final RibOutRefresh table = this.vpnTableRefresher.get(tk);
+ if (table != null) {
+ table.refreshTable(tk, peerId);
+ }
+ }
+
@Override
public DOMDataTreeChangeService getService() {
- return (DOMDataTreeChangeService) this.service;
+ return (DOMDataTreeChangeService) this.domService;
+ }
+
+ @Override
+ public DataBroker getDataBroker() {
+ return this.dataBroker;
}
@Override
}
@Override
- public DOMTransactionChain createPeerChain(final TransactionChainListener listener) {
- return this.domDataBroker.createTransactionChain(listener);
+ public TransactionChain createPeerChain(final TransactionChainListener listener) {
+ return this.dataBroker.createMergingTransactionChain(listener);
+ }
+
+ @Override
+ public DOMTransactionChain createPeerDOMChain(final DOMTransactionChainListener listener) {
+ return this.domDataBroker.createMergingTransactionChain(listener);
}
@Override
return this.codecsRegistry;
}
- @Override
- public Optional<BGPOpenConfigProvider> getOpenConfigProvider() {
- return Optional.fromNullable(this.openConfigProvider);
- }
+ public synchronized void instantiateServiceInstance() {
+ this.isServiceInstantiated = true;
+ setActive(true);
+ this.domChain = this.domDataBroker.createMergingTransactionChain(this);
+ LOG.debug("Instantiating RIB table {} at {}", this.ribId, this.yangRibId);
- @Override
- public CacheDisconnectedPeers getCacheDisconnectedPeers() {
- return this.cacheDisconnectedPeers;
+ final ContainerNode bgpRib = Builders.containerBuilder().withNodeIdentifier(BGPRIB_NID)
+ .addChild(ImmutableNodes.mapNodeBuilder(RIB_NID).build()).build();
+
+ final MapEntryNode ribInstance = Builders.mapEntryBuilder().withNodeIdentifier(
+ NodeIdentifierWithPredicates.of(Rib.QNAME, RIB_ID_QNAME, this.ribId.getValue()))
+ .addChild(ImmutableNodes.leafNode(RIB_ID_QNAME, this.ribId.getValue()))
+ .addChild(ImmutableNodes.mapNodeBuilder(PEER_NID).build())
+ .addChild(Builders.containerBuilder().withNodeIdentifier(LOCRIB_NID)
+ .addChild(ImmutableNodes.mapNodeBuilder(TABLES_NID).build())
+ .build()).build();
+
+ final DOMDataTreeWriteTransaction trans = this.domChain.newWriteOnlyTransaction();
+
+ // merge empty BgpRib + Rib, to make sure the top-level parent structure is present
+ trans.merge(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(BGPRIB_NID), bgpRib);
+ trans.put(LogicalDatastoreType.OPERATIONAL, this.yangRibId, ribInstance);
+
+ try {
+ trans.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
+ LOG.error("Failed to initiate RIB {}", this.yangRibId, e);
+ }
+
+ LOG.debug("Effective RIB created.");
+
+ this.localTablesKeys.forEach(this::startLocRib);
+ this.localTablesKeys.forEach(this::createLocRibWriter);
}
- public ImportPolicyPeerTracker getImportPolicyPeerTracker() {
- return this.importPolicyPeerTracker;
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
+ if (!this.isServiceInstantiated) {
+ LOG.trace("RIB {} already closed", this.ribId.getValue());
+ return CommitInfo.emptyFluentFuture();
+ }
+ LOG.info("Close RIB {}", this.ribId.getValue());
+ this.isServiceInstantiated = false;
+ setActive(false);
+
+ this.txChainToLocRibWriter.values().forEach(LocRibWriter::close);
+ this.txChainToLocRibWriter.clear();
+
+ final DOMDataTreeWriteTransaction t = this.domChain.newWriteOnlyTransaction();
+ t.delete(LogicalDatastoreType.OPERATIONAL, getYangRibId());
+ final FluentFuture<? extends CommitInfo> cleanFuture = t.commit();
+ cleanFuture.addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.info("RIB cleaned {}", RIBImpl.this.ribId.getValue());
+ }
+
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to clean RIB {}",
+ RIBImpl.this.ribId.getValue(), throwable);
+ }
+ }, MoreExecutors.directExecutor());
+ this.domChain.close();
+ return cleanFuture;
}
}