import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
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.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
+import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPConfigModuleTracker;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
+import org.opendaylight.protocol.bgp.rib.impl.stats.peer.BGPPeerStats;
+import org.opendaylight.protocol.bgp.rib.impl.stats.peer.BGPPeerStatsImpl;
+import org.opendaylight.protocol.bgp.rib.spi.ExportPolicyPeerTracker;
+import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils;
+import org.opendaylight.protocol.bgp.rib.spi.RibSupportUtils;
+import org.opendaylight.protocol.bgp.rib.spi.RouterIds;
+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.rib.rev130925.ApplicationRibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.SimpleRoutingPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.Peer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.rib.peer.AdjRibIn;
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.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
* For purposed of import policies such as Best Path Selection, application
* peer needs to have a BGP-ID that is configurable.
*/
-public class ApplicationPeer implements AutoCloseable, org.opendaylight.protocol.bgp.rib.spi.Peer, DOMDataTreeChangeListener, TransactionChainListener {
+public class ApplicationPeer implements org.opendaylight.protocol.bgp.rib.spi.Peer, ClusteredDOMDataTreeChangeListener, TransactionChainListener {
private static final Logger LOG = LoggerFactory.getLogger(ApplicationPeer.class);
private final byte[] rawIdentifier;
- private final RIBImpl targetRib;
private final String name;
private final YangInstanceIdentifier adjRibsInId;
- private final DOMTransactionChain chain;
- private final DOMTransactionChain writerChain;
+ private final Ipv4Address ipAddress;
private final BGPConfigModuleTracker moduleTracker;
+ private final RIB rib;
+ private final YangInstanceIdentifier peerIId;
+ private DOMTransactionChain chain;
+ private DOMTransactionChain writerChain;
+ private EffectiveRibInWriter effectiveRibInWriter;
+ private AdjRibInWriter adjRibInWriter;
+ private BGPPeerStats peerStats;
+ private ListenerRegistration<ApplicationPeer> registration;
+ private final Set<NodeIdentifierWithPredicates> supportedTables = new HashSet<>();
- private AdjRibInWriter writer;
- public ApplicationPeer(final ApplicationRibId applicationRibId, final Ipv4Address ipAddress, final RIBImpl targetRib, final BGPConfigModuleTracker moduleTracker) {
- this.name = applicationRibId.getValue().toString();
- this.targetRib = Preconditions.checkNotNull(targetRib);
+ @FunctionalInterface
+ interface RegisterAppPeerListener {
+ /**
+ * Register Application Peer Change Listener once AdjRibIn has been successfully initialized.
+ */
+ void register();
+ }
+
+ public ApplicationPeer(final ApplicationRibId applicationRibId, final Ipv4Address ipAddress, final RIB rib,
+ final BGPConfigModuleTracker moduleTracker) {
+ this.name = applicationRibId.getValue();
+ final RIB targetRib = Preconditions.checkNotNull(rib);
this.rawIdentifier = InetAddresses.forString(ipAddress.getValue()).getAddress();
final NodeIdentifierWithPredicates peerId = IdentifierUtils.domPeerId(RouterIds.createPeerId(ipAddress));
- this.adjRibsInId = this.targetRib.getYangRibId().node(Peer.QNAME).node(peerId).node(AdjRibIn.QNAME).node(Tables.QNAME);
- this.chain = this.targetRib.createPeerChain(this);
- this.writerChain = this.targetRib.createPeerChain(this);
- this.writer = AdjRibInWriter.create(this.targetRib.getYangRibId(), PeerRole.Internal, this.writerChain);
- this.writer = this.writer.transform(RouterIds.createPeerId(ipAddress), this.targetRib.getRibSupportContext(), this.targetRib.getLocalTablesKeys(), true);
+ this.peerIId = targetRib.getYangRibId().node(Peer.QNAME).node(peerId);
+ this.adjRibsInId = this.peerIId.node(AdjRibIn.QNAME).node(Tables.QNAME);
+ this.rib = targetRib;
+ this.ipAddress = ipAddress;
this.moduleTracker = moduleTracker;
- if (moduleTracker != null) {
- moduleTracker.onInstanceCreate();
- }
}
- public ApplicationPeer(final ApplicationRibId applicationRibId, final Ipv4Address bgpPeerId, final RIBImpl targetRibDependency) {
+ public ApplicationPeer(final ApplicationRibId applicationRibId, final Ipv4Address bgpPeerId, final RIB targetRibDependency) {
this(applicationRibId, bgpPeerId, targetRibDependency, null);
}
+ public synchronized void instantiateServiceInstance(final DOMDataTreeChangeService dataTreeChangeService,
+ final DOMDataTreeIdentifier appPeerDOMId) {
+ this.chain = this.rib.createPeerChain(this);
+ this.writerChain = this.rib.createPeerChain(this);
+
+ final Optional<SimpleRoutingPolicy> simpleRoutingPolicy = Optional.of(SimpleRoutingPolicy.AnnounceNone);
+ final PeerId peerId = RouterIds.createPeerId(this.ipAddress);
+ final Set<TablesKey> localTables = this.rib.getLocalTablesKeys();
+ localTables.forEach(tablesKey -> {
+ final ExportPolicyPeerTracker exportTracker = this.rib.getExportPolicyPeerTracker(tablesKey);
+ if (exportTracker != null) {
+ exportTracker.registerPeer(peerId, null, this.peerIId, PeerRole.Internal, simpleRoutingPolicy);
+ }
+ this.supportedTables.add(RibSupportUtils.toYangTablesKey(tablesKey));
+ });
+
+ this.adjRibInWriter = AdjRibInWriter.create(this.rib.getYangRibId(), PeerRole.Internal, simpleRoutingPolicy, this.writerChain);
+ final RIBSupportContextRegistry context = this.rib.getRibSupportContext();
+ final RegisterAppPeerListener registerAppPeerListener = () -> {
+ synchronized (this) {
+ if(this.chain != null) {
+ this.registration = dataTreeChangeService.registerDataTreeChangeListener(appPeerDOMId, this);
+ }
+ }
+ };
+ this.adjRibInWriter = this.adjRibInWriter.transform(peerId, context, localTables, Collections.emptyMap(),
+ registerAppPeerListener);
+ this.peerStats = new BGPPeerStatsImpl(this.name, localTables);
+ this.effectiveRibInWriter = EffectiveRibInWriter.create(this.rib.getService(), this.rib.createPeerChain(this), this.peerIId,
+ this.rib.getImportPolicyPeerTracker(), context, PeerRole.Internal, this.peerStats.getEffectiveRibInRouteCounters(),
+ this.peerStats.getAdjRibInRouteCounters());
+ if (moduleTracker != null) {
+ moduleTracker.onInstanceCreate();
+ }
+ }
+
/**
* Routes come from application RIB that is identified by (configurable) name.
* Each route is pushed into AdjRibsInWriter with it's whole context. In this
* be determined in LocRib.
*/
@Override
- public void onDataTreeChanged(final Collection<DataTreeCandidate> changes) {
+ public synchronized void onDataTreeChanged(final Collection<DataTreeCandidate> changes) {
+ if(this.chain == null) {
+ LOG.trace("Skipping data changed called to Application Peer. Change : {}", changes);
+ return;
+ }
final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
LOG.debug("Received data change to ApplicationRib {}", changes);
for (final DataTreeCandidate tc : changes) {
final PathArgument lastArg = path.getLastPathArgument();
Verify.verify(lastArg instanceof NodeIdentifierWithPredicates, "Unexpected type %s in path %s", lastArg.getClass(), path);
final NodeIdentifierWithPredicates tableKey = (NodeIdentifierWithPredicates) lastArg;
+ if (!this.supportedTables.contains(tableKey)) {
+ LOG.trace("Skipping received data change for non supported family {}.", tableKey);
+ continue;
+ }
for (final DataTreeCandidateNode child : tc.getRootNode().getChildNodes()) {
final PathArgument childIdentifier = child.getIdentifier();
final YangInstanceIdentifier tableId = this.adjRibsInId.node(tableKey).node(childIdentifier);
* @param tx
* @param routeTableIdentifier
*/
- private void processRoutesTable(final DataTreeCandidateNode node, final YangInstanceIdentifier identifier,
- final DOMDataWriteTransaction tx, final YangInstanceIdentifier routeTableIdentifier) {
+ private synchronized void processRoutesTable(final DataTreeCandidateNode node, final YangInstanceIdentifier identifier,
+ final DOMDataWriteTransaction tx, final YangInstanceIdentifier routeTableIdentifier) {
for (final DataTreeCandidateNode child : node.getChildNodes()) {
final YangInstanceIdentifier childIdentifier = identifier.node(child.getIdentifier());
switch (child.getModificationType()) {
return this.name;
}
+ // FIXME ListenableFuture<?> should be used once closeServiceInstance uses wildcard too
@Override
- public void close() {
- this.writer.removePeer();
- this.chain.close();
- this.writerChain.close();
+ public synchronized ListenableFuture<Void> close() {
+ if (this.registration != null) {
+ this.registration.close();
+ this.registration = null;
+ }
+ if (this.effectiveRibInWriter != null) {
+ this.effectiveRibInWriter.close();
+ }
+ final ListenableFuture<Void> future;
+ if (this.adjRibInWriter != null) {
+ future = this.adjRibInWriter.removePeer();
+ }else {
+ future = Futures.immediateFuture(null);
+ }
+ if (this.chain != null) {
+ this.chain.close();
+ this.chain = null;
+ }
+ if (this.writerChain != null) {
+ this.writerChain.close();
+ this.writerChain = null;
+ }
if (this.moduleTracker != null) {
this.moduleTracker.onInstanceClose();
}
+ return future;
}
@Override
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction,
- final Throwable cause) {
- LOG.error("Transaction chain failed.", cause);
+ public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
+ final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ LOG.error("Transaction chain {} failed.", transaction != null ? transaction.getIdentifier() : null, cause);
}
@Override
public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
- LOG.debug("Transaction chain {} successfull.", chain);
+ LOG.debug("Transaction chain {} successful.", chain);
}
}