import java.util.concurrent.TimeUnit;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-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.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.Rpc;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class AppPeerBenchmark implements TransactionChainListener, AutoCloseable {
+public final class AppPeerBenchmark implements FutureCallback<Empty>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(AppPeerBenchmark.class);
public AppPeerBenchmark(final DataBroker bindingDataBroker, final RpcProviderService rpcProviderRegistry,
final String appRibId) {
this.appRibId = requireNonNull(appRibId);
- txChain = bindingDataBroker.createMergingTransactionChain(this);
+ txChain = bindingDataBroker.createMergingTransactionChain();
+ txChain.addCallback(this);
appIID = InstanceIdentifier.builder(ApplicationRib.class,
new ApplicationRibKey(new ApplicationRibId(appRibId))).build();
}
@Override
- public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
- final Throwable cause) {
- LOG.error("Broken chain {} in DatastoreBaAbstractWrite, transaction {}", chain, transaction.getIdentifier(),
- cause);
+ public void onFailure(final Throwable cause) {
+ LOG.error("Broken chain in DatastoreBaAbstractWrite", cause);
close();
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain chain) {
- LOG.debug("DatastoreBaAbstractWrite closed successfully, chain {}", chain);
+ public void onSuccess(final Empty result) {
+ LOG.debug("DatastoreBaAbstractWrite closed successfully");
}
@VisibleForTesting
<name>${project.artifactId}</name>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.kohsuke.metainf-services</groupId>
+ <artifactId>metainf-services</artifactId>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgp-mvpn</artifactId>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-rfc8294-netty</artifactId>
</dependency>
- <dependency>
- <groupId>org.kohsuke.metainf-services</groupId>
- <artifactId>metainf-services</artifactId>
- </dependency>
- <dependency>
- <groupId>com.guicedee.services</groupId>
- <artifactId>javax.inject</artifactId>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.service.component.annotations</artifactId>
<name>${project.artifactId}</name>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.kohsuke.metainf-services</groupId>
+ <artifactId>metainf-services</artifactId>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgp-inet</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common-netty</artifactId>
</dependency>
- <dependency>
- <groupId>org.kohsuke.metainf-services</groupId>
- <artifactId>metainf-services</artifactId>
- </dependency>
- <dependency>
- <groupId>com.guicedee.services</groupId>
- <artifactId>javax.inject</artifactId>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.service.component.annotations</artifactId>
<name>${project.artifactId}</name>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>org.kohsuke.metainf-services</groupId>
+ <artifactId>metainf-services</artifactId>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgp-parser-impl</artifactId>
<groupId>org.opendaylight.mdsal.model</groupId>
<artifactId>yang-ext</artifactId>
</dependency>
- <dependency>
- <groupId>org.kohsuke.metainf-services</groupId>
- <artifactId>metainf-services</artifactId>
- </dependency>
- <dependency>
- <groupId>com.guicedee.services</groupId>
- <artifactId>javax.inject</artifactId>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.service.component.annotations</artifactId>
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
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.binding.api.WriteOperations;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.RibKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
@Component(service = {})
@Designate(ocd = StateProviderImpl.Configuration.class)
@RequireServiceComponentRuntime
-public final class StateProviderImpl implements TransactionChainListener, AutoCloseable {
+public final class StateProviderImpl implements FutureCallback<Empty>, AutoCloseable {
@ObjectClassDefinition
public @interface Configuration {
@AttributeDefinition(description = "Name of the OpenConfig network instance to which to bind")
.child(NetworkInstance.class, new NetworkInstanceKey(networkInstanceName));
this.scheduler = scheduler;
- transactionChain = this.dataBroker.createMergingTransactionChain(this);
+ transactionChain = this.dataBroker.createMergingTransactionChain();
+ transactionChain.addCallback(this);
final TimerTask task = new TimerTask() {
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
}
@Override
- public synchronized void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
- final Throwable cause) {
- LOG.error("Transaction chain {} failed for tx {}",
- chain, transaction != null ? transaction.getIdentifier() : null, cause);
+ public synchronized void onFailure(final Throwable cause) {
+ LOG.error("Transaction chain failed", cause);
if (!closed.get()) {
transactionChain.close();
- transactionChain = dataBroker.createMergingTransactionChain(this);
+ transactionChain = dataBroker.createMergingTransactionChain();
+ transactionChain.addCallback(this);
}
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain chain) {
- LOG.debug("Transaction chain {} successful.", chain);
+ public void onSuccess(final Empty result) {
+ LOG.debug("Transaction chain successfu.");
}
}
public DOMStore createOperationalDatastore() {
realOperStore = new InMemoryDOMDataStore("OPER", getDataTreeChangeListenerExecutor());
spiedOperStore = spy(realOperStore);
- getSchemaService().registerSchemaContextListener(spiedOperStore);
+ getSchemaService().registerSchemaContextListener(spiedOperStore::onModelContextUpdated);
return spiedOperStore;
}
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteOperations;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.mode.impl.BGPRouteEntryExportParametersImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.PeerTransactionChain;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
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.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.slf4j.LoggerFactory;
abstract class AbstractPeer extends BGPPeerStateImpl implements BGPRouteEntryImportParameters, Peer,
- PeerTransactionChain, DOMTransactionChainListener {
+ PeerTransactionChain, FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractPeer.class);
final RTCClientRouteCache rtCache = new RTCClientRouteCache();
}
@Override
- public final void onTransactionChainSuccessful(final DOMTransactionChain chain) {
- LOG.debug("Transaction chain {} successful.", chain);
+ public final void onSuccess(final Empty value) {
+ LOG.debug("Transaction chain successful");
}
@Override
final synchronized void createDomChain() {
if (domChain == null) {
LOG.info("Creating DOM peer chain {}", getPeerId());
- domChain = rib.createPeerDOMChain(this);
+ domChain = rib.createPeerDOMChain();
+ domChain.addCallback(this);
}
}
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.protocol.bgp.rib.impl.spi.Codecs;
import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.update.message.NlriBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.update.message.WithdrawnRoutesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* Instantiated for each peer and table, listens on a particular peer's adj-rib-out, performs transcoding to BA form
* (message) and sends it down the channel. This class is NOT thread-safe.
*/
-final class AdjRibOutListener implements ClusteredDOMDataTreeChangeListener, PrefixesSentCounters {
+final class AdjRibOutListener implements DOMDataTreeChangeListener, PrefixesSentCounters {
private static final Logger LOG = LoggerFactory.getLogger(AdjRibOutListener.class);
private static final QName PREFIX_QNAME = QName.create(Ipv4Route.QNAME, "prefix").intern();
private static final QName PATHID_QNAME = QName.create(Ipv4Route.QNAME, "path-id").intern();
private final RIBSupport<?, ?> support;
// FIXME: this field needs to be eliminated: either subclass this class or create a filtering ribsupport
private final boolean mpSupport;
- private final ListenerRegistration<AdjRibOutListener> registerDataTreeChangeListener;
+ private final Registration registerDataTreeChangeListener;
private final LongAdder prefixesSentCounter = new LongAdder();
private boolean initalState;
private AdjRibOutListener(final PeerId peerId, final YangInstanceIdentifier ribId, final CodecsRegistry registry,
- final RIBSupport<?, ?> support, final DOMDataTreeChangeService service, final ChannelOutputLimiter session,
+ final RIBSupport<?, ?> support, final DataTreeChangeExtension service, final ChannelOutputLimiter session,
final boolean mpSupport) {
this.session = requireNonNull(session);
this.support = requireNonNull(support);
* send EOR marker. initialState flag is distinguishing between first ODTC execution and the rest.
*/
initalState = true;
- registerDataTreeChangeListener = service.registerDataTreeChangeListener(
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, adjRibOutId), this);
+ registerDataTreeChangeListener = service.registerTreeChangeListener(
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, adjRibOutId), this);
}
static AdjRibOutListener create(
final @NonNull YangInstanceIdentifier ribId,
final @NonNull CodecsRegistry registry,
final @NonNull RIBSupport<?, ?> support,
- final @NonNull DOMDataTreeChangeService service,
+ final @NonNull DataTreeChangeExtension service,
final @NonNull ChannelOutputLimiter session,
final boolean mpSupport) {
return new AdjRibOutListener(peerId, ribId, registry, support, service, session, mpSupport);
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerRole;
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.types.rev200120.RouteTarget;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
private final BGPTableTypeRegistryConsumer tableTypeRegistry;
private EffectiveRibInWriter effectiveRibInWriter;
private AdjRibInWriter adjRibInWriter;
- private ListenerRegistration<ApplicationPeer> registration;
+ private Registration registration;
private final Set<NodeIdentifierWithPredicates> supportedTables = new HashSet<>();
private final BGPSessionStateImpl bgpSessionState = new BGPSessionStateImpl();
private Registration trackerRegistration;
peerRibOutIId = peerRib.node(ADJRIBOUT_NID).node(TABLES_NID).toOptimized();
}
- public synchronized void instantiateServiceInstance(final DOMDataTreeChangeService dataTreeChangeService,
+ public synchronized void instantiateServiceInstance(final DataTreeChangeExtension dataTreeChangeService,
final DOMDataTreeIdentifier appPeerDOMId) {
setActive(true);
final var localTables = rib.getLocalTablesKeys();
final RegisterAppPeerListener registerAppPeerListener = () -> {
synchronized (this) {
if (getDomChain() != null) {
- registration = dataTreeChangeService.registerDataTreeChangeListener(appPeerDOMId, this);
+ registration = dataTreeChangeService.registerTreeChangeListener(appPeerDOMId, this);
}
}
};
peerPath = createPeerPath(peerId);
adjRibInWriter = adjRibInWriter.transform(peerId, peerPath, context, localTables,
Map.of(), registerAppPeerListener);
- effectiveRibInWriter = new EffectiveRibInWriter(this, rib,
- rib.createPeerDOMChain(this), peerPath, localTables, tableTypeRegistry,
- new ArrayList<>(), rtCache);
+
+ final var chain = rib.createPeerDOMChain();
+ chain.addCallback(this);
+
+ effectiveRibInWriter = new EffectiveRibInWriter(this, rib, chain, peerPath, localTables, tableTypeRegistry,
+ new ArrayList<>(), rtCache);
effectiveRibInWriter.init();
bgpSessionState.registerMessagesCounter(this);
trackerRegistration = rib.getPeerTracker().registerPeer(this);
}
@Override
- public void onTransactionChainFailed(final DOMTransactionChain chain, final DOMDataTreeTransaction transaction,
- final Throwable cause) {
- LOG.error("Transaction chain {} failed.", transaction != null ? transaction.getIdentifier() : null, cause);
+ public void onFailure(final Throwable cause) {
+ LOG.error("Transaction chain failed.", cause);
}
@Override
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPError;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.Rpc;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.slf4j.Logger;
currentSession = session;
sessionUp = true;
- ribOutChain = rib.createPeerDOMChain(new DOMTransactionChainListener() {
+ final var chain = rib.createPeerDOMChain();
+ ribOutChain = chain;
+ chain.addCallback(new FutureCallback<Empty>() {
@Override
- public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
+ public void onSuccess(final Empty result) {
LOG.debug("RibOut transaction chain {} successful.", chain);
}
@Override
- public void onTransactionChainFailed(final DOMTransactionChain chain,
- final DOMDataTreeTransaction transaction, final Throwable cause) {
+ public void onFailure(final Throwable cause) {
onRibOutChainFailed(cause);
}
});
}
private synchronized void createEffRibInWriter() {
- effRibInWriter = new EffectiveRibInWriter(this, rib,
- rib.createPeerDOMChain(this),
- peerPath, tables, tableTypeRegistry,
- rtMemberships,
+ final var chain = rib.createPeerDOMChain();
+ chain.addCallback(this);
+
+ effRibInWriter = new EffectiveRibInWriter(this, rib, chain, peerPath, tables, tableTypeRegistry, rtMemberships,
rtCache);
}
}
@Override
- public synchronized void onTransactionChainFailed(final DOMTransactionChain chain,
- final DOMDataTreeTransaction transaction, final Throwable cause) {
+ public synchronized void onFailure(final Throwable cause) {
LOG.error("Transaction domChain failed.", cause);
releaseConnection(true);
}
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv6AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.MplsLabeledVpnSubsequentAddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.RouteTarget;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
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;
* This class is NOT thread-safe.
*/
final class EffectiveRibInWriter implements PrefixesReceivedCounters, PrefixesInstalledCounters,
- AutoCloseable, ClusteredDOMDataTreeChangeListener {
-
+ AutoCloseable, DOMDataTreeChangeListener {
private static final Logger LOG = LoggerFactory.getLogger(EffectiveRibInWriter.class);
private static final TablesKey IVP4_VPN_TABLE_KEY =
new TablesKey(Ipv4AddressFamily.VALUE, MplsLabeledVpnSubsequentAddressFamily.VALUE);
private final RIBSupportContextRegistry registry;
private final YangInstanceIdentifier peerIId;
private final YangInstanceIdentifier effRibTables;
- private final DOMDataTreeChangeService service;
+ private final DataTreeChangeExtension service;
private final List<RouteTarget> rtMemberships;
private final RibOutRefresh vpnTableRefresher;
private final ClientRouteTargetContrainCache rtCache;
- private ListenerRegistration<?> reg;
+ private Registration reg;
private DOMTransactionChain chain;
private final Map<TablesKey, LongAdder> prefixesReceived;
private final Map<TablesKey, LongAdder> prefixesInstalled;
}
public void init() {
- final DOMDataTreeIdentifier treeId = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
+ final DOMDataTreeIdentifier treeId = DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
peerIId.node(ADJRIBIN_NID).node(TABLES_NID));
LOG.debug("Registered Effective RIB on {}", peerIId);
- reg = requireNonNull(service).registerDataTreeChangeListener(treeId, this);
+ reg = requireNonNull(service).registerTreeChangeListener(treeId, this);
}
private static Map<TablesKey, LongAdder> buildPrefixesTables(final Set<TablesKey> tables) {
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteOperations;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
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.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
// This class is NOT thread-safe
final class LocRibWriter<C extends Routes & DataObject & ChoiceIn<Tables>, S extends ChildOf<? super C>>
- implements AutoCloseable, RibOutRefresh, TotalPrefixesCounter, TotalPathsCounter,
- ClusteredDOMDataTreeChangeListener {
+ implements AutoCloseable, RibOutRefresh, TotalPrefixesCounter, TotalPathsCounter, DOMDataTreeChangeListener {
private static final Logger LOG = LoggerFactory.getLogger(LocRibWriter.class);
private final Map<String, RouteEntry<C, S>> routeEntries = new HashMap<>();
private final long ourAs;
private final RIBSupport<C, S> ribSupport;
- private final DOMDataTreeChangeService dataBroker;
+ private final DataTreeChangeExtension dataBroker;
private final PathSelectionMode pathSelectionMode;
private final LongAdder totalPathsCounter = new LongAdder();
private final LongAdder totalPrefixesCounter = new LongAdder();
private DOMTransactionChain chain;
@GuardedBy("this")
- private ListenerRegistration<?> reg;
+ private Registration reg;
private LocRibWriter(final RIBSupport<C, S> ribSupport,
final DOMTransactionChain chain,
final YangInstanceIdentifier ribIId,
final Uint32 ourAs,
- final DOMDataTreeChangeService dataBroker,
+ final DataTreeChangeExtension dataBroker,
final BGPRibRoutingPolicy ribPolicies,
final BGPPeerTracker peerTracker,
final AfiSafiType afiSafiType,
final @NonNull DOMTransactionChain chain,
final @NonNull YangInstanceIdentifier ribIId,
final @NonNull AsNumber ourAs,
- final @NonNull DOMDataTreeChangeService dataBroker,
+ final @NonNull DataTreeChangeExtension dataBroker,
final BGPRibRoutingPolicy ribPolicies,
final @NonNull BGPPeerTracker peerTracker,
final @NonNull PathSelectionMode pathSelectionStrategy) {
}
}, MoreExecutors.directExecutor());
- reg = dataBroker.registerDataTreeChangeListener(new DOMDataTreeIdentifier(
+ reg = dataBroker.registerTreeChangeListener(DOMDataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, ribIId.node(PEER_NID).node(PEER_NID).node(EFFRIBIN_NID).node(TABLES_NID)
.node(locRibTableIID.getLastPathArgument())), this);
}
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.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
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.slf4j.LoggerFactory;
// This class is thread-safe
-public final class RIBImpl extends BGPRibStateImpl implements RIB, DOMTransactionChainListener {
+public final class RIBImpl extends BGPRibStateImpl implements RIB {
private static final Logger LOG = LoggerFactory.getLogger(RIBImpl.class);
private static final QName RIB_ID_QNAME = QName.create(Rib.QNAME, "id").intern();
private final RIBSupportContextRegistryImpl ribContextRegistry;
private final CodecsRegistry codecsRegistry;
private final BGPTableTypeRegistryConsumer tableTypeRegistry;
- private final DOMDataBrokerExtension domService;
+ private final DataTreeChangeExtension domService;
private final Map<DOMTransactionChain, LocRibWriter<?, ?>> txChainToLocRibWriter = new HashMap<>();
private final Map<TablesKey, RibOutRefresh> vpnTableRefresher = new HashMap<>();
private final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies;
.collect(Collectors.toCollection(HashSet::new));
this.domDataBroker = requireNonNull(domDataBroker);
- domService = domDataBroker.getExtensions().get(DOMDataTreeChangeService.class);
+ domService = domDataBroker.extension(DataTreeChangeExtension.class);
this.extensions = requireNonNull(extensions);
this.ribPolicies = requireNonNull(ribPolicies);
this.codecsRegistry = codecsRegistry;
return;
}
LOG.debug("Creating LocRIB writer for key {}", key);
- final DOMTransactionChain txChain = createPeerDOMChain(this);
+ final DOMTransactionChain txChain = createPeerDOMChain();
+ addCallback(txChain);
PathSelectionMode pathSelectionStrategy = bestPathSelectionStrategies.get(key);
if (pathSelectionStrategy == null) {
pathSelectionStrategy = BasePathSelectionModeFactory.createBestPathSelectionStrategy();
return dispatcher;
}
- @Override
- 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);
+ private void addCallback(final DOMTransactionChain txChain) {
+ txChain.addCallback(new FutureCallback<Empty>() {
+ @Override
+ public void onSuccess(final Empty result) {
+ LOG.info("RIB {} closed successfully", getInstanceIdentifier());
+ }
+
+ @Override
+ public void onFailure(final Throwable cause) {
+ RIBImpl.this.onFailure(txChain, cause);
+ }
+ });
+ }
+
+ private synchronized void onFailure(final DOMTransactionChain chain, final Throwable cause) {
+ LOG.error("Broken chain in RIB {}", getInstanceIdentifier(), cause);
final LocRibWriter<?, ?> locRibWriter = txChainToLocRibWriter.remove(chain);
if (locRibWriter != null) {
- final DOMTransactionChain newChain = createPeerDOMChain(this);
+ final DOMTransactionChain newChain = createPeerDOMChain();
+ addCallback(newChain);
startLocRib(locRibWriter.getTableKey());
locRibWriter.restart(newChain);
txChainToLocRibWriter.put(newChain, locRibWriter);
}
}
- @Override
- public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
- LOG.info("RIB {} closed successfully", getInstanceIdentifier());
- }
-
@Override
public Set<TablesKey> getLocalTablesKeys() {
return localTablesKeys;
}
@Override
- public DOMDataTreeChangeService getService() {
- return (DOMDataTreeChangeService) domService;
+ public DataTreeChangeExtension getService() {
+ return domService;
}
@Override
}
@Override
- public DOMTransactionChain createPeerDOMChain(final DOMTransactionChainListener listener) {
- return domDataBroker.createMergingTransactionChain(listener);
+ public DOMTransactionChain createPeerDOMChain() {
+ return domDataBroker.createMergingTransactionChain();
}
@Override
}
public synchronized void instantiateServiceInstance() {
+ LOG.debug("Instantiating RIB table {} at {}", ribId, yangRibId);
+
isServiceInstantiated = true;
setActive(true);
- domChain = domDataBroker.createMergingTransactionChain(this);
- LOG.debug("Instantiating RIB table {} at {}", ribId, yangRibId);
+ domChain = domDataBroker.createMergingTransactionChain();
+ addCallback(domChain);
final ContainerNode bgpRib = Builders.containerBuilder().withNodeIdentifier(BGPRIB_NID)
.addChild(ImmutableNodes.mapNodeBuilder(RIB_NID).build()).build();
import java.util.Objects;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.ApplicationPeer;
private static final class BgpAppPeerSingletonService implements BGPPeerStateProvider {
private final ApplicationPeer applicationPeer;
- private final DOMDataTreeChangeService dataTreeChangeService;
+ private final DataTreeChangeExtension dataTreeChangeService;
private final ApplicationRibId appRibId;
@GuardedBy("this")
private boolean isServiceInstantiated;
synchronized void instantiateServiceInstance() {
isServiceInstantiated = true;
- final YangInstanceIdentifier yangIId = YangInstanceIdentifier.builder().node(APPRIB)
- .nodeWithKey(ApplicationRib.QNAME, APP_ID_QNAME, appRibId.getValue())
- .node(TABLES_NID).node(TABLES_NID).build();
applicationPeer.instantiateServiceInstance(dataTreeChangeService,
- new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, yangIId));
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.builder()
+ .node(APPRIB)
+ .nodeWithKey(ApplicationRib.QNAME, APP_ID_QNAME, appRibId.getValue())
+ .node(TABLES_NID)
+ .node(TABLES_NID)
+ .build()));
}
synchronized ListenableFuture<?> closeServiceInstance() {
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Global;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Neighbors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.network.instance.protocol.NeighborPeerGroupConfig;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Empty;
import org.slf4j.Logger;
@GuardedBy("this")
private RibImpl ribImpl;
@GuardedBy("this")
- private ClusterSingletonServiceRegistration cssRegistration;
+ private Registration cssRegistration;
BGPClusterSingletonService(
final @NonNull PeerGroupConfigLoader peerGroupLoader,
this.stateProviderRegistry = stateProviderRegistry;
this.domDataBroker = domDataBroker;
this.bgpIid = bgpIid;
- serviceGroupIdentifier = ServiceGroupIdentifier.create(getRibInstanceName(bgpIid) + "-service-group");
+ serviceGroupIdentifier = new ServiceGroupIdentifier(getRibInstanceName(bgpIid) + "-service-group");
cssRegistration = provider.registerClusterSingletonService(this);
- LOG.info("BGPClusterSingletonService {} registered", serviceGroupIdentifier.getName());
+ LOG.info("BGPClusterSingletonService {} registered", serviceGroupIdentifier.value());
}
@Override
peers.values().forEach(PeerBean::instantiateServiceInstance);
}
instantiated.set(true);
- LOG.info("BGPClusterSingletonService {} instantiated", serviceGroupIdentifier.getName());
+ LOG.info("BGPClusterSingletonService {} instantiated", serviceGroupIdentifier.value());
}
@Override
public synchronized ListenableFuture<?> closeServiceInstance() {
- LOG.info("BGPClusterSingletonService {} close service instance", serviceGroupIdentifier.getName());
+ LOG.info("BGPClusterSingletonService {} close service instance", serviceGroupIdentifier.value());
instantiated.set(false);
final List<ListenableFuture<?>> futurePeerCloseList = peers.values().stream()
return;
}
- LOG.info("Closing BGPClusterSingletonService {}", serviceGroupIdentifier.getName());
+ LOG.info("Closing BGPClusterSingletonService {}", serviceGroupIdentifier.value());
cssRegistration.close();
cssRegistration = null;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.ProtocolsBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.Protocol;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.NetworkInstanceProtocol;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
}
});
private final String networkInstanceName;
- private ListenerRegistration<DefaultBgpDeployer> registration;
+ private Registration registration;
@GuardedBy("this")
private boolean closed;
// Split out of constructor to support partial mocking
public synchronized void init() {
registration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
networkInstanceIId.child(Protocols.class).child(Protocol.class)
.augmentation(NetworkInstanceProtocol.class).child(Bgp.class)), this);
LOG.info("BGP Deployer {} started.", networkInstanceName);
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<Bgp>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<Bgp>> changes) {
if (closed) {
LOG.trace("BGP Deployer was already closed, skipping changes.");
return;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
}
@Override
- public synchronized DOMTransactionChain createPeerDOMChain(final DOMTransactionChainListener listener) {
- return ribImpl.createPeerDOMChain(listener);
+ public synchronized DOMTransactionChain createPeerDOMChain() {
+ return ribImpl.createPeerDOMChain();
}
@Override
}
@Override
- public synchronized DOMDataTreeChangeService getService() {
+ public synchronized DataTreeChangeExtension getService() {
return ribImpl.getService();
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.rib.RibReference;
import org.opendaylight.protocol.bgp.rib.spi.BGPPeerTracker;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
/**
* Allocate a new transaction chain for use with a peer.
*
- * @param listener {@link DOMTransactionChainListener} handling recovery
* @return A new transaction chain.
*/
- DOMTransactionChain createPeerDOMChain(DOMTransactionChainListener listener);
+ DOMTransactionChain createPeerDOMChain();
/**
* Return the RIB extensions available to the RIB instance.
*
* @return DOMDataTreeChangeService
*/
- DOMDataTreeChangeService getService();
+ DataTreeChangeExtension getService();
/**
* Returns true if RIB supports table.
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.inet.RIBActivator;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BGPError;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.next.hop.c.next.hop.Ipv4NextHopCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.next.hop.c.next.hop.ipv4.next.hop._case.Ipv4NextHopBuilder;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
groups = new BGPNettyGroups();
serverRegistry = new StrictBGPPeerRegistry();
serverDispatcher = new BGPDispatcherImpl(context, groups, serverRegistry);
- doReturn(Mockito.mock(ClusterSingletonServiceRegistration.class)).when(clusterSingletonServiceProvider)
+ doReturn(Mockito.mock(Registration.class)).when(clusterSingletonServiceProvider)
.registerClusterSingletonService(any(ClusterSingletonService.class));
codecsRegistry = new ConstantCodecsRegistry(mappingService.currentSerializer());
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.mdsal.binding.dom.adapter.CurrentAdapterSerializer;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
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.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.inet.RIBActivator;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv6AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private FluentFuture<? extends CommitInfo> future;
@Mock
- private DOMDataTreeChangeService service;
+ private DataTreeChangeExtension service;
@Mock
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
a1.startRIBExtensionProvider(context, serializer);
mockedMethods();
- doReturn(mock(ClusterSingletonServiceRegistration.class)).when(clusterSingletonServiceProvider)
+ doReturn(mock(Registration.class)).when(clusterSingletonServiceProvider)
.registerClusterSingletonService(any(ClusterSingletonService.class));
rib = new RIBImpl(tableRegistry, new RibId("test"), new AsNumber(Uint32.valueOf(5)), RIB_ID, context,
dispatcher, new ConstantCodecsRegistry(serializer), dom, policies, localTables,
private void mockedMethods() throws Exception {
MockitoAnnotations.initMocks(this);
doReturn(new TestListenerRegistration()).when(service)
- .registerDataTreeChangeListener(any(DOMDataTreeIdentifier.class),
- any(ClusteredDOMDataTreeChangeListener.class));
+ .registerTreeChangeListener(any(DOMDataTreeIdentifier.class), any(DOMDataTreeChangeListener.class));
doNothing().when(domTransWrite).put(eq(LogicalDatastoreType.OPERATIONAL),
any(YangInstanceIdentifier.class), any(NormalizedNode.class));
doNothing().when(domTransWrite).delete(eq(LogicalDatastoreType.OPERATIONAL),
doReturn(domTransWrite).when(domChain).newWriteOnlyTransaction();
doNothing().when(getTransaction()).put(eq(LogicalDatastoreType.OPERATIONAL),
eq(YangInstanceIdentifier.of(BgpRib.QNAME)), any(NormalizedNode.class));
- doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, service)).when(dom)
- .getExtensions();
- doReturn(domChain).when(dom).createMergingTransactionChain(any(DOMTransactionChainListener.class));
+ doReturn(service).when(dom).extension(DataTreeChangeExtension.class);
+ doReturn(domChain).when(dom).createMergingTransactionChain();
+ doNothing().when(domChain).addCallback(any());
doReturn(Optional.empty()).when(future).get();
doReturn(future).when(domTransWrite).commit();
doCallRealMethod().when(future).addCallback(any(), any());
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.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Ignore
final BGPPeer peer = AbstractAddPathTest.configurePeer(tableRegistry,
localAddress.getIpv4AddressNoZone(), rib, null, PeerRole.Ibgp, new StrictBGPPeerRegistry());
peer.instantiateServiceInstance();
- final ListenerRegistration<?> reg = mock.registerUpdateListener(peer);
+ final Registration reg = mock.registerUpdateListener(peer);
reg.close();
}
final BGPPeer peer = AbstractAddPathTest.configurePeer(tableRegistry,
localAddress.getIpv4AddressNoZone(), rib, null, PeerRole.Ibgp, new StrictBGPPeerRegistry());
peer.instantiateServiceInstance();
- final ListenerRegistration<?> reg = mock.registerUpdateListener(peer);
+ final Registration reg = mock.registerUpdateListener(peer);
reg.close();
}
import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID;
import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_NID;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
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.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.next.hop.CNextHop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.next.hop.c.next.hop.Ipv4NextHopCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.next.hop.c.next.hop.ipv4.next.hop._case.Ipv4NextHopBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
doReturn(null).when(futureChannel).addListener(any());
doReturn(futureChannel).when(speakerListener).close();
doReturn(futureChannel).when(speakerListener).writeAndFlush(any(Notify.class));
- doReturn(domChain).when(domBroker).createMergingTransactionChain(any());
+ doReturn(domChain).when(domBroker).createMergingTransactionChain();
+ doNothing().when(domChain).addCallback(any());
doReturn(tx).when(domChain).newWriteOnlyTransaction();
- final DOMDataTreeChangeService dOMDataTreeChangeService = mock(DOMDataTreeChangeService.class);
- final ListenerRegistration<?> listener = mock(ListenerRegistration.class);
- doReturn(listener).when(dOMDataTreeChangeService).registerDataTreeChangeListener(any(), any());
+ final DataTreeChangeExtension domDataTreeChangeService = mock(DataTreeChangeExtension.class);
+ final Registration listener = mock(Registration.class);
+ doReturn(listener).when(domDataTreeChangeService).registerTreeChangeListener(any(), any());
doNothing().when(listener).close();
doNothing().when(domChain).close();
- doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, dOMDataTreeChangeService))
- .when(domBroker).getExtensions();
+ doReturn(domDataTreeChangeService).when(domBroker).extension(DataTreeChangeExtension.class);
doNothing().when(tx).merge(eq(LogicalDatastoreType.OPERATIONAL),
any(YangInstanceIdentifier.class), any(NormalizedNode.class));
doNothing().when(tx).put(eq(LogicalDatastoreType.OPERATIONAL),
import org.mockito.Mock;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.protocol.bgp.rib.impl.BGPPeerTrackerImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.BgpId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Mock
protected BGPPeerRegistry bgpPeerRegistry;
@Mock
- protected ListenerRegistration<?> listener;
+ protected Registration listener;
@Mock
protected Future<?> future;
@Mock
@Mock
protected PeerGroupConfigLoader peerGroupLoader;
@Mock
- private DOMDataTreeChangeService dataTreeChangeService;
+ private DataTreeChangeExtension dataTreeChangeService;
private final BGPPeerTracker peerTracker = new BGPPeerTrackerImpl();
@Override
doReturn(InstanceIdentifier.create(BgpRib.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight
.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib.class, new RibKey(RIB_ID))).when(rib)
.getInstanceIdentifier();
- doReturn(domTx).when(rib).createPeerDOMChain(any(DOMTransactionChainListener.class));
+ doReturn(domTx).when(rib).createPeerDOMChain();
+ doNothing().when(domTx).addCallback(any());
doReturn(AS).when(rib).getLocalAs();
doReturn(mock(RIBSupportContextRegistry.class)).when(rib).getRibSupportContext();
doReturn(YangInstanceIdentifier.of(Rib.QNAME)).when(rib).getYangRibId();
doReturn(dataTreeChangeService).when(rib).getService();
- doReturn(listener).when(dataTreeChangeService).registerDataTreeChangeListener(any(), any());
+ doReturn(listener).when(dataTreeChangeService).registerTreeChangeListener(any(), any());
doReturn(new BgpId("127.0.0.1")).when(rib).getBgpIdentifier();
doReturn(true).when(future).cancel(true);
doReturn(future).when(dispatcher).createReconnectingClient(any(InetSocketAddress.class),
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.internal.verification.VerificationModeFactory.times;
import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.protocol.bgp.rib.impl.state.BGPStateCollector;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbor.group.ConfigBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
appPeer.start(rib, neighbor, null, peerGroupLoader, tableTypeRegistry);
verify(rib).getYangRibId();
verify(rib).getService();
- verify(rib).createPeerDOMChain(any(DOMTransactionChainListener.class));
+ verify(rib).createPeerDOMChain();
verify(rib, times(1)).getLocalTablesKeys();
appPeer.instantiateServiceInstance();
verify(rib, times(3)).getYangRibId();
verify(rib, times(2)).getRibSupportContext();
verify(rib, times(2)).getLocalTablesKeys();
- verify(rib, times(2)).createPeerDOMChain(any(DOMTransactionChainListener.class));
+ verify(rib, times(2)).createPeerDOMChain();
verify(domTx).newWriteOnlyTransaction();
appPeer.closeServiceInstance();
appPeer.instantiateServiceInstance();
verify(rib, times(6)).getYangRibId();
verify(rib, times(4)).getService();
- verify(rib, times(4)).createPeerDOMChain(any(DOMTransactionChainListener.class));
+ verify(rib, times(4)).createPeerDOMChain();
verify(listener, times(2)).close();
assertTrue(appPeer.containsEqualConfiguration(neighbor));
verify(domTx, times(4)).close();
appPeer.instantiateServiceInstance();
- verify(rib, times(6)).createPeerDOMChain(any(DOMTransactionChainListener.class));
+ verify(rib, times(6)).createPeerDOMChain();
appPeer.closeServiceInstance();
verify(domTx, times(6)).close();
appPeer.stop().get();
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.impl.DefaultBGPRibRoutingPolicyFactory;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.registry.StatementRegistry;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.NetworkInstanceProtocol;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
doReturn(TABLE_TYPE).when(tableTypeRegistry).getTableType(any());
doReturn(TABLES_KEY).when(tableTypeRegistry).getTableKey(any());
- final ClusterSingletonServiceRegistration serviceRegistration = mock(ClusterSingletonServiceRegistration.class);
+ final var serviceRegistration = mock(Registration.class);
doReturn(serviceRegistration).when(singletonServiceProvider).registerClusterSingletonService(any());
doNothing().when(serviceRegistration).close();
.build();
bgpPeer.start(rib, neighbor, null, peerGroupLoader, tableTypeRegistry);
- verify(rib).createPeerDOMChain(any());
+ verify(rib).createPeerDOMChain();
verify(rib, times(2)).getLocalAs();
verify(rib).getLocalTables();
bgpPeer.stop().get();
bgpPeer.start(rib, bgpPeer.getCurrentConfiguration(), null, peerGroupLoader, tableTypeRegistry);
bgpPeer.instantiateServiceInstance();
- verify(rib, times(2)).createPeerDOMChain(any());
+ verify(rib, times(2)).createPeerDOMChain();
verify(rib, times(4)).getLocalAs();
verify(rib, times(2)).getLocalTables();
verify(bgpPeerRegistry, times(2)).addPeer(any(), any(), any());
bgpPeer.closeServiceInstance();
verify(bgpPeerRegistry, times(3)).removePeer(any());
verify(future, times(3)).cancel(true);
- verify(rib, times(3)).createPeerDOMChain(any());
+ verify(rib, times(3)).createPeerDOMChain();
bgpPeer.stop().get();
bgpPeer.start(rib, bgpPeer.getCurrentConfiguration(), null, peerGroupLoader, tableTypeRegistry);
bgpPeer.instantiateServiceInstance();
- verify(rib, times(4)).createPeerDOMChain(any());
+ verify(rib, times(4)).createPeerDOMChain();
verify(rib, times(6)).getLocalAs();
verify(rib, times(3)).getLocalTables();
verify(bgpPeerRegistry, times(4)).addPeer(any(), any(), any());
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker.DataTreeChangeExtension;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
import org.opendaylight.protocol.bgp.rib.impl.state.BGPStateCollector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.BgpId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.Ipv4AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev200120.UnicastSubsequentAddressFamily;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint8;
final NodeIdentifierWithPredicates niie = NodeIdentifierWithPredicates.of(Rib.QNAME,
QName.create("", "test").intern(), "t");
doReturn(niie).when(emptyTable).name();
- doReturn(domTx).when(domDataBroker).createMergingTransactionChain(any());
- final DOMDataTreeChangeService dOMDataTreeChangeService = mock(DOMDataTreeChangeService.class);
- doReturn(ImmutableClassToInstanceMap.of(DOMDataTreeChangeService.class, dOMDataTreeChangeService))
- .when(domDataBroker).getExtensions();
- doReturn(mock(ListenerRegistration.class)).when(dOMDataTreeChangeService)
- .registerDataTreeChangeListener(any(), any());
+ doReturn(domTx).when(domDataBroker).createMergingTransactionChain();
+ final DataTreeChangeExtension domDataTreeChangeService = mock(DataTreeChangeExtension.class);
+ doReturn(domDataTreeChangeService).when(domDataBroker).extension(DataTreeChangeExtension.class);
+ doReturn(mock(Registration.class)).when(domDataTreeChangeService).registerTreeChangeListener(any(), any());
}
@Test
final RibImpl ribImpl = new RibImpl(extension, dispatcher, policyProvider, codecsRegistry,
new BGPStateCollector(), domDataBroker);
ribImpl.start(createGlobal(), "rib-test", tableTypeRegistry);
- verify(domDataBroker).getExtensions();
+ verify(domDataBroker).extension(DataTreeChangeExtension.class);
assertEquals("""
RIBImpl{bgpId=Ipv4Address{value=127.0.0.1}, localTables=[BgpTableTypeImpl [\
getAfi()=Ipv4AddressFamily{qname=\
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
-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.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.TopologyTypes;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractTopologyBuilder<T extends Route> implements ClusteredDataTreeChangeListener<T>,
- TopologyReference, TransactionChainListener {
+public abstract class AbstractTopologyBuilder<T extends Route>
+ implements ClusteredDataTreeChangeListener<T>, TopologyReference, FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractTopologyBuilder.class);
// we limit the listener reset interval to be 5 min at most
private static final long LISTENER_RESET_LIMIT_IN_MILLSEC = 5 * 60 * 1000;
private final int listenerResetEnforceCounter;
@GuardedBy("this")
- private ListenerRegistration<AbstractTopologyBuilder<T>> listenerRegistration = null;
+ private Registration listenerRegistration = null;
@GuardedBy("this")
private TransactionChain chain = null;
private final AtomicBoolean closed = new AtomicBoolean(false);
final int listenerResetEnforceCounter) {
this.dataProvider = dataProvider;
this.locRibReference = requireNonNull(locRibReference);
- this.topologyKey = new TopologyKey(requireNonNull(topologyId));
- this.topologyTypes = types;
+ topologyKey = new TopologyKey(requireNonNull(topologyId));
+ topologyTypes = types;
this.afi = afi;
this.safi = safi;
this.listenerResetLimitInMillsec = listenerResetLimitInMillsec;
this.listenerResetEnforceCounter = listenerResetEnforceCounter;
- this.topology = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, this.topologyKey).build();
+ topology = InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, topologyKey)
+ .build();
}
protected AbstractTopologyBuilder(final DataBroker dataProvider, final RibReference locRibReference,
}
public final synchronized void start() {
- LOG.debug("Initiating topology builder from {} at {}. AFI={}, SAFI={}", this.locRibReference, this.topology,
- this.afi, this.safi);
+ LOG.debug("Initiating topology builder from {} at {}. AFI={}, SAFI={}", locRibReference, topology,
+ afi, safi);
initTransactionChain();
initOperationalTopology();
registerDataChangeListener();
* Register to data tree change listener.
*/
private synchronized void registerDataChangeListener() {
- Preconditions.checkState(this.listenerRegistration == null,
+ Preconditions.checkState(listenerRegistration == null,
"Topology Listener on topology %s has been registered before.",
this.getInstanceIdentifier());
- final InstanceIdentifier<Tables> tablesId = this.locRibReference.getInstanceIdentifier()
- .child(LocRib.class).child(Tables.class, new TablesKey(this.afi, this.safi));
+ final InstanceIdentifier<Tables> tablesId = locRibReference.getInstanceIdentifier()
+ .child(LocRib.class).child(Tables.class, new TablesKey(afi, safi));
final DataTreeIdentifier<T> id = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
getRouteWildcard(tablesId));
- this.listenerRegistration = this.dataProvider.registerDataTreeChangeListener(id, this);
+ listenerRegistration = dataProvider.registerDataTreeChangeListener(id, this);
LOG.debug("Registered listener {} on topology {}. Timestamp={}", this, this.getInstanceIdentifier(),
- this.listenerScheduledRestartTime);
+ listenerScheduledRestartTime);
}
/**
* Unregister to data tree change listener.
*/
private synchronized void unregisterDataChangeListener() {
- if (this.listenerRegistration != null) {
+ if (listenerRegistration != null) {
LOG.debug("Unregistered listener {} on topology {}", this, this.getInstanceIdentifier());
- this.listenerRegistration.close();
- this.listenerRegistration = null;
+ listenerRegistration.close();
+ listenerRegistration = null;
}
}
@Override
public final InstanceIdentifier<Topology> getInstanceIdentifier() {
- return this.topology;
+ return topology;
}
public final synchronized FluentFuture<? extends CommitInfo> close() {
- if (this.closed.getAndSet(true)) {
+ if (closed.getAndSet(true)) {
LOG.trace("Transaction chain was already closed.");
return CommitInfo.emptyFluentFuture();
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<T>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<T>> changes) {
if (networkTopologyTransaction) {
- if (this.closed.get()) {
+ if (closed.get()) {
LOG.trace("Transaction chain was already closed, skipping update.");
return;
}
LOG.debug("The data change {} is disregarded due to restart of listener {}", changes, this);
return;
}
- final ReadWriteTransaction trans = this.chain.newReadWriteTransaction();
+ final ReadWriteTransaction trans = chain.newReadWriteTransaction();
LOG.trace("Received data change {} event with transaction {}", changes, trans.getIdentifier());
final AtomicBoolean transactionInError = new AtomicBoolean(false);
for (final DataTreeModification<T> change : changes) {
}
private synchronized void initOperationalTopology() {
- requireNonNull(this.chain, "A valid transaction chain must be provided.");
- final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
- trans.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, this.topology,
- new TopologyBuilder().withKey(this.topologyKey).setServerProvided(Boolean.TRUE)
- .setTopologyTypes(this.topologyTypes)
+ requireNonNull(chain, "A valid transaction chain must be provided.");
+ final WriteTransaction trans = chain.newWriteOnlyTransaction();
+ trans.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, topology,
+ new TopologyBuilder().withKey(topologyKey).setServerProvided(Boolean.TRUE)
+ .setTopologyTypes(topologyTypes)
.setLink(Map.of()).setNode(Map.of()).build());
trans.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
* Destroy the current operational topology data. Note a valid transaction must be provided.
*/
private synchronized FluentFuture<? extends CommitInfo> destroyOperationalTopology() {
- requireNonNull(this.chain, "A valid transaction chain must be provided.");
- final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
+ requireNonNull(chain, "A valid transaction chain must be provided.");
+ final WriteTransaction trans = chain.newWriteOnlyTransaction();
trans.delete(LogicalDatastoreType.OPERATIONAL, getInstanceIdentifier());
final FluentFuture<? extends CommitInfo> future = trans.commit();
future.addCallback(new FutureCallback<CommitInfo>() {
*/
private synchronized void initTransactionChain() {
LOG.debug("Initializing transaction chain for topology {}", this);
- Preconditions.checkState(this.chain == null,
+ Preconditions.checkState(chain == null,
"Transaction chain has to be closed before being initialized");
- this.chain = this.dataProvider.createMergingTransactionChain(this);
+ chain = dataProvider.createMergingTransactionChain();
+ chain.addCallback(this);
}
/**
* Destroy the current transaction chain.
*/
private synchronized void destroyTransactionChain() {
- if (this.chain != null) {
+ if (chain != null) {
LOG.debug("Destroy transaction chain for topology {}", this);
// we cannot close the transaction chain, as it will close the AbstractDOMForwardedTransactionFactory
// and the transaction factory cannot be reopen even if we recreate the transaction chain
// LOG.error("Unable to close transaction chain {} for topology builder {}", this.chain,
// getInstanceIdentifier());
// }
- this.chain = null;
+ chain = null;
}
}
*/
@VisibleForTesting
protected synchronized void resetListener() {
- requireNonNull(this.listenerRegistration, "Listener on topology " + this + " hasn't been initialized.");
+ requireNonNull(listenerRegistration, "Listener on topology " + this + " hasn't been initialized.");
LOG.debug("Resetting data change listener for topology builder {}", getInstanceIdentifier());
// unregister current listener to prevent incoming data tree change first
unregisterDataChangeListener();
*/
@VisibleForTesting
protected synchronized boolean restartTransactionChainOnDemand() {
- if (this.listenerScheduledRestartTime > 0) {
+ if (listenerScheduledRestartTime > 0) {
// when the #this.listenerScheduledRestartTime timer timed out we can reset the listener,
// otherwise we should only reset the transaction chain
- if (System.currentTimeMillis() > this.listenerScheduledRestartTime) {
+ if (System.currentTimeMillis() > listenerScheduledRestartTime) {
// reset the the restart timer
- this.listenerScheduledRestartTime = 0;
- this.listenerScheduledRestartEnforceCounter = 0;
+ listenerScheduledRestartTime = 0;
+ listenerScheduledRestartEnforceCounter = 0;
resetListener();
return true;
}
@VisibleForTesting
protected synchronized void scheduleListenerRestart() {
- if (0 == this.listenerScheduledRestartTime) {
- this.listenerScheduledRestartTime = System.currentTimeMillis() + this.listenerResetLimitInMillsec;
- } else if (System.currentTimeMillis() > this.listenerScheduledRestartTime
- && ++this.listenerScheduledRestartEnforceCounter < this.listenerResetEnforceCounter) {
+ if (0 == listenerScheduledRestartTime) {
+ listenerScheduledRestartTime = System.currentTimeMillis() + listenerResetLimitInMillsec;
+ } else if (System.currentTimeMillis() > listenerScheduledRestartTime
+ && ++listenerScheduledRestartEnforceCounter < listenerResetEnforceCounter) {
// if the transaction failure happens again, we will delay the listener restart up to
// #LISTENER_RESET_LIMIT_IN_MILLSEC times
- this.listenerScheduledRestartTime += this.listenerResetLimitInMillsec;
+ listenerScheduledRestartTime += listenerResetLimitInMillsec;
}
LOG.debug("A listener restart was scheduled at {} (current system time is {})",
- this.listenerScheduledRestartTime, System.currentTimeMillis());
+ listenerScheduledRestartTime, System.currentTimeMillis());
}
@Override
- public final synchronized void onTransactionChainFailed(final TransactionChain transactionChain,
- final Transaction transaction, final Throwable cause) {
- LOG.error("Topology builder for {} failed in transaction {}.", getInstanceIdentifier(),
- transaction != null ? transaction.getIdentifier() : null, cause);
+ public final synchronized void onFailure(final Throwable cause) {
+ LOG.error("Topology builder for {} failed", getInstanceIdentifier(), cause);
scheduleListenerRestart();
restartTransactionChainOnDemand();
}
@Override
- public final void onTransactionChainSuccessful(final TransactionChain transactionChain) {
+ public final void onSuccess(final Empty value) {
LOG.info("Topology builder for {} shut down", getInstanceIdentifier());
}
}
import static java.util.Objects.requireNonNull;
-import java.util.Collection;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.PreDestroy;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
private final Set<Topology> topologies = new HashSet<>();
private final DataBroker dataBroker;
private final ClusterSingletonServiceProvider singletonProvider;
- private ListenerRegistration<BgpTopologyDeployerImpl> registration;
+ private Registration registration;
@GuardedBy("this")
private boolean closed;
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<Topology>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<Topology>> changes) {
if (closed) {
LOG.trace("BGP Topology Provider Deployer was already closed, skipping changes.");
return;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.bgpcep.bgp.topology.provider.config;
import static java.util.Objects.requireNonNull;
import org.opendaylight.bgpcep.bgp.topology.provider.spi.BgpTopologyDeployer;
import org.opendaylight.bgpcep.bgp.topology.provider.spi.TopologyReferenceSingletonService;
import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
final BgpTopologyDeployer deployer, final Topology configuration) {
this.configuration = requireNonNull(configuration);
this.topologyBuilder = requireNonNull(topologyBuilder);
- this.serviceRegistration = deployer.registerService(this);
+ serviceRegistration = deployer.registerService(this);
}
@Override
public InstanceIdentifier<Topology> getInstanceIdentifier() {
- return this.topologyBuilder.getInstanceIdentifier();
+ return topologyBuilder.getInstanceIdentifier();
}
@Override
public void close() {
- this.serviceRegistration.close();
+ serviceRegistration.close();
}
@Override
public void instantiateServiceInstance() {
LOG.info("Topology Singleton Service {} instantiated", getIdentifier());
- this.topologyBuilder.start();
+ topologyBuilder.start();
}
@Override
public FluentFuture<? extends CommitInfo> closeServiceInstance() {
LOG.info("Close Topology Singleton Service {}", getIdentifier());
- return this.topologyBuilder.close();
+ return topologyBuilder.close();
}
@Override
public ServiceGroupIdentifier getIdentifier() {
- return ServiceGroupIdentifier.create(getInstanceIdentifier().firstKeyOf(Topology.class)
- .getTopologyId().getValue());
+ return new ServiceGroupIdentifier(
+ getInstanceIdentifier().firstKeyOf(Topology.class).getTopologyId().getValue());
}
@Override
public Topology getConfiguration() {
- return this.configuration;
+ return configuration;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.bgpcep.bgp.topology.provider.spi;
import org.opendaylight.bgpcep.topology.TopologyReference;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
public interface TopologyReferenceSingletonService extends TopologyReference, AutoCloseable, ClusterSingletonService {
-
@Override
void close();
Topology getConfiguration();
-
}
verify(spiedLinkstateTopologyBuilder, never()).resetListener();
Thread.sleep(LISTENER_RESTART_TIME);
// manually invoke onTransactionChainFailed() to have the listener restart scheduled again
- spiedLinkstateTopologyBuilder.onTransactionChainFailed(null, null, null);
+ spiedLinkstateTopologyBuilder.onFailure(null);
assertEquals(spiedLinkstateTopologyBuilder.listenerScheduledRestartTime, listenerScheduledRestartTime
+ LISTENER_RESTART_TIME);
verify(spiedLinkstateTopologyBuilder, times(5)).restartTransactionChainOnDemand();
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>io.netty</groupId>
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.api.BmpDispatcher;
import org.opendaylight.protocol.bmp.impl.spi.BmpMonitoringStation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.bmp.monitor.Monitor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.rfc2385.cfg.rev160324.Rfc2385Key;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
private static final QName MONITOR_ID_QNAME = QName.create(Monitor.QNAME, "monitor-id").intern();
private static final ServiceGroupIdentifier SERVICE_GROUP_IDENTIFIER =
- ServiceGroupIdentifier.create("bmp-monitors-service-group");
+ new ServiceGroupIdentifier("bmp-monitors-service-group");
private final DOMDataBroker domDataBroker;
private final InetSocketAddress address;
private final RouterSessionManager sessionManager;
private final YangInstanceIdentifier yangMonitorId;
private Channel channel;
- private ClusterSingletonServiceRegistration singletonServiceRegistration;
+ private Registration singletonServiceRegistration;
public BmpMonitoringStationImpl(final DOMDataBroker domDataBroker, final BmpDispatcher dispatcher,
final RIBExtensionConsumerContext extensions, final BindingCodecTree codecTree,
sessionManager = new RouterSessionManager(yangMonitorId, this.domDataBroker, extensions, codecTree);
LOG.info("BMP Monitor Singleton Service {} registered, Monitor Id {}",
- getIdentifier().getName(), this.monitorId.getValue());
+ getIdentifier().value(), this.monitorId.getValue());
singletonServiceRegistration = singletonProvider.registerClusterSingletonService(this);
}
@Override
public synchronized void instantiateServiceInstance() {
LOG.info("BMP Monitor Singleton Service {} instantiated, Monitor Id {}",
- getIdentifier().getName(), monitorId.getValue());
+ getIdentifier().value(), monitorId.getValue());
final ChannelFuture channelFuture = dispatcher.createServer(address, sessionManager,
constructKeys(monitoredRouters));
@Override
public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
LOG.info("BMP Monitor Singleton Service {} instance closed, Monitor Id {}",
- getIdentifier().getName(), monitorId.getValue());
+ getIdentifier().value(), monitorId.getValue());
if (channel != null) {
channel.close().addListener((ChannelFutureListener) future -> {
Preconditions.checkArgument(future.isSuccess(),
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.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.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.api.BmpSession;
import org.opendaylight.protocol.bmp.impl.spi.BmpRouter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.peers.Peer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.routers.Router;
import org.opendaylight.yangtools.yang.binding.Notification;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class BmpRouterImpl implements BmpRouter, DOMTransactionChainListener {
+public final class BmpRouterImpl implements BmpRouter, FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(BmpRouterImpl.class);
public BmpRouterImpl(final RouterSessionManager sessionManager) {
this.sessionManager = requireNonNull(sessionManager);
domDataBroker = sessionManager.getDomDataBroker();
- domTxChain = domDataBroker.createMergingTransactionChain(this);
+ domTxChain = domDataBroker.createMergingTransactionChain();
+ domTxChain.addCallback(this);
extensions = sessionManager.getExtensions();
tree = sessionManager.getCodecTree();
}
}
@Override
- public synchronized void onTransactionChainFailed(final DOMTransactionChain chain,
- final DOMDataTreeTransaction transaction, final Throwable cause) {
+ public synchronized void onFailure(final Throwable cause) {
LOG.error("Transaction chain failed.", cause);
}
@Override
- public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
- LOG.debug("Transaction chain {} successfully.", chain);
+ public void onSuccess(final Empty value) {
+ LOG.debug("Transaction chain finished successfully.");
}
private synchronized boolean isDatastoreWritable() {
import java.net.InetSocketAddress;
import java.util.Collection;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.annotation.PreDestroy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.api.BmpDispatcher;
import org.opendaylight.protocol.bmp.impl.app.BmpMonitoringStationImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.BmpMonitor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.MonitorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.bmp.monitor.Monitor;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@GuardedBy("this")
private final Map<MonitorId, BmpMonitoringStationImpl> bmpMonitorServices = new HashMap<>();
@GuardedBy("this")
- private ListenerRegistration<BmpDeployerImpl> registration;
+ private Registration registration;
@Activate
@Inject
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<OdlBmpMonitors>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<OdlBmpMonitors>> changes) {
final DataTreeModification<OdlBmpMonitors> dataTreeModification = Iterables.getOnlyElement(changes);
final Collection<? extends DataObjectModification<? extends DataObject>> rootNode =
dataTreeModification.getRootNode().getModifiedChildren();
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.inet.RIBActivator;
import org.opendaylight.protocol.bgp.parser.impl.BGPActivator;
import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.peers.peer.Stats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.monitor.rev200120.routers.RouterKey;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private ClusterSingletonService singletonService;
private ClusterSingletonService singletonService2;
@Mock
- private ClusterSingletonServiceRegistration singletonServiceRegistration;
+ private Registration singletonServiceRegistration;
@Mock
- private ClusterSingletonServiceRegistration singletonServiceRegistration2;
+ private Registration singletonServiceRegistration2;
@Mock
private ClusterSingletonServiceProvider clusterSSProv;
@Mock
@Reference(policy = ReferencePolicy.DYNAMIC, updated = "setRuntimeContext", unbind = "setRuntimeContext")
void setRuntimeContext(final BindingRuntimeContext runtimeContext) {
- updateModelContext(runtimeContext.getEffectiveModelContext());
+ updateModelContext(runtimeContext.modelContext());
}
@Activate
@Inject
public SimpleConfigLoader(final FileWatcher fileWatcher, final BindingRuntimeContext runtimeContext) {
- updateModelContext(runtimeContext.getEffectiveModelContext());
- this.watchService = fileWatcher.getWatchService();
- this.directory = new File(fileWatcher.getPathFile());
+ updateModelContext(runtimeContext.modelContext());
+ watchService = fileWatcher.getWatchService();
+ directory = new File(fileWatcher.getPathFile());
}
@PostConstruct
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
doNothing().when(processor).loadConfiguration(any());
- configLoader.updateModelContext(getSchemaContext());
+ configLoader.updateModelContext(modelContext());
}
@Override
protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
- final AbstractDataBrokerTestCustomizer customizer = super.createDataBrokerTestCustomizer();
- this.schemaService = customizer.getSchemaService();
+ final var customizer = super.createDataBrokerTestCustomizer();
+ schemaService = customizer.getSchemaService();
return customizer;
}
}).when(watchKey).pollEvents();
doReturn("watchEvent").when(watchEvent).context();
doReturn(true).when(watchKey).reset();
- doReturn(domContext).when(bindingContext).getEffectiveModelContext();
+ doReturn(domContext).when(bindingContext).modelContext();
loader = new OSGiConfigLoader();
loader.watcher = watcher;
@Before
public void before() throws InterruptedException {
- doReturn(domContext).when(bindingContext).getEffectiveModelContext();
+ doReturn(domContext).when(bindingContext).modelContext();
doReturn(watchService).when(watcher).getWatchService();
doReturn("foo").when(watcher).getPathFile();
doReturn(watchKey).when(watchService).take();
package org.opendaylight.protocol.data.change.counter;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collection;
+import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.LongAdder;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
-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.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class TopologyDataChangeCounter implements ClusteredDataTreeChangeListener<Topology>,
- TransactionChainListener, AutoCloseable {
-
+final class TopologyDataChangeCounter
+ implements DataTreeChangeListener<Topology>, FutureCallback<Empty>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TopologyDataChangeCounter.class);
private final DataBroker dataBroker;
private final String counterId;
private final InstanceIdentifier<Counter> counterInstanceId;
private final LongAdder count = new LongAdder();
- private final ListenerRegistration<TopologyDataChangeCounter> registration;
private final AtomicBoolean closed = new AtomicBoolean(false);
+ private final Registration registration;
+
private TransactionChain transactionChain;
TopologyDataChangeCounter(final DataBroker dataBroker, final String counterId, final String topologyName) {
- this.dataBroker = dataBroker;
- this.transactionChain = this.dataBroker.createMergingTransactionChain(this);
+ this.dataBroker = requireNonNull(dataBroker);
+ transactionChain = dataBroker.createMergingTransactionChain();
this.counterId = counterId;
- this.counterInstanceId = InstanceIdentifier.builder(DataChangeCounter.class)
+ counterInstanceId = InstanceIdentifier.builder(DataChangeCounter.class)
.child(Counter.class, new CounterKey(this.counterId)).build();
- putCount(this.count.longValue());
+ putCount(count.longValue());
final InstanceIdentifier<Topology> topoIId = InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(new TopologyId(topologyName))).build();
- this.registration = this.dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, topoIId), this);
+ registration = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, topoIId), this);
LOG.debug("Data change counter {} initiated", this.counterId);
+ transactionChain.addCallback(this);
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<Topology>> changes) {
- this.count.increment();
- final long inc = this.count.sum();
- LOG.debug("Data change #{} for counter {}", inc, this.counterId);
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<Topology>> changes) {
+ count.increment();
+ final long inc = count.sum();
+ LOG.debug("Data change #{} for counter {}", inc, counterId);
putCount(inc);
}
@Override
public synchronized void close() {
- this.registration.close();
- final WriteTransaction wTx = this.dataBroker.newWriteOnlyTransaction();
- wTx.delete(LogicalDatastoreType.OPERATIONAL, this.counterInstanceId);
+ registration.close();
+ final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.OPERATIONAL, counterInstanceId);
try {
wTx.commit().get();
} catch (final ExecutionException | InterruptedException except) {
- LOG.warn("Error on remove data change counter {}", this.counterId, except);
+ LOG.warn("Error on remove data change counter {}", counterId, except);
}
- this.transactionChain.close();
- LOG.debug("Data change counter {} removed", this.counterId);
+ transactionChain.close();
+ LOG.debug("Data change counter {} removed", counterId);
}
private void putCount(final long totalCount) {
- final WriteTransaction wTx = this.transactionChain.newWriteOnlyTransaction();
- final Counter counter = new CounterBuilder().setId(this.counterId).setCount(Uint32.valueOf(totalCount)).build();
- wTx.put(LogicalDatastoreType.OPERATIONAL, this.counterInstanceId, counter);
+ final WriteTransaction wTx = transactionChain.newWriteOnlyTransaction();
+ final Counter counter = new CounterBuilder().setId(counterId).setCount(Uint32.valueOf(totalCount)).build();
+ wTx.put(LogicalDatastoreType.OPERATIONAL, counterInstanceId, counter);
wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onSuccess(final CommitInfo result) {
}
@Override
- public synchronized void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
- final Throwable cause) {
- LOG.warn("Transaction chain failure. Transaction: {}", transaction, cause);
+ public synchronized void onFailure(final Throwable cause) {
+ LOG.warn("Transaction chain failure", cause);
if (!closed.get()) {
- this.transactionChain.close();
- this.transactionChain = dataBroker.createMergingTransactionChain(this);
+ transactionChain.close();
+ transactionChain = dataBroker.createMergingTransactionChain();
+ transactionChain.addCallback(this);
}
}
@Override
- public synchronized void onTransactionChainSuccessful(final TransactionChain chain) {
- LOG.debug("Transaction chain successful. {}", chain);
+ public synchronized void onSuccess(final Empty result) {
+ LOG.debug("Transaction chain successful");
}
}
import static java.util.Objects.requireNonNull;
-import java.util.Collection;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgpcep.data.change.counter.config.rev170424.DataChangeCounterConfig;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
@GuardedBy("this")
private final Map<String, TopologyDataChangeCounter> counters = new HashMap<>();
@GuardedBy("this")
- private ListenerRegistration<TopologyDataChangeCounterDeployer> registration;
+ private Registration registration;
@Inject
@Activate
public TopologyDataChangeCounterDeployer(@Reference final DataBroker dataBroker) {
this.dataBroker = requireNonNull(dataBroker);
- registration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, DATA_CHANGE_COUNTER_IID), this);
+ registration = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, DATA_CHANGE_COUNTER_IID), this);
LOG.info("Data change counter Deployer started");
}
}
@Override
- public synchronized void onDataTreeChanged(
- final Collection<DataTreeModification<DataChangeCounterConfig>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<DataChangeCounterConfig>> changes) {
for (var change : changes) {
final var rootNode = change.getRootNode();
- switch (rootNode.getModificationType()) {
+ switch (rootNode.modificationType()) {
case DELETE:
- deleteCounterChange(rootNode.getDataBefore().getCounterId());
+ deleteCounterChange(rootNode.dataBefore().getCounterId());
break;
case SUBTREE_MODIFIED:
case WRITE:
- final var counterConfig = rootNode.getDataAfter();
+ final var counterConfig = rootNode.dataAfter();
handleCounterChange(counterConfig.getCounterId(), counterConfig.getTopologyName());
break;
default:
- LOG.error("Unhandled modification Type: {}", rootNode.getModificationType());
+ LOG.error("Unhandled modification Type: {}", rootNode.modificationType());
break;
}
}
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-benchmark" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
- <feature version="[8,9)">odl-controller-blueprint</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-controller-blueprint</feature>
</feature>
</features>
-->
<features name="odl-bgpcep-bgp-dependencies-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
<feature name="odl-bgpcep-bgp-dependencies" version="${project.version}">
- <feature version="[11,12)">odl-yangtools-data-api</feature>
+ <feature version="[13,14)">odl-yangtools-data-api</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-evpn" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-rfc8294-netty</feature>
+ <feature version="[13,14)">odl-mdsal-rfc8294-netty</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-labeled-unicast" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-rfc8294-netty</feature>
+ <feature version="[13,14)">odl-mdsal-rfc8294-netty</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-linkstate" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
- <feature version="[12,13)">odl-mdsal-rfc8294-netty</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
+ <feature version="[13,14)">odl-mdsal-rfc8294-netty</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-openconfig-rp-impl" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-openconfig-rp-statement" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-parser-api" version="${project.version}">
- <feature version="[11,12)">odl-yangtools-data</feature>
- <feature version="[11,12)">odl-yangtools-netty</feature>
+ <feature version="[13,14)">odl-yangtools-data</feature>
+ <feature version="[13,14)">odl-yangtools-netty</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-rib-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc8343</feature>
- <feature version="[12,13)">odl-mdsal-singleton-common</feature>
- <feature version="[12,13)">odl-mdsal-dom-api</feature>
- <feature version="[12,13)">odl-mdsal-binding-runtime</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8343</feature>
+ <feature version="[13,14)">odl-mdsal-singleton-common</feature>
+ <feature version="[13,14)">odl-mdsal-dom-api</feature>
+ <feature version="[13,14)">odl-mdsal-binding-runtime</feature>
</feature>
</features>
<type>xml</type>
<classifier>routing-policy-default-config</classifier>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-controller-exp-netty-config</artifactId>
- <type>xml</type>
- <classifier>features</classifier>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-controller-blueprint</artifactId>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bgp-rib-impl" version="${project.version}">
- <feature version="[8,9)">odl-controller-blueprint</feature>
- <feature version="[8,9)">odl-controller-exp-netty-config</feature>
+ <feature version="[9,10)">odl-controller-blueprint</feature>
<configfile finalname="etc/opendaylight/bgpcep/routing-policy-default-config.xml">mvn:org.opendaylight.bgpcep/bgp-config-example/${project.version}/xml/routing-policy-default-config</configfile>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-bmp-config-loader" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-concepts" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8294</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8294</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-config-loader-impl" version="${project.version}">
- <feature version="[11,12)">odl-yangtools-codec</feature>
+ <feature version="[13,14)">odl-yangtools-codec</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-config-loader-spi" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-binding-runtime</feature>
+ <feature version="[13,14)">odl-mdsal-binding-runtime</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-bgpcep-data-change-counter-${project.version}">
<feature name="odl-bgpcep-data-change-counter" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-graph-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
- <feature version="[12,13)">odl-mdsal-model-rfc8294</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[13,14)">odl-mdsal-model-rfc8294</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-graph" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
<name>OpenDaylight :: PCEP :: Impl</name>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-controller-exp-netty-config</artifactId>
- <type>xml</type>
- <classifier>features</classifier>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-pcep-impl" version="${project.version}">
- <feature version="[8,9)">odl-controller-exp-netty-config</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-pcep-p2mp-te-lsp" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-bgpcep-programming-api-${project.version}">
<feature name="odl-bgpcep-programming-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-singleton-common</feature>
+ <feature version="[13,14)">odl-mdsal-singleton-common</feature>
</feature>
</features>
<type>xml</type>
<classifier>features</classifier>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>odl-controller-exp-netty-config</artifactId>
- <type>xml</type>
- <classifier>features</classifier>
- </dependency>
</dependencies>
</project>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-programming-impl" version="${project.version}">
- <feature version="[8,9)">odl-controller-exp-netty-config</feature>
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-rsvp-api" version="${project.version}">
- <feature version="[11,12)">odl-yangtools-netty</feature>
+ <feature version="[13,14)">odl-yangtools-netty</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-topology-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
</feature>
</features>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-bgpcep-topology-config-loader" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[9,10)">odl-mdsal-broker</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-bgpcep-topology-tunnel-api-${project.version}">
<feature name="odl-bgpcep-topology-tunnel-api" version="${project.version}">
- <feature version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[13,14)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
</feature>
</features>
import org.opendaylight.graph.ConnectedGraphProvider;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
-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.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.graph.Vertex;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
*/
@Singleton
@Component(immediate = true, service = ConnectedGraphProvider.class)
-public final class ConnectedGraphServer implements ConnectedGraphProvider, TransactionChainListener, AutoCloseable {
+public final class ConnectedGraphServer implements ConnectedGraphProvider, FutureCallback<Empty>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(ConnectedGraphServer.class);
private static final @NonNull InstanceIdentifier<GraphTopology> GRAPH_TOPOLOGY_IDENTIFIER =
InstanceIdentifier.create(GraphTopology.class);
private synchronized void initTransactionChain() {
LOG.debug("Initializing transaction chain for Graph Model Server {}", this);
checkState(chain == null, "Transaction chain has to be closed before being initialized");
- chain = dataBroker.createMergingTransactionChain(this);
+ chain = dataBroker.createMergingTransactionChain();
+ chain.addCallback(this);
}
/**
}
@Override
- public synchronized void onTransactionChainFailed(final TransactionChain transactionChain,
- final Transaction transaction, final Throwable cause) {
- LOG.error("GraphModel builder for {} failed in transaction: {} ", GRAPH_TOPOLOGY_IDENTIFIER,
- transaction != null ? transaction.getIdentifier() : null, cause);
+ public synchronized void onFailure(final Throwable cause) {
+ LOG.error("GraphModel builder for {} failed", GRAPH_TOPOLOGY_IDENTIFIER, cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain transactionChain) {
+ public void onSuccess(final Empty result) {
LOG.info("GraphModel builder for {} shut down", GRAPH_TOPOLOGY_IDENTIFIER);
}
import static java.util.Objects.requireNonNull;
import java.util.Collection;
+import java.util.List;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.GraphTopology;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.Graph;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.GraphKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.graph.Edge;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.graph.Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.graph.Vertex;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
private final ConnectedGraphProvider graphProvider;
- private ListenerRegistration<GraphListener> listenerRegistration;
+ private Registration listenerRegistration;
@Inject
@Activate
final var graphIdentifier = InstanceIdentifier.builder(GraphTopology.class).child(Graph.class).build();
listenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, graphIdentifier), this);
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, graphIdentifier), this);
LOG.info("Registered listener {} on Graph Model at {}", this, graphIdentifier);
}
final Collection<? extends DataObjectModification<? extends DataObject>> children) {
for (var child : children) {
final DataObject value;
- switch (child.getModificationType()) {
+ switch (child.modificationType()) {
case DELETE:
- value = child.getDataBefore();
+ value = child.dataBefore();
if (value instanceof Vertex vertex) {
cgraph.deleteVertex(vertex.key());
}
break;
case SUBTREE_MODIFIED:
case WRITE:
- value = child.getDataAfter();
+ value = child.dataAfter();
if (value instanceof Vertex vertex) {
cgraph.addVertex(vertex);
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Graph>> changes) {
- for (DataTreeModification<Graph> change : changes) {
- DataObjectModification<Graph> root = change.getRootNode();
- GraphKey key = change.getRootPath().getRootIdentifier().firstKeyOf(Graph.class);
- switch (root.getModificationType()) {
+ public void onDataTreeChanged(final List<DataTreeModification<Graph>> changes) {
+ for (var change : changes) {
+ final var root = change.getRootNode();
+ final var key = change.getRootPath().path().firstKeyOf(Graph.class);
+ switch (root.modificationType()) {
case DELETE:
graphProvider.deleteGraph(key);
break;
/* First look if the Graph was not already configured */
ConnectedGraph cgraph = graphProvider.getConnectedGraph(key);
if (cgraph == null) {
- graphProvider.addGraph(root.getDataAfter());
+ graphProvider.addGraph(root.dataAfter());
} else {
/* Graph exist, process Children */
- parseSubTree(cgraph, root.getModifiedChildren());
+ parseSubTree(cgraph, root.modifiedChildren());
}
break;
default:
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>8.0.4</version>
+ <version>9.0.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>11.0.5</version>
+ <version>13.0.1</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>12.0.4</version>
+ <version>13.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>6.0.6</version>
+ <version>7.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<groupId>${project.groupId}</groupId>
<artifactId>pcep-base-parser</artifactId>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>pcep-topology-api</artifactId>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
import org.opendaylight.graph.ConnectedGraph;
import org.opendaylight.graph.ConnectedGraphProvider;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.graph.topology.GraphKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
@Component(immediate = true)
public final class DefaultPceServerProvider implements PceServerProvider, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(DefaultPceServerProvider.class);
+
+ private final Map<TopologyId, PathManagerProvider> pathManagers = new HashMap<>();
+ private final Map<TopologyId, PathManagerListener> pathListeners = new HashMap<>();
+ private final Map<TopologyId, PcepTopologyListener> pcepListeners = new HashMap<>();
private final ConnectedGraphProvider graphProvider;
private final PathComputationProvider algoProvider;
private final DataBroker dataBroker;
- private final RpcConsumerRegistry rpcRegistry;
- private Map<TopologyId, PathManagerProvider> pathManagers = new HashMap<TopologyId, PathManagerProvider>();
- private Map<TopologyId, PathManagerListener> pathListeners = new HashMap<TopologyId, PathManagerListener>();
- private Map<TopologyId, PcepTopologyListener> pcepListeners = new HashMap<TopologyId, PcepTopologyListener>();
+ private final RpcService rpcService;
+
private volatile ConnectedGraph tedGraph;
private volatile GraphKey graphKey;
@Inject
@Activate
public DefaultPceServerProvider(@Reference final ConnectedGraphProvider graphProvider,
- @Reference final PathComputationProvider pathComputationProvider,
- @Reference final DataBroker dataBroker,
- @Reference final RpcConsumerRegistry rpcConsumerRegistry) {
+ @Reference final PathComputationProvider pathComputationProvider, @Reference final DataBroker dataBroker,
+ @Reference final RpcService rpcService) {
this.graphProvider = requireNonNull(graphProvider);
- this.algoProvider = requireNonNull(pathComputationProvider);
+ algoProvider = requireNonNull(pathComputationProvider);
this.dataBroker = requireNonNull(dataBroker);
- this.rpcRegistry = requireNonNull(rpcConsumerRegistry);
+ this.rpcService = requireNonNull(rpcService);
}
@Override
pathManagers.clear();
}
- private void closeListenerAndManager(TopologyId key) {
-
+ private void closeListenerAndManager(final TopologyId key) {
PathManagerListener pathListener = pathListeners.remove(key);
if (pathListener != null) {
pathListener.close();
}
@Override
- public void registerPcepTopology(KeyedInstanceIdentifier<Topology, TopologyKey> topology, GraphKey key) {
+ public void registerPcepTopology(final KeyedInstanceIdentifier<Topology, TopologyKey> topology,
+ final GraphKey key) {
TopologyId topoKey = requireNonNull(topology).getKey().getTopologyId();
- this.graphKey = requireNonNull(key);
+ graphKey = requireNonNull(key);
LOG.info("Start PCE Server components for Topology {} with TED {}", topoKey.getValue(), graphKey.getName());
closeListenerAndManager(topoKey);
/* Then create Path Manger */
- PathManagerProvider pathManager = new PathManagerProvider(dataBroker, topology, rpcRegistry, this);
+ PathManagerProvider pathManager = new PathManagerProvider(dataBroker, topology, rpcService, this);
/* And Listener */
PathManagerListener pathListener = new PathManagerListener(dataBroker, topology, pathManager);
}
@Override
- public void unRegisterPcepTopology(KeyedInstanceIdentifier<Topology, TopologyKey> topology) {
+ public void unRegisterPcepTopology(final KeyedInstanceIdentifier<Topology, TopologyKey> topology) {
TopologyId topoKey = requireNonNull(topology).getKey().getTopologyId();
- this.graphKey = null;
+ graphKey = null;
LOG.info("Stop PCE Server for Topology {}", topoKey.getValue());
closeListenerAndManager(topoKey);
import org.slf4j.LoggerFactory;
public class ManagedTeNode {
-
private enum NodeState {
Disabled,
Enabled,
Sync
}
+ private static final Logger LOG = LoggerFactory.getLogger(ManagedTeNode.class);
+
+ private final ConcurrentMap<ConfiguredLspKey, ManagedTePath> mngPaths = new ConcurrentHashMap<>();
+ private final TransactionChain chain;
private final NodeId id;
private NodeState state;
- private ConcurrentMap<ConfiguredLspKey, ManagedTePath> mngPaths =
- new ConcurrentHashMap<ConfiguredLspKey, ManagedTePath>();
- private final TransactionChain chain;
- private static final Logger LOG = LoggerFactory.getLogger(ManagedTeNode.class);
public ManagedTeNode(final NodeId id, final TransactionChain chain) {
this.id = id;
this.chain = chain;
- this.state = NodeState.Enabled;
+ state = NodeState.Enabled;
}
- public ManagedTeNode(final NodeId id, TransactionChain chain, final NodeState state) {
+ public ManagedTeNode(final NodeId id, final TransactionChain chain, final NodeState state) {
this.id = id;
this.chain = chain;
this.state = state;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.List;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.graph.ConnectedEdge;
import org.opendaylight.graph.ConnectedEdgeTrigger;
import org.opendaylight.graph.ConnectedGraph;
private static final Logger LOG = LoggerFactory.getLogger(ManagedTePath.class);
- public ManagedTePath(ManagedTeNode teNode, InstanceIdentifier<Topology> topology) {
+ public ManagedTePath(final ManagedTeNode teNode, final InstanceIdentifier<Topology> topology) {
this.teNode = requireNonNull(teNode);
- this.pcepTopology = requireNonNull(topology);
- this.pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
+ pcepTopology = requireNonNull(topology);
+ pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
.child(PathComputationClient.class).augmentation(PathComputationClient1.class);
}
- public ManagedTePath(ManagedTeNode teNode, final ConfiguredLsp lsp, InstanceIdentifier<Topology> topology) {
- this.cfgLsp = requireNonNull(lsp);
+ public ManagedTePath(final ManagedTeNode teNode, final ConfiguredLsp lsp,
+ final InstanceIdentifier<Topology> topology) {
+ cfgLsp = requireNonNull(lsp);
this.teNode = requireNonNull(teNode);
- this.pcepTopology = requireNonNull(topology);
- this.pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
+ pcepTopology = requireNonNull(topology);
+ pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
.child(PathComputationClient.class).augmentation(PathComputationClient1.class);
}
- public ManagedTePath(ManagedTeNode teNode, final ManagedTePath mngPath) {
+ public ManagedTePath(final ManagedTeNode teNode, final ManagedTePath mngPath) {
checkArgument(mngPath != null, "Managed TE Path is mandatory. Can't be null or empty!");
- this.cfgLsp = mngPath.getLsp();
- this.sent = mngPath.isSent();
- this.type = mngPath.getType();
+ cfgLsp = mngPath.getLsp();
+ sent = mngPath.isSent();
+ type = mngPath.getType();
this.teNode = requireNonNull(teNode);
- this.pcepTopology = mngPath.getTopology();
- this.pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
+ pcepTopology = mngPath.getTopology();
+ pccIdentifier = pcepTopology.child(Node.class, new NodeKey(teNode.getId())).augmentation(Node1.class)
.child(PathComputationClient.class).augmentation(PathComputationClient1.class);
}
}
public ManagedTePath setConfiguredLsp(final ConfiguredLsp lsp) {
- this.prevLsp = this.cfgLsp;
- this.cfgLsp = lsp;
+ prevLsp = cfgLsp;
+ cfgLsp = lsp;
return this;
}
- public ManagedTePath setType(PathType type) {
+ public ManagedTePath setType(final PathType type) {
this.type = type;
return this;
}
*
*/
public void sync() {
- this.cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Sync).build();
+ cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Sync).build();
updateToDataStore();
}
* Disabling this TE Path by marking it as Configured. Do not update the Data Store.
*/
public void disabled() {
- this.cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Configured).build();
+ cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Configured).build();
}
/**
* Mark this TE Path as Failed.
*/
public void failed() {
- this.cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Failed).build();
+ cfgLsp = new ConfiguredLspBuilder(cfgLsp).setPathStatus(PathStatus.Failed).build();
updateToDataStore();
}
return PathStatus.Sync;
}
- private void configureGraph(ConnectedGraph graph, ComputedPath cpath, Constraints cts, boolean config) {
+ private void configureGraph(final ConnectedGraph graph, final ComputedPath cpath, final Constraints cts,
+ final boolean config) {
/* Check that Connected Graph is valid */
if (graph == null) {
return;
triggerFlag = false;
}
- private boolean edgeAttrNotNull(ConnectedEdge edge) {
+ private static boolean edgeAttrNotNull(final ConnectedEdge edge) {
return edge != null && edge.getEdge() != null && edge.getEdge().getEdgeAttributes() != null;
}
- public void setGraph(ConnectedGraph graph) {
+ public void setGraph(final ConnectedGraph graph) {
configureGraph(graph, cfgLsp.getComputedPath(), cfgLsp.getIntendedPath().getConstraints(), true);
}
- public void unsetGraph(ConnectedGraph graph) {
+ public void unsetGraph(final ConnectedGraph graph) {
configureGraph(graph, cfgLsp.getComputedPath(), cfgLsp.getIntendedPath().getConstraints(), false);
}
- public void updateGraph(ConnectedGraph graph) {
+ public void updateGraph(final ConnectedGraph graph) {
/* First unset Bandwidth and Triggers for the old path if any */
if (prevLsp != null) {
configureGraph(graph, prevLsp.getComputedPath(), prevLsp.getIntendedPath().getConstraints(), false);
}
@Override
- public boolean verifyVertex(@Nullable ConnectedVertex next, @Nullable Vertex current) {
+ public boolean verifyVertex(final ConnectedVertex next, final Vertex current) {
/* Check if there is an on-going trigger */
if (triggerFlag) {
return false;
}
@Override
- public boolean verifyEdge(@Nullable ConnectedEdge next, @Nullable Edge current) {
+ public boolean verifyEdge(final ConnectedEdge next, final Edge current) {
/* Check if there is an on-going trigger */
if (triggerFlag) {
return false;
final Ipv4Builder ipBuilder = new Ipv4Builder()
.setDestinationIpv4Address(new Ipv4AddressNoZone(iPath.getDestination().getIpv4Address()))
.setSourceIpv4Address(new Ipv4AddressNoZone(iPath.getSource().getIpv4Address()));
- epb.setAddressFamily((new Ipv4CaseBuilder().setIpv4(ipBuilder.build()).build()));
+ epb.setAddressFamily(new Ipv4CaseBuilder().setIpv4(ipBuilder.build()).build());
} else if (cfgLsp.getIntendedPath().getSource().getIpv6Address() != null) {
final Ipv6Builder ipBuilder = new Ipv6Builder()
.setDestinationIpv6Address(new Ipv6AddressNoZone(iPath.getDestination().getIpv6Address()))
.setSourceIpv6Address(new Ipv6AddressNoZone(iPath.getSource().getIpv6Address()));
- epb.setAddressFamily((new Ipv6CaseBuilder().setIpv6(ipBuilder.build()).build()));
+ epb.setAddressFamily(new Ipv6CaseBuilder().setIpv6(ipBuilder.build()).build());
} else {
// In case of ...
return null;
*/
public ListenableFuture<RpcResult<AddLspOutput>> addPath(final AddLsp addLsp) {
/* Check if we could add this path */
- if ((type != PathType.Initiated) || !teNode.isSync()) {
+ if (type != PathType.Initiated || !teNode.isSync()) {
return null;
}
}
sent = true;
- final ListenableFuture<RpcResult<AddLspOutput>> enforce = addLsp.invoke(getAddLspInput());
+ final var enforce = addLsp.invoke(getAddLspInput());
LOG.info("Call Add LSP to {} with {}", addLsp, enforce);
- Futures.addCallback(enforce, new FutureCallback<RpcResult<AddLspOutput>>() {
+ Futures.addCallback(enforce, new FutureCallback<>() {
@Override
public void onSuccess(final RpcResult<AddLspOutput> result) {
if (result.isSuccessful()) {
*
* @return new Update LSP Input
*/
- private UpdateLspInput getUpdateLspInput() {
+ private @NonNull UpdateLspInput getUpdateLspInput() {
/* Create Path Setup Type */
final IntendedPath iPath = cfgLsp.getIntendedPath();
final PathSetupTypeBuilder pstBuilder = new PathSetupTypeBuilder();
public ListenableFuture<RpcResult<UpdateLspOutput>> updatePath(final UpdateLsp updateLsp) {
/* Check if we could update this path */
- if ((type != PathType.Initiated && type != PathType.Delegated) || !teNode.isSync()) {
+ if (type != PathType.Initiated && type != PathType.Delegated || !teNode.isSync()) {
return null;
}
sent = true;
final NodeId id = teNode.getId();
- final ListenableFuture<RpcResult<UpdateLspOutput>> enforce = updateLsp.invoke(getUpdateLspInput());
+ final var enforce = updateLsp.invoke(getUpdateLspInput());
LOG.info("Call Update LSP to {} with {}", updateLsp, enforce);
- Futures.addCallback(enforce, new FutureCallback<RpcResult<UpdateLspOutput>>() {
+ Futures.addCallback(enforce, new FutureCallback<>() {
@Override
public void onSuccess(final RpcResult<UpdateLspOutput> result) {
if (result.isSuccessful()) {
public ListenableFuture<RpcResult<RemoveLspOutput>> removePath(final RemoveLsp removeLsp) {
/* Check if we could remove this path */
- if ((type != PathType.Initiated) || !teNode.isSync() || cfgLsp.getPathStatus() != PathStatus.Sync) {
+ if (type != PathType.Initiated || !teNode.isSync() || cfgLsp.getPathStatus() != PathStatus.Sync) {
return null;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.lsp.attributes.Metrics;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.Requests;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.P2p;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.SubobjectType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.IpPrefixCase;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Uint32;
private VertexKey getDestinationVertexKey(final EndpointsObj endPoints) {
IpAddress address = null;
- if (endPoints.getAddressFamily() instanceof Ipv4Case) {
- address = new IpAddress(((Ipv4Case) endPoints.getAddressFamily()).getIpv4().getDestinationIpv4Address());
+ if (endPoints.getAddressFamily() instanceof Ipv4Case ipv4) {
+ address = new IpAddress(ipv4.getIpv4().getDestinationIpv4Address());
}
- if (endPoints.getAddressFamily() instanceof Ipv6Case) {
- address = new IpAddress(((Ipv6Case) endPoints.getAddressFamily()).getIpv6().getDestinationIpv6Address());
+ if (endPoints.getAddressFamily() instanceof Ipv6Case ipv6) {
+ address = new IpAddress(ipv6.getIpv6().getDestinationIpv6Address());
}
if (address == null) {
return null;
}
/* Convert Exclude Route Object (list of IP prefix) into Exclude Route (list of IP address) */
- private static List<ExcludeRoute> getExcludeRoute(final Xro xro, AddressFamily af) {
- if (xro == null || xro.getSubobject() == null || xro.getSubobject().isEmpty()) {
+ private static List<ExcludeRoute> getExcludeRoute(final Xro xro, final AddressFamily af) {
+ if (xro == null) {
+ return null;
+ }
+ final var subobjects = xro.getSubobject();
+ if (subobjects == null || subobjects.isEmpty()) {
return null;
}
- ArrayList<ExcludeRoute> erl = new ArrayList<ExcludeRoute>();
- for (int i = 0; i < xro.getSubobject().size(); i++) {
- final SubobjectType sbt = xro.getSubobject().get(i).getSubobjectType();
- if (sbt instanceof IpPrefixCase) {
- final IpPrefixCase ipc = (IpPrefixCase) sbt;
+
+ final var erl = new ArrayList<ExcludeRoute>();
+ for (var element : subobjects) {
+ final var sbt = element.getSubobjectType();
+ if (sbt instanceof IpPrefixCase ipc) {
switch (af) {
- case Ipv4:
- case SrIpv4:
- erl.add(new ExcludeRouteBuilder().setIpv4(new Ipv4Address(
+ case Ipv4, SrIpv4 -> {
+ erl.add(new ExcludeRouteBuilder()
+ .setIpv4(new Ipv4Address(
ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
- .build());
- break;
- case Ipv6:
- case SrIpv6:
- erl.add(new ExcludeRouteBuilder().setIpv6(new Ipv6Address(
+ .build());
+ }
+ case Ipv6, SrIpv6 -> {
+ erl.add(new ExcludeRouteBuilder()
+ .setIpv6(new Ipv6Address(
ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
- .build());
- break;
- default:
- break;
+ .build());
+ }
+ default -> {
+ // No-op
+ }
}
}
}
}
/* Convert Include Route Object (list of IP prefix) into Exclude Route (list of IP address) */
- private static List<IncludeRoute> getIncludeRoute(final Iro iro, AddressFamily af) {
- if (iro == null || iro.getSubobject() == null || iro.getSubobject().isEmpty()) {
+ private static List<IncludeRoute> getIncludeRoute(final Iro iro, final AddressFamily af) {
+ if (iro == null) {
+ return null;
+ }
+
+ final var subobjects = iro.getSubobject();
+ if (subobjects == null || subobjects.isEmpty()) {
return null;
}
- ArrayList<IncludeRoute> irl = new ArrayList<IncludeRoute>();
- for (int i = 0; i < iro.getSubobject().size(); i++) {
- final SubobjectType sbt = iro.getSubobject().get(i).getSubobjectType();
- if (sbt instanceof IpPrefixCase) {
- final IpPrefixCase ipc = (IpPrefixCase) sbt;
+ final var irl = new ArrayList<IncludeRoute>();
+ for (var element : subobjects) {
+ final var sbt = element.getSubobjectType();
+ if (sbt instanceof IpPrefixCase ipc) {
switch (af) {
- case Ipv4:
- case SrIpv4:
- irl.add(new IncludeRouteBuilder().setIpv4(new Ipv4Address(
+ case Ipv4, SrIpv4 -> {
+ irl.add(new IncludeRouteBuilder()
+ .setIpv4(new Ipv4Address(
ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
- .build());
- break;
- case Ipv6:
- case SrIpv6:
- irl.add(new IncludeRouteBuilder().setIpv6(new Ipv6Address(
+ .build());
+ }
+ case Ipv6, SrIpv6 -> {
+ irl.add(new IncludeRouteBuilder()
+ .setIpv6(new Ipv6Address(
ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
- .build());
- break;
- default:
- break;
+ .build());
+ }
+ default -> {
+ // No-op
+ }
}
}
}
import static java.util.Objects.requireNonNull;
-import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final class PathManagerListener implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(PathManagerListener.class);
- private ListenerRegistration<PathManagerListener> listenerRegistration;
+
+ private Registration listenerRegistration;
private final PathManagerProvider pathManager;
- public PathManagerListener(final DataBroker dataBroker, KeyedInstanceIdentifier<Topology, TopologyKey> topology,
- final PathManagerProvider pathManager) {
- requireNonNull(dataBroker);
- requireNonNull(topology);
+ public PathManagerListener(final DataBroker dataBroker,
+ final KeyedInstanceIdentifier<Topology, TopologyKey> topology, final PathManagerProvider pathManager) {
this.pathManager = requireNonNull(pathManager);
- final InstanceIdentifier<Node> nodeTopology = topology.child(Node.class);
- this.listenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, nodeTopology), this);
+ listenerRegistration = dataBroker.registerLegacyTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, topology.child(Node.class)), this);
LOG.info("Registered listener for Managed TE Path on Topology {}",
- topology.getKey().getTopologyId().getValue());
+ topology.getKey().getTopologyId().getValue());
}
/**
*/
@Override
public void close() {
- if (this.listenerRegistration != null) {
+ if (listenerRegistration != null) {
LOG.debug("Unregistered listener {} for Managed TE Path", this);
- this.listenerRegistration.close();
- this.listenerRegistration = null;
+ listenerRegistration.close();
+ listenerRegistration = null;
}
}
* @param nodeId Node Identifier to which the modified children belongs to.
* @param lspMod List of Configured LSP modifications.
*/
- private void handleLspChange(NodeId nodeId, List<? extends DataObjectModification<? extends DataObject>> lspMod) {
+ private void handleLspChange(final NodeId nodeId,
+ final List<? extends DataObjectModification<? extends DataObject>> lspMod) {
for (DataObjectModification<? extends DataObject> lsp : lspMod) {
ConfiguredLsp cfgLsp;
- switch (lsp.getModificationType()) {
+ switch (lsp.modificationType()) {
case DELETE:
- cfgLsp = (ConfiguredLsp) lsp.getDataBefore();
+ cfgLsp = (ConfiguredLsp) lsp.dataBefore();
LOG.debug("Delete Managed TE Path: {}", cfgLsp.getName());
pathManager.deleteManagedTePath(nodeId, cfgLsp.key());
break;
case SUBTREE_MODIFIED:
case WRITE:
- cfgLsp = (ConfiguredLsp) lsp.getDataAfter();
+ cfgLsp = (ConfiguredLsp) lsp.dataAfter();
LOG.debug("Update Managed TE Path {}", cfgLsp);
pathManager.createManagedTePath(nodeId, cfgLsp);
break;
* @param nodeId Node Identifier to which the modified children belongs to.
* @param pccMod List of PCEP Node Configuration modifications.
*/
- private void handlePccChange(NodeId nodeId, List<? extends DataObjectModification<? extends DataObject>> pccMod) {
- for (DataObjectModification<? extends DataObject> node : pccMod) {
+ private void handlePccChange(final NodeId nodeId,
+ final List<? extends DataObjectModification<? extends DataObject>> pccMod) {
+ for (var node : pccMod) {
/* First, process PCC modification */
- switch (node.getModificationType()) {
+ switch (node.modificationType()) {
case DELETE:
LOG.debug("Delete Managed TE Node: {}", nodeId);
pathManager.deleteManagedTeNode(nodeId);
case SUBTREE_MODIFIED:
case WRITE:
/* First look if the Managed TE Node belongs to this PCC was not already created */
- final PcepNodeConfig pccNode = (PcepNodeConfig) node.getDataAfter();
+ final var pccNode = (PcepNodeConfig) node.dataAfter();
if (!pathManager.checkManagedTeNode(nodeId)) {
LOG.info("Create new Managed Node {}", nodeId);
pathManager.createManagedTeNode(nodeId, pccNode);
} else {
/* Then, look to Configured LSP modification */
- final List<DataObjectModification<? extends DataObject>> lspMod = node.getModifiedChildren()
- .stream().filter(mod -> mod.getDataType().equals(ConfiguredLsp.class))
+ final var lspMod = node.modifiedChildren()
+ .stream().filter(mod -> mod.dataType().equals(ConfiguredLsp.class))
.collect(Collectors.toList());
if (!lspMod.isEmpty()) {
handleLspChange(nodeId, lspMod);
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
- for (DataTreeModification<Node> change : changes) {
- DataObjectModification<Node> root = change.getRootNode();
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
+ for (var change : changes) {
+ final var root = change.getRootNode();
- final String nodeAddr = root.getModificationType() == DataObjectModification.ModificationType.DELETE
- ? root.getDataBefore().getNodeId().getValue()
- : root.getDataAfter().getNodeId().getValue();
+ final String nodeAddr = root.modificationType() == DataObjectModification.ModificationType.DELETE
+ ? root.dataBefore().getNodeId().getValue()
+ : root.dataAfter().getNodeId().getValue();
NodeId nodeId;
if (nodeAddr.startsWith("pcc://")) {
nodeId = new NodeId(nodeAddr);
}
/* Look only to PcepNodeConfig.class modification */
- final List<DataObjectModification<? extends DataObject>> pccMod = root.getModifiedChildren().stream()
- .filter(mod -> mod.getDataType().equals(PcepNodeConfig.class)).collect(Collectors.toList());
+ final var pccMod = root.modifiedChildren().stream()
+ .filter(mod -> mod.dataType().equals(PcepNodeConfig.class))
+ .collect(Collectors.toList());
if (!pccMod.isEmpty()) {
handlePccChange(nodeId, pccMod);
}
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
+import com.google.common.util.concurrent.FutureCallback;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.PreDestroy;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.graph.ConnectedEdge;
import org.opendaylight.graph.ConnectedEdgeTrigger;
import org.opendaylight.graph.ConnectedGraph;
import org.opendaylight.graph.ConnectedVertex;
import org.opendaylight.graph.ConnectedVertexTrigger;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
-import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.mdsal.binding.api.TransactionChain;
-import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.Edge;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev220720.Vertex;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.path.computation.rev220324.ComputationStatus;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.osgi.service.component.annotations.Deactivate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Olivier Dugeon
*/
-public final class PathManagerProvider implements TransactionChainListener, AutoCloseable, ConnectedGraphTrigger {
+public final class PathManagerProvider implements FutureCallback<Empty>, AutoCloseable, ConnectedGraphTrigger {
private static final Logger LOG = LoggerFactory.getLogger(PathManagerProvider.class);
private final InstanceIdentifier<Topology> pcepTopology;
private final DataBroker dataBroker;
private TransactionChain chain = null;
private ConnectedGraph tedGraph = null;
- private final Map<NodeId, ManagedTeNode> mngNodes = new HashMap<NodeId, ManagedTeNode>();
+ private final Map<NodeId, ManagedTeNode> mngNodes = new HashMap<>();
- public PathManagerProvider(final DataBroker dataBroker, KeyedInstanceIdentifier<Topology, TopologyKey> topology,
- final RpcConsumerRegistry rpcRegistry, final DefaultPceServerProvider pceServerProvider) {
+ public PathManagerProvider(final DataBroker dataBroker,
+ final KeyedInstanceIdentifier<Topology, TopologyKey> topology, final RpcService rpcService,
+ final DefaultPceServerProvider pceServerProvider) {
this.dataBroker = requireNonNull(dataBroker);
this.pceServerProvider = requireNonNull(pceServerProvider);
- this.addLsp = rpcRegistry.getRpc(AddLsp.class);
- this.updateLsp = rpcRegistry.getRpc(UpdateLsp.class);
- this.removeLsp = rpcRegistry.getRpc(RemoveLsp.class);
- this.pcepTopology = requireNonNull(topology);
+ addLsp = rpcService.getRpc(AddLsp.class);
+ updateLsp = rpcService.getRpc(UpdateLsp.class);
+ removeLsp = rpcService.getRpc(RemoveLsp.class);
+ pcepTopology = requireNonNull(topology);
initTransactionChain();
tedGraph = getGraph();
LOG.info("Path Manager Server started for topology {}", topology.getKey().getTopologyId().getValue());
@Deactivate
@PreDestroy
public void close() {
- this.tedGraph = pceServerProvider.getTedGraph();
+ tedGraph = pceServerProvider.getTedGraph();
if (tedGraph != null) {
tedGraph.unRegisterTrigger(this, InstanceIdentifier.keyOf(pcepTopology));
}
private ConnectedGraph getGraph() {
if (tedGraph == null) {
- this.tedGraph = pceServerProvider.getTedGraph();
+ tedGraph = pceServerProvider.getTedGraph();
if (tedGraph != null) {
tedGraph.registerTrigger(this, InstanceIdentifier.keyOf(pcepTopology));
}
*/
private synchronized void initTransactionChain() {
LOG.debug("Initializing transaction chain for Path Manager Server {}", this);
- checkState(this.chain == null, "Transaction chain has to be closed before being initialized");
- this.chain = dataBroker.createMergingTransactionChain(this);
+ checkState(chain == null, "Transaction chain has to be closed before being initialized");
+ chain = dataBroker.createMergingTransactionChain();
+ chain.addCallback(this);
}
/**
* Destroy the current transaction chain.
*/
private synchronized void destroyTransactionChain() {
- if (this.chain != null) {
+ if (chain != null) {
LOG.debug("Destroy transaction chain for Path Manager {}", this);
- this.chain = null;
+ chain = null;
}
}
}
@Override
- public synchronized void onTransactionChainFailed(final TransactionChain transactionChain,
- final Transaction transaction, final Throwable cause) {
- LOG.error("Path Manager Provider for {} failed in transaction: {} ", pcepTopology,
- transaction != null ? transaction.getIdentifier() : null, cause);
+ public synchronized void onFailure(final Throwable cause) {
+ LOG.error("Path Manager Provider for {}", pcepTopology, cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain transactionChain) {
+ public void onSuccess(final Empty value) {
LOG.info("Path Manager Provider for {} shut down", pcepTopology);
}
*
* @param mngPath Managed TE Path to be updated
*/
- private void updateComputedPath(final ManagedTePath mngPath, boolean add) {
+ private void updateComputedPath(final ManagedTePath mngPath, final boolean add) {
checkArgument(mngPath != null, "Provided Managed TE Path is a null object");
final ManagedTeNode teNode = mngPath.getManagedTeNode();
*
* @return new or updated TE Path i.e. original TE Path augmented by a valid computed route.
*/
- public ConfiguredLsp createManagedTePath(final NodeId id, ConfiguredLsp cfgLsp) {
+ public ConfiguredLsp createManagedTePath(final NodeId id, final ConfiguredLsp cfgLsp) {
checkArgument(id != null, "Provided Node ID is a null object");
checkArgument(cfgLsp != null, "Provided TE Path is a null object");
*
* @return Newly created or Updated Managed TE Path
*/
- public ManagedTePath registerTePath(NodeId id, final ConfiguredLsp rptPath, final PathType ptype) {
+ public ManagedTePath registerTePath(final NodeId id, final ConfiguredLsp rptPath, final PathType ptype) {
checkArgument(id != null, "Provided Node ID is a null object");
/* Verify we got a valid reported TE Path */
}
/* Check if Current Path has no valid route while Reported Path has one */
- if ((curPath.getLsp().getComputedPath().getPathDescription() == null)
- && (rptPath.getComputedPath().getPathDescription() != null)) {
+ if (curPath.getLsp().getComputedPath().getPathDescription() == null
+ && rptPath.getComputedPath().getPathDescription() != null) {
curPath.setConfiguredLsp(new ConfiguredLspBuilder(rptPath).setPathStatus(PathStatus.Sync).build());
curPath.updateGraph(getGraph());
curPath.updateToDataStore();
* @return True if Managed TE Node exist, false otherwise
*/
public boolean checkManagedTeNode(final NodeId id) {
- return (mngNodes.get(id) != null);
+ return mngNodes.get(id) != null;
}
/**
}
@Override
- public void verifyVertex(Collection<ConnectedVertexTrigger> triggers, @Nullable ConnectedVertex current,
- @Nullable Vertex next) {
+ public void verifyVertex(final Collection<ConnectedVertexTrigger> triggers, final ConnectedVertex current,
+ final Vertex next) {
for (ConnectedVertexTrigger trigger : triggers) {
if (trigger.verifyVertex(current, next)) {
updateComputedPath((ManagedTePath )trigger, false);
}
@Override
- public void verifyEdge(Collection<ConnectedEdgeTrigger> triggers, @Nullable ConnectedEdge current,
- @Nullable Edge next) {
+ public void verifyEdge(final Collection<ConnectedEdgeTrigger> triggers, final ConnectedEdge current,
+ final Edge next) {
for (ConnectedEdgeTrigger trigger : triggers) {
if (trigger.verifyEdge(current, next)) {
updateComputedPath((ManagedTePath )trigger, false);
import com.google.common.collect.Iterables;
import java.nio.ByteBuffer;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Path1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.identifiers.tlv.lsp.identifiers.address.family.Ipv4Case;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.identifiers.tlv.lsp.identifiers.address.family.Ipv6Case;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.identifiers.tlv.lsp.identifiers.address.family.ipv4._case.Ipv4;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.identifiers.tlv.lsp.identifiers.address.family.ipv6._case.Ipv6;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object.Lsp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev200720.SrSubobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev200720.sr.subobject.nai.IpAdjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.server.rev220321.pcc.configured.lsp.configured.lsp.IntendedPathBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.server.rev220321.pcc.configured.lsp.configured.lsp.intended.path.ConstraintsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.explicit.route.object.Ero;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.explicit.route.object.ero.Subobject;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.lsp.attributes.Metrics;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.reported.route.object.Rro;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.SubobjectType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.IpPrefixCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev220730.Node1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev220730.PccSyncState;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Uint32;
public final class PcepTopologyListener implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(PcepTopologyListener.class);
- private ListenerRegistration<PcepTopologyListener> listenerRegistration;
+
private final PathManagerProvider pathManager;
+ private Registration listenerRegistration;
+
public PcepTopologyListener(final DataBroker dataBroker,
final KeyedInstanceIdentifier<Topology, TopologyKey> topology, final PathManagerProvider pathManager) {
- requireNonNull(dataBroker);
- requireNonNull(topology);
this.pathManager = requireNonNull(pathManager);
- final InstanceIdentifier<Node> nodeTopology = topology.child(Node.class);
- listenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, nodeTopology), this);
+ listenerRegistration = dataBroker.registerLegacyTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, topology.child(Node.class)), this);
LOG.info("Registered PCE Server listener {} for Operational PCEP Topology {}",
listenerRegistration, topology.getKey().getTopologyId().getValue());
}
for (DataObjectModification<?> lsp : lspMod) {
ReportedLsp rptLsp;
- switch (lsp.getModificationType()) {
+ switch (lsp.modificationType()) {
case DELETE:
- rptLsp = (ReportedLsp) lsp.getDataBefore();
+ rptLsp = (ReportedLsp) lsp.dataBefore();
LOG.debug("Un-Register Managed TE Path: {}", rptLsp.getName());
pathManager.unregisterTePath(nodeId, new ConfiguredLspKey(rptLsp.getName()));
break;
case SUBTREE_MODIFIED:
case WRITE:
- rptLsp = (ReportedLsp) lsp.getDataAfter();
+ rptLsp = (ReportedLsp) lsp.dataAfter();
LOG.debug("Register Managed TE Path {}", rptLsp.getName());
pathManager.registerTePath(nodeId, getConfiguredLsp(rptLsp), getPathType(rptLsp));
break;
default:
break;
}
-
}
}
private void handlePccChange(final NodeId nodeId, final List<DataObjectModification<?>> pccMod) {
for (DataObjectModification<?> node : pccMod) {
/* First, process PCC modification */
- switch (node.getModificationType()) {
+ switch (node.modificationType()) {
case DELETE:
LOG.debug("Un-Register Managed TE Node: {}", nodeId);
pathManager.disableManagedTeNode(nodeId);
/* First look if the PCC was already created or not yet */
if (pathManager.checkManagedTeNode(nodeId)) {
/* Check if PCC State is Synchronized */
- if (node.getModifiedChildren() == null || node.getModifiedChildren().isEmpty()) {
- PathComputationClient pcc = (PathComputationClient) node.getDataAfter();
+ if (node.modifiedChildren() == null || node.modifiedChildren().isEmpty()) {
+ PathComputationClient pcc = (PathComputationClient) node.dataAfter();
if (pcc.getStateSync() == PccSyncState.Synchronized) {
LOG.debug("Synchronize Managed TE Node {}", nodeId);
pathManager.syncManagedTeNode(nodeId);
}
/* Then, look to reported LSP modification */
- final List<DataObjectModification<? extends DataObject>> lspMod = node.getModifiedChildren()
- .stream().filter(mod -> mod.getDataType().equals(ReportedLsp.class))
+ final List<DataObjectModification<? extends DataObject>> lspMod = node.modifiedChildren()
+ .stream().filter(mod -> mod.dataType().equals(ReportedLsp.class))
.collect(Collectors.toList());
if (!lspMod.isEmpty()) {
handleLspChange(nodeId, lspMod);
private void handleNode1Change(final NodeId nodeId, final List<DataObjectModification<?>> node1Mod) {
for (DataObjectModification<?> child : node1Mod) {
/* Then, look only to PathComputationClient.class modification */
- final List<DataObjectModification<?>> pccMod = child.getModifiedChildren()
- .stream().filter(mod -> mod.getDataType().equals(PathComputationClient.class))
+ final List<DataObjectModification<?>> pccMod = child.modifiedChildren()
+ .stream().filter(mod -> mod.dataType().equals(PathComputationClient.class))
.collect(Collectors.toList());
if (!pccMod.isEmpty()) {
handlePccChange(nodeId, pccMod);
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
- for (DataTreeModification<Node> change : changes) {
- DataObjectModification<Node> root = change.getRootNode();
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
+ for (var change : changes) {
+ final var root = change.getRootNode();
final NodeId nodeId =
- root.getModificationType() == DataObjectModification.ModificationType.DELETE
- ? root.getDataBefore().getNodeId()
- : root.getDataAfter().getNodeId();
+ root.modificationType() == DataObjectModification.ModificationType.DELETE
+ ? root.dataBefore().getNodeId() : root.dataAfter().getNodeId();
/* Look only to Node1.class modification */
- final List<DataObjectModification<?>> node1Mod = root.getModifiedChildren().stream()
- .filter(mod -> mod.getDataType().equals(Node1.class))
+ final List<DataObjectModification<?>> node1Mod = root.modifiedChildren().stream()
+ .filter(mod -> mod.dataType().equals(Node1.class))
.collect(Collectors.toList());
if (!node1Mod.isEmpty()) {
handleNode1Change(nodeId, node1Mod);
* @return Path Description of the corresponding ERO SubObject.
*/
private static PathDescription getSrPath(final SrSubobject srObj, final AddressFamily af) {
- switch (af) {
- case SrIpv4:
- switch (srObj.getNaiType()) {
- case Ipv4Adjacency:
- return new PathDescriptionBuilder()
- .setSid(srObj.getSid())
- .setIpv4(((IpAdjacency)srObj.getNai()).getLocalIpAddress().getIpv4AddressNoZone())
- .setRemoteIpv4(((IpAdjacency)srObj.getNai()).getRemoteIpAddress().getIpv4AddressNoZone())
- .build();
- case Ipv4NodeId:
- return new PathDescriptionBuilder()
- .setSid(srObj.getSid())
- .setRemoteIpv4(((IpNodeId)srObj.getNai()).getIpAddress().getIpv4AddressNoZone())
- .build();
- default:
- return null;
- }
- case SrIpv6:
- switch (srObj.getNaiType()) {
- case Ipv6Adjacency:
- return new PathDescriptionBuilder()
- .setSid(srObj.getSid())
- .setIpv6(((IpAdjacency)srObj.getNai()).getLocalIpAddress().getIpv6AddressNoZone())
- .setRemoteIpv6(((IpAdjacency)srObj.getNai()).getRemoteIpAddress().getIpv6AddressNoZone())
- .build();
- case Ipv6NodeId:
- return new PathDescriptionBuilder()
- .setSid(srObj.getSid())
- .setRemoteIpv6(((IpNodeId)srObj.getNai()).getIpAddress().getIpv6AddressNoZone())
- .build();
- default:
- return null;
- }
- default:
- return null;
- }
+ return switch (af) {
+ case SrIpv4 -> switch (srObj.getNaiType()) {
+ case Ipv4Adjacency -> new PathDescriptionBuilder()
+ .setSid(srObj.getSid())
+ .setIpv4(((IpAdjacency)srObj.getNai()).getLocalIpAddress().getIpv4AddressNoZone())
+ .setRemoteIpv4(((IpAdjacency)srObj.getNai()).getRemoteIpAddress().getIpv4AddressNoZone())
+ .build();
+ case Ipv4NodeId -> new PathDescriptionBuilder()
+ .setSid(srObj.getSid())
+ .setRemoteIpv4(((IpNodeId)srObj.getNai()).getIpAddress().getIpv4AddressNoZone())
+ .build();
+ default -> null;
+ };
+ case SrIpv6 -> switch (srObj.getNaiType()) {
+ case Ipv6Adjacency -> new PathDescriptionBuilder()
+ .setSid(srObj.getSid())
+ .setIpv6(((IpAdjacency)srObj.getNai()).getLocalIpAddress().getIpv6AddressNoZone())
+ .setRemoteIpv6(((IpAdjacency)srObj.getNai()).getRemoteIpAddress().getIpv6AddressNoZone())
+ .build();
+ case Ipv6NodeId -> new PathDescriptionBuilder()
+ .setSid(srObj.getSid())
+ .setRemoteIpv6(((IpNodeId)srObj.getNai()).getIpAddress().getIpv6AddressNoZone())
+ .build();
+ default -> null;
+ };
+ default -> null;
+ };
}
/**
* @return Path Description of the corresponding ERO SubObject.
*/
private static PathDescription getIpPath(final IpPrefixCase ipc, final AddressFamily af) {
- switch (af) {
- case Ipv4:
- return new PathDescriptionBuilder().setRemoteIpv4(
- new Ipv4Address(ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
- .build();
- case Ipv6:
- return new PathDescriptionBuilder().setRemoteIpv6(
- new Ipv6Address(ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
- .build();
- default:
- return null;
- }
+ return switch (af) {
+ case Ipv4 -> new PathDescriptionBuilder()
+ .setRemoteIpv4(
+ new Ipv4Address(ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
+ .build();
+ case Ipv6 -> new PathDescriptionBuilder()
+ .setRemoteIpv6(
+ new Ipv6Address(ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
+ .build();
+ default -> null;
+ };
}
/**
*/
private static PathDescription getIpPath(final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
.rsvp.rev150820._record.route.subobjects.subobject.type.IpPrefixCase ipc, final AddressFamily af) {
- switch (af) {
- case Ipv4:
- return new PathDescriptionBuilder().setRemoteIpv4(
- new Ipv4Address(ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
- .build();
- case Ipv6:
- return new PathDescriptionBuilder().setRemoteIpv6(
- new Ipv6Address(ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
- .build();
- default:
- return null;
- }
+ return switch (af) {
+ case Ipv4 -> new PathDescriptionBuilder()
+ .setRemoteIpv4(
+ new Ipv4Address(ipc.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue().split("/")[0]))
+ .build();
+ case Ipv6 -> new PathDescriptionBuilder()
+ .setRemoteIpv6(
+ new Ipv6Address(ipc.getIpPrefix().getIpPrefix().getIpv6Prefix().getValue().split("/")[0]))
+ .build();
+ default -> null;
+ };
}
/**
* @return Path Description of the corresponding TE Path.
*/
private static List<PathDescription> getPathDescription(final Ero ero, final AddressFamily af) {
- final ArrayList<PathDescription> pathDesc = new ArrayList<>();
- for (Subobject element : ero.getSubobject()) {
- final SubobjectType sbt = element.getSubobjectType();
- if (sbt instanceof SrSubobject) {
- pathDesc.add(getSrPath((SrSubobject) sbt, af));
- } else if (sbt instanceof IpPrefixCase) {
- pathDesc.add(getIpPath((IpPrefixCase) sbt, af));
+ final var pathDesc = new ArrayList<PathDescription>();
+ for (var element : ero.nonnullSubobject()) {
+ final var sbt = element.getSubobjectType();
+ if (sbt instanceof SrSubobject sr) {
+ pathDesc.add(getSrPath(sr, af));
+ } else if (sbt instanceof IpPrefixCase ip) {
+ pathDesc.add(getIpPath(ip, af));
}
}
return pathDesc.isEmpty() ? null : pathDesc;
* @return Path Description of the corresponding TE Path.
*/
private static List<PathDescription> getPathDescription(final Rro rro, final AddressFamily af) {
- final ArrayList<PathDescription> pathDesc = new ArrayList<>();
+ final var pathDesc = new ArrayList<PathDescription>();
for (var element : rro.nonnullSubobject()) {
final var sbt = element.getSubobjectType();
- if (sbt instanceof SrSubobject) {
- pathDesc.add(getSrPath((SrSubobject) sbt, af));
- } else if (sbt instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820
- ._record.route.subobjects.subobject.type.IpPrefixCase) {
- pathDesc.add(getIpPath((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820
- ._record.route.subobjects.subobject.type.IpPrefixCase)sbt, af));
+ if (sbt instanceof SrSubobject sr) {
+ pathDesc.add(getSrPath(sr, af));
+ } else if (sbt
+ instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820._record
+ .route.subobjects.subobject.type.IpPrefixCase ip) {
+ pathDesc.add(getIpPath(ip, af));
}
}
return pathDesc.isEmpty() ? null : pathDesc;
cb.setBandwidth(new DecimalBandwidth(Decimal64.valueOf(2, convert.longValue())));
}
if (path.getMetrics() != null) {
- for (Metrics metric: path.getMetrics()) {
+ for (var metric : path.getMetrics()) {
convert = ByteBuffer.wrap(metric.getMetric().getValue().getValue()).getFloat();
switch (metric.getMetric().getMetricType().intValue()) {
case MessagesUtil.IGP_METRIC:
final Path1 p1 = path.augmentation(Path1.class);
final Uint8 pst = p1.getPathSetupType() != null ? p1.getPathSetupType().getPst() : Uint8.ZERO;
final Lsp lsp = p1.getLsp();
- final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp
- .identifiers.tlv.lsp.identifiers.AddressFamily af = lsp.getTlvs().getLspIdentifiers().getAddressFamily();
+ final var af = lsp.getTlvs().getLspIdentifiers().getAddressFamily();
IpAddress source = null;
IpAddress destination = null;
- if (af instanceof Ipv4Case) {
- final Ipv4 ipv4 = ((Ipv4Case) af).getIpv4();
+ if (af instanceof Ipv4Case v4) {
+ final var ipv4 = v4.getIpv4();
source = new IpAddress(ipv4.getIpv4TunnelSenderAddress());
destination = new IpAddress(ipv4.getIpv4TunnelEndpointAddress());
cb.setAddressFamily(pst == Uint8.ZERO ? AddressFamily.Ipv4 : AddressFamily.SrIpv4);
- } else if (af instanceof Ipv6Case) {
- final Ipv6 ipv6 = ((Ipv6Case) af).getIpv6();
+ } else if (af instanceof Ipv6Case v6) {
+ final var ipv6 = v6.getIpv6();
source = new IpAddress(ipv6.getIpv6TunnelSenderAddress());
destination = new IpAddress(ipv6.getIpv6TunnelSenderAddress());
cb.setAddressFamily(pst == Uint8.ZERO ? AddressFamily.Ipv6 : AddressFamily.SrIpv6);
}
return PathType.Initiated;
}
-
}
</properties>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.guicedee.services</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
+ <scope>provided</scope>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>pcep-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
- <dependency>
- <groupId>jakarta.annotation</groupId>
- <artifactId>jakarta.annotation-api</artifactId>
- <scope>provided</scope>
- <optional>true</optional>
- </dependency>
- <dependency>
- <groupId>com.guicedee.services</groupId>
- <artifactId>javax.inject</artifactId>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>pcep-impl</artifactId>
</dependency>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
<!-- Test dependencies -->
<dependency>
import com.google.common.annotations.VisibleForTesting;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.InetSocketAddress;
-import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
final class PCEPStatefulPeerProposal extends AbstractRegistration implements PCEPPeerProposal {
- private abstract static class AbstractListener<D extends DataObject, V>
- implements ClusteredDataTreeChangeListener<D> {
+ private abstract static class AbstractListener<D extends DataObject, V> implements DataTreeChangeListener<D> {
final Map<NodeId, V> map = new ConcurrentHashMap<>();
final Registration reg;
justification = "Stateless specializations in this nest")
AbstractListener(final DataBroker dataBroker, final @NonNull LogicalDatastoreType datastore,
final @NonNull InstanceIdentifier<D> wildcard) {
- reg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(datastore, wildcard), this);
+ reg = dataBroker.registerTreeChangeListener(DataTreeIdentifier.of(datastore, wildcard), this);
}
final void remove(final DataTreeModification<?> modification) {
}
private static @NonNull NodeId extractNodeId(final DataTreeModification<?> modification) {
- return verifyNotNull(modification.getRootPath().getRootIdentifier().firstKeyOf(Node.class)).getNodeId();
+ return verifyNotNull(modification.getRootPath().path().firstKeyOf(Node.class)).getNodeId();
}
}
}
@Override
- public void onDataTreeChanged(final
Collection<DataTreeModification<PcepNodeSyncConfig>> changes) {
+ public void onDataTreeChanged(final
List<DataTreeModification<PcepNodeSyncConfig>> changes) {
for (var change : changes) {
- final var config = change.getRootNode().getDataAfter();
+ final var config = change.getRootNode().dataAfter();
if (config != null) {
update(change, config.getSpeakerEntityIdValue());
} else {
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<LspDbVersion>> changes) {
+ public void onDataTreeChanged(final List<DataTreeModification<LspDbVersion>> changes) {
for (var change : changes) {
- update(change, change.getRootNode().getDataAfter());
+ update(change, change.getRootNode().dataAfter());
}
}
}
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.ListenableFuture;
-import java.util.Collection;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
* This class tracks the configuration content of a particular topology instance and propagates updates towards its
* associated {@link PCEPTopologyProvider}.
*/
-final class PCEPTopologyInstance implements ClusteredDataTreeChangeListener<Topology> {
+final class PCEPTopologyInstance implements DataListener<Topology> {
private static final Logger LOG = LoggerFactory.getLogger(PCEPTopologyInstance.class);
private final @NonNull TopologyKey topology;
provider = new PCEPTopologyProvider(instanceIdentifier, dependencies, scheduler);
- reg = dependencies.getDataBroker().registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), this);
+ reg = dependencies.getDataBroker().registerDataListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), this);
LOG.info("Topology instance for {} initialized", topologyId());
}
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<Topology>> changes) {
+ public synchronized void dataChangedTo(final Topology data) {
if (reg == null) {
// We have been shut down, do not process any more updates
return;
}
- // We are only interested in the after-image
- final var content = Iterables.getLast(changes).getRootNode().getDataAfter();
- if (content != null) {
- LOG.trace("Updating topology {} configuration to {}", topologyId(), content);
- provider.updateConfiguration(PCEPTopologyConfiguration.of(content));
+ if (data != null) {
+ LOG.trace("Updating topology {} configuration to {}", topologyId(), data);
+ provider.updateConfiguration(PCEPTopologyConfiguration.of(data));
} else {
LOG.info("Topology {} configuration disappeared, ignoring update in anticipation of shutdown",
topologyId());
import org.checkerframework.checker.lock.qual.Holding;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.Empty;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
-import java.util.Collection;
+import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.bgpcep.pcep.server.PceServerProvider;
import org.opendaylight.bgpcep.programming.spi.InstructionSchedulerFactory;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.pcep.MessageRegistry;
import org.opendaylight.protocol.pcep.PCEPDispatcher;
import org.opendaylight.protocol.pcep.spi.PCEPExtensionConsumerContext;
@Singleton
@Component(service = { })
public final class PCEPTopologyTracker
- implements PCEPTopologyProviderDependencies, ClusteredDataTreeChangeListener<TopologyPcep>, AutoCloseable {
+ implements PCEPTopologyProviderDependencies, DataTreeChangeListener<TopologyPcep>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(PCEPTopologyTracker.class);
// Services we are using
statsProvider = new TopologyStatsProvider(timer);
statsRpcs = new TopologyStatsRpc(dataBroker, rpcProviderRegistry);
- reg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ reg = dataBroker.registerTreeChangeListener(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(TopologyTypes.class)
.augmentation(TopologyTypes1.class).child(TopologyPcep.class).build()), this);
LOG.info("PCEP Topology tracker initialized");
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<TopologyPcep>> changes) {
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<TopologyPcep>> changes) {
if (reg == null) {
// Registration has been terminated, do not process any changes
return;
for (var change : changes) {
final var root = change.getRootNode();
- switch (root.getModificationType()) {
+ switch (root.modificationType()) {
case WRITE:
// We only care if the topology has been newly introduced, not when its details have changed
- if (root.getDataBefore() == null) {
+ if (root.dataBefore() == null) {
createInstance(extractTopologyKey(change));
}
break;
}
private static @NonNull TopologyKey extractTopologyKey(final DataTreeModification<?> change) {
- final var path = change.getRootPath().getRootIdentifier();
+ final var path = change.getRootPath().path();
return verifyNotNull(path.firstKeyOf(Topology.class), "No topology key in %s", path);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-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.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// This class is thread-safe
-final class TopologyNodeState implements TransactionChainListener {
+final class TopologyNodeState implements FutureCallback<Empty> {
private static final Logger LOG = LoggerFactory.getLogger(TopologyNodeState.class);
private final Map<String, Metadata> metadata = new HashMap<>();
checkArgument(holdStateNanos >= 0);
nodeId = topology.child(Node.class, new NodeKey(id));
this.holdStateNanos = holdStateNanos;
- chain = broker.createMergingTransactionChain(this);
+ chain = broker.createMergingTransactionChain();
+ chain.addCallback(this);
}
@NonNull KeyedInstanceIdentifier<Node, NodeKey> getNodeId() {
}
@Override
- public void onTransactionChainFailed(final TransactionChain pchain, final Transaction transaction,
- final Throwable cause) {
+ public void onFailure(final Throwable cause) {
// FIXME: flip internal state, so that the next attempt to update fails, triggering node reconnect
- LOG.error("Unexpected transaction failure in node {} transaction {}", nodeId, transaction.getIdentifier(),
- cause);
+ LOG.error("Unexpected transaction failure in node {}", nodeId, cause);
close();
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain pchain) {
+ public void onSuccess(final Empty result) {
LOG.info("Node {} shutdown successfully", nodeId);
}
package org.opendaylight.bgpcep.pcep.topology.provider;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import org.opendaylight.bgpcep.programming.spi.SuccessfulRpcResult;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class TopologyStatsRpc implements
ClusteredDataTreeChangeListener<PcepSessionState>, AutoCloseable {
+final class TopologyStatsRpc implements DataTreeChangeListener<PcepSessionState>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TopologyStatsRpc.class);
private final ConcurrentMap<InstanceIdentifier<PcepSessionState>, PcepSessionState> sessionStateMap =
TopologyStatsRpc(final DataBroker dataBroker, final RpcProviderService rpcProviderService) {
LOG.info("Initializing PCEP Topology Stats RPC service.");
- listenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
+ listenerRegistration = dataBroker.registerTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class)
.augmentation(PcepTopologyNodeStatsAug.class).child(PcepSessionState.class).build()),
this);
- rpcRegistration = rpcProviderService.registerRpcImplementations(ImmutableClassToInstanceMap.of(
- GetStats.class, this::getStats));
+ rpcRegistration = rpcProviderService.registerRpcImplementation((GetStats) this::getStats);
}
@Override
- public void onDataTreeChanged(final
Collection<DataTreeModification<PcepSessionState>> changes) {
+ public void onDataTreeChanged(final
List<DataTreeModification<PcepSessionState>> changes) {
changes.forEach(change -> {
- final InstanceIdentifier<PcepSessionState> iid = change.getRootPath().getRootIdentifier();
- final DataObjectModification<PcepSessionState> mod = change.getRootNode();
- switch (mod.getModificationType()) {
- case SUBTREE_MODIFIED:
- case WRITE:
- sessionStateMap.put(iid, mod.getDataAfter());
+ final var iid = change.getRootPath().path();
+ final var mod = change.getRootNode();
+ switch (mod.modificationType()) {
+ case SUBTREE_MODIFIED, WRITE:
+ sessionStateMap.put(iid, mod.dataAfter());
break;
case DELETE:
sessionStateMap.remove(iid);
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.bgpcep.pcep.topology.provider.PCEPStatefulPeerProposal.LspDbVersionListener;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
@Mock
private DataBroker dataBroker;
@Mock
- private ListenerRegistration<?> listenerReg;
+ private Registration listenerReg;
@Mock
private FluentFuture<Optional<LspDbVersion>> listenableFutureMock;
-
+ @Captor
private ArgumentCaptor<DataTreeChangeListener<?>> captor;
+
private TlvsBuilder tlvsBuilder;
@Before
tlvsBuilder = new TlvsBuilder().addAugmentation(new Tlvs1Builder()
.setStateful(new StatefulBuilder().addAugmentation(new Stateful1Builder().build()).build())
.build());
- captor = ArgumentCaptor.forClass(DataTreeChangeListener.class);
- doReturn(listenerReg).when(dataBroker).registerDataTreeChangeListener(any(), captor.capture());
+ doReturn(listenerReg).when(dataBroker).registerTreeChangeListener(any(), captor.capture());
doNothing().when(listenerReg).close();
}
new NodeKey(ServerSessionManager.createNodeId(ADDRESS.getAddress())));
final var dbverRoot = mock(DataObjectModification.class);
- doReturn(LSP_DB_VERSION).when(dbverRoot).getDataAfter();
+ doReturn(LSP_DB_VERSION).when(dbverRoot).dataAfter();
final var dbverMod = mock(DataTreeModification.class);
- doReturn(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
doReturn(dbverRoot).when(dbverMod).getRootNode();
- for (DataTreeChangeListener<?> listener : listeners) {
+ for (var listener : listeners) {
if (listener instanceof LspDbVersionListener) {
listener.onDataTreeChanged(List.of(dbverMod));
}
new NodeKey(ServerSessionManager.createNodeId(ADDRESS.getAddress())));
final var dbverRoot = mock(DataObjectModification.class);
- doReturn(LSP_DB_VERSION).when(dbverRoot).getDataAfter();
+ doReturn(LSP_DB_VERSION).when(dbverRoot).dataAfter();
final var dbverMod = mock(DataTreeModification.class);
- doReturn(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
doReturn(dbverRoot).when(dbverMod).getRootNode();
final var speakerRoot = mock(DataObjectModification.class);
doReturn(new PcepNodeSyncConfigBuilder().setSpeakerEntityIdValue(SPEAKER_ID).build()).when(speakerRoot)
- .getDataAfter();
+ .dataAfter();
final var speakerMod = mock(DataTreeModification.class);
- doReturn(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, modPath)).when(speakerMod)
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, modPath)).when(speakerMod)
.getRootPath();
doReturn(speakerRoot).when(speakerMod).getRootNode();
- for (DataTreeChangeListener<?> listener : listeners) {
+ for (var listener : listeners) {
if (listener instanceof SpeakerIdListener) {
listener.onDataTreeChanged(List.of(speakerMod));
} else if (listener instanceof LspDbVersionListener) {
@Before
public void setUp() throws Exception {
- doReturn(rpcReg).when(rpcProviderService).registerRpcImplementations(any());
+ doReturn(rpcReg).when(rpcProviderService).registerRpcImplementation(any());
doNothing().when(rpcReg).close();
rpcService = new TopologyStatsRpc(getDataBroker(), rpcProviderService);
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import org.opendaylight.bgpcep.programming.topology.TopologyProgrammingUtil;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
private final PcepCreateP2pTunnelInput p2pTunnelInput;
CreateTunnelInstructionExecutor(final PcepCreateP2pTunnelInput p2pTunnelInput, final DataBroker dataProvider,
- final RpcConsumerRegistry rpcConsumerRegistry) {
+ final RpcService rpcService) {
super(p2pTunnelInput);
this.p2pTunnelInput = p2pTunnelInput;
this.dataProvider = dataProvider;
- addLsp = rpcConsumerRegistry.getRpc(AddLsp.class);
+ addLsp = rpcService.getRpc(AddLsp.class);
}
private static void checkLinkIsnotExistent(final InstanceIdentifier<Topology> tii,
import org.opendaylight.bgpcep.programming.tunnel.TunnelProgrammingUtil;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev220730.OperationResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev220730.RemoveLsp;
private final RemoveLsp removeLsp;
DestroyTunnelInstructionExecutor(final PcepDestroyTunnelInput pcepDestroyTunnelInput, final DataBroker dataProvider,
- final RpcConsumerRegistry rpcConsumerRegistry) {
+ final RpcService rpcService) {
super(pcepDestroyTunnelInput);
this.pcepDestroyTunnelInput = pcepDestroyTunnelInput;
this.dataProvider = dataProvider;
- removeLsp = rpcConsumerRegistry.getRpc(RemoveLsp.class);
+ removeLsp = rpcService.getRpc(RemoveLsp.class);
}
@Override
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.termination.point.attributes.igp.termination.point.attributes.termination.point.type.Ip;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.termination.point.attributes.igp.termination.point.attributes.termination.point.type.IpBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.DataObjectStep;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class NodeChangedListener implements ClusteredDataTreeChangeListener<Node> {
+public final class NodeChangedListener implements DataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(NodeChangedListener.class);
private final InstanceIdentifier<Topology> target;
private final DataBroker dataProvider;
new TerminationPointKey(tp)).build();
}
- private InstanceIdentifier<Node> nodeIdentifier(final NodeId node) {
+ private @NonNull InstanceIdentifier<Node> nodeIdentifier(final NodeId node) {
return target.child(Node.class, new NodeKey(node));
}
}
@Override
- public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
- final ReadWriteTransaction trans = dataProvider.newReadWriteTransaction();
+ public void onDataTreeChanged(final List<DataTreeModification<Node>> changes) {
+ final var trans = dataProvider.newReadWriteTransaction();
- final Set<InstanceIdentifier<ReportedLsp>> lsps = new HashSet<>();
- final Set<InstanceIdentifier<Node>> nodes = new HashSet<>();
+ final var lsps = new HashSet<InstanceIdentifier<ReportedLsp>>();
+ final var nodes = new HashSet<InstanceIdentifier<Node>>();
- final Map<InstanceIdentifier<?>, DataObject> original = new HashMap<>();
- final Map<InstanceIdentifier<?>, DataObject> updated = new HashMap<>();
- final Map<InstanceIdentifier<?>, DataObject> created = new HashMap<>();
+ final var original = new HashMap<InstanceIdentifier<?>, DataObject>();
+ final var updated = new HashMap<InstanceIdentifier<?>, DataObject>();
+ final var created = new HashMap<InstanceIdentifier<?>, DataObject>();
- for (final DataTreeModification<?> change : changes) {
- final InstanceIdentifier<?> iid = change.getRootPath().getRootIdentifier();
- final DataObjectModification<?> rootNode = change.getRootNode();
- handleChangedNode(rootNode, iid, lsps, nodes, original, updated, created);
+ for (final var change : changes) {
+ handleChangedNode(change.getRootNode(), change.getRootPath().path(), lsps, nodes, original, updated,
+ created);
}
// Now walk all nodes, check for removals/additions and cascade them to LSPs
- for (final InstanceIdentifier<Node> iid : nodes) {
+ for (var iid : nodes) {
enumerateLsps(iid, (Node) original.get(iid), lsps);
enumerateLsps(iid, (Node) updated.get(iid), lsps);
enumerateLsps(iid, (Node) created.get(iid), lsps);
categorizeIdentifier(iid, lsps, nodes);
// Get the subtrees
- switch (changedNode.getModificationType()) {
+ switch (changedNode.modificationType()) {
case DELETE:
- original.put(iid, changedNode.getDataBefore());
+ original.put(iid, changedNode.dataBefore());
break;
case SUBTREE_MODIFIED:
- original.put(iid, changedNode.getDataBefore());
- updated.put(iid, changedNode.getDataAfter());
+ original.put(iid, changedNode.dataBefore());
+ updated.put(iid, changedNode.dataAfter());
break;
case WRITE:
- created.put(iid, changedNode.getDataAfter());
+ created.put(iid, changedNode.dataAfter());
break;
default:
- throw new IllegalArgumentException("Unhandled modification type " + changedNode.getModificationType());
+ throw new IllegalArgumentException("Unhandled modification type " + changedNode.modificationType());
}
- for (DataObjectModification<? extends DataObject> child : changedNode.getModifiedChildren()) {
- final List<PathArgument> pathArguments = new ArrayList<>();
- for (PathArgument pathArgument : iid.getPathArguments()) {
- pathArguments.add(pathArgument);
- }
- pathArguments.add(child.getIdentifier());
- final InstanceIdentifier<?> childIID = InstanceIdentifier.unsafeOf(pathArguments);
+ for (var child : changedNode.modifiedChildren()) {
+ final var pathArguments = new ArrayList<DataObjectStep<?>>();
+ iid.getPathArguments().forEach(pathArguments::add);
+ pathArguments.add(child.step());
+ final var childIID = InstanceIdentifier.unsafeOf(pathArguments);
handleChangedNode(child, childIID, lsps, nodes, original, updated, created);
}
}
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
import org.opendaylight.bgpcep.topology.DefaultTopologyReference;
import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.slf4j.LoggerFactory;
public final class PCEPTunnelClusterSingletonService implements ClusterSingletonService, AutoCloseable {
-
private static final Logger LOG = LoggerFactory.getLogger(PCEPTunnelClusterSingletonService.class);
+
private final PCEPTunnelTopologyProvider ttp;
private final TunnelProgramming tp;
private final ServiceGroupIdentifier sgi;
private final TopologyId tunnelTopologyId;
- private final TunnelProviderDependencies dependencies;
+
@GuardedBy("this")
private ServiceRegistration<?> serviceRegistration;
@GuardedBy("this")
- private ClusterSingletonServiceRegistration pcepTunnelCssReg;
+ private Registration pcepTunnelCssReg;
@GuardedBy("this")
private Registration reg;
final InstanceIdentifier<Topology> pcepTopology,
final TopologyId tunnelTopologyId
) {
- this.dependencies = requireNonNull(dependencies);
this.tunnelTopologyId = requireNonNull(tunnelTopologyId);
final TopologyId pcepTopologyId = pcepTopology.firstKeyOf(Topology.class).getTopologyId();
final BundleContext bundleContext = dependencies.getBundleContext();
FrameworkUtil.asDictionary(Map.of(
PCEPTunnelTopologyProvider.class.getName(), tunnelTopologyId.getValue())));
- LOG.info("PCEP Tunnel Cluster Singleton service {} registered", getIdentifier().getName());
+ LOG.info("PCEP Tunnel Cluster Singleton service {} registered", getIdentifier().value());
pcepTunnelCssReg = dependencies.getCssp().registerClusterSingletonService(this);
}
@Override
public synchronized void instantiateServiceInstance() {
- LOG.info("Instantiate PCEP Tunnel Topology Provider Singleton Service {}", getIdentifier().getName());
+ LOG.info("Instantiate PCEP Tunnel Topology Provider Singleton Service {}", getIdentifier().value());
reg = tp.register(InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(tunnelTopologyId))
@Override
public synchronized ListenableFuture<? extends CommitInfo> closeServiceInstance() {
- LOG.info("Close Service Instance PCEP Tunnel Topology Provider Singleton Service {}",
- getIdentifier().getName());
+ LOG.info("Close Service Instance PCEP Tunnel Topology Provider Singleton Service {}", getIdentifier().value());
reg.close();
tp.close();
ttp.close();
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
public synchronized void close() {
- LOG.info("Close PCEP Tunnel Topology Provider Singleton Service {}", getIdentifier().getName());
+ LOG.info("Close PCEP Tunnel Topology Provider Singleton Service {}", getIdentifier().value());
if (pcepTunnelCssReg != null) {
try {
pcepTunnelCssReg.close();
} catch (final Exception e) {
- LOG.debug("Failed to close PCEP Tunnel Topology service {}", sgi.getName(), e);
+ LOG.debug("Failed to close PCEP Tunnel Topology service {}", sgi.value(), e);
}
pcepTunnelCssReg = null;
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.TopologyTypesBuilder;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final DataBroker dataBroker;
private final TopologyId tunneltopologyId;
@GuardedBy("this")
- private ListenerRegistration<NodeChangedListener> reg;
+ private Registration reg;
public PCEPTunnelTopologyProvider(
final DataBroker dataBroker,
super(tunnelTopology);
this.dataBroker = dataBroker;
this.tunneltopologyId = tunneltopologyId;
- this.ncl = new NodeChangedListener(dataBroker, pcepTopologyId, tunnelTopology);
- this.src = pcepTopology.child(Node.class);
- this.ref = new DefaultTopologyReference(tunnelTopology);
+ ncl = new NodeChangedListener(dataBroker, pcepTopologyId, tunnelTopology);
+ src = pcepTopology.child(Node.class);
+ ref = new DefaultTopologyReference(tunnelTopology);
}
synchronized void init() {
- final WriteTransaction tx = this.dataBroker.newWriteOnlyTransaction();
+ final WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, getTopologyReference().getInstanceIdentifier(),
- new TopologyBuilder().setTopologyId(this.tunneltopologyId)
+ new TopologyBuilder().setTopologyId(tunneltopologyId)
.setTopologyTypes(new TopologyTypesBuilder()
.addAugmentation(new TopologyTypes1Builder()
.setTopologyTunnelPcep(
} catch (final InterruptedException | ExecutionException e) {
LOG.error("Failed to create Tunnel Topology root", e);
}
- this.reg = this.ncl.getDataProvider()
- .registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, this.src),
- this.ncl);
+ reg = ncl.getDataProvider()
+ .registerTreeChangeListener(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, src), ncl);
}
public TopologyReference getTopologyReference() {
- return this.ref;
+ return ref;
}
@Override
public synchronized void close() {
- if (this.reg != null) {
- this.reg.close();
- this.reg = null;
+ if (reg != null) {
+ reg.close();
+ reg = null;
}
}
}
import static java.util.Objects.requireNonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.binding.api.RpcService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.osgi.framework.BundleContext;
final class TunnelProviderDependencies {
private final DataBroker dataBroker;
private final ClusterSingletonServiceProvider cssp;
- private final RpcConsumerRegistry rpcConsumerRegistry;
+ private final RpcService rpcService;
private final RpcProviderService rpcProviderRegistry;
private final BundleContext bundleContext;
final DataBroker dataBroker,
final ClusterSingletonServiceProvider cssp,
final RpcProviderService rpcProviderRegistry,
- final RpcConsumerRegistry rpcConsumerRegistry,
+ final RpcService rpcService,
final BundleContext bundleContext
) {
this.cssp = requireNonNull(cssp);
this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
this.bundleContext = requireNonNull(bundleContext);
- this.rpcConsumerRegistry = requireNonNull(rpcConsumerRegistry);
+ this.rpcService = requireNonNull(rpcService);
}
DataBroker getDataBroker() {
- return this.dataBroker;
+ return dataBroker;
}
ClusterSingletonServiceProvider getCssp() {
- return this.cssp;
+ return cssp;
}
- RpcConsumerRegistry getRpcConsumerRegistry() {
- return this.rpcConsumerRegistry;
+ RpcService getRpcConsumerRegistry() {
+ return rpcService;
}
RpcProviderService getRpcProviderRegistry() {
- return this.rpcProviderRegistry;
+ return rpcProviderRegistry;
}
BundleContext getBundleContext() {
- return this.bundleContext;
+ return bundleContext;
}
}
import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
-import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.checkerframework.checker.lock.qual.GuardedBy;
-import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.binding.api.RpcService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.config.rev181109.PcepTunnelTopologyConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.rev181109.TopologyTypes1;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.slf4j.LoggerFactory;
@Component(service = { })
-public final class TunnelProviderDeployer implements ClusteredDataTreeChangeListener<Topology>, AutoCloseable {
+public final class TunnelProviderDeployer implements DataTreeChangeListener<Topology>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TunnelProviderDeployer.class);
private static final long TIMEOUT_NS = TimeUnit.SECONDS.toNanos(5);
@Activate
public TunnelProviderDeployer(@Reference final DataBroker dataBroker,
@Reference final RpcProviderService rpcProviderRegistry,
- @Reference final RpcConsumerRegistry rpcConsumerRegistry,
+ @Reference final RpcService rpcService,
@Reference final ClusterSingletonServiceProvider cssp,
// FIXME: do not reference BundleContext in an alternative constructor
final BundleContext bundleContext) {
- dependencies = new TunnelProviderDependencies(dataBroker, cssp, rpcProviderRegistry, rpcConsumerRegistry,
+ dependencies = new TunnelProviderDependencies(dataBroker, cssp, rpcProviderRegistry, rpcService,
bundleContext);
- reg = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(CONFIGURATION,
+ reg = dataBroker.registerTreeChangeListener(DataTreeIdentifier.of(CONFIGURATION,
InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).build()), this);
LOG.info("Tunnel Provider Deployer created");
}
}
@Override
- public synchronized void onDataTreeChanged(final Collection<DataTreeModification<Topology>> changes) {
- final List<DataObjectModification<Topology>> topoChanges = changes.stream()
- .map(DataTreeModification::getRootNode)
- .collect(Collectors.toList());
-
- topoChanges.stream().iterator().forEachRemaining(this::handleTopologyChange);
- }
-
- private synchronized void handleTopologyChange(final DataObjectModification<Topology> topo) {
- switch (topo.getModificationType()) {
- case SUBTREE_MODIFIED:
- updateTunnelTopologyProvider(topo.getDataAfter());
- break;
- case WRITE:
- createTunnelTopologyProvider(topo.getDataAfter());
- break;
- case DELETE:
- removeTunnelTopologyProvider(topo.getDataBefore());
- break;
- default:
- }
+ public synchronized void onDataTreeChanged(final List<DataTreeModification<Topology>> changes) {
+ changes.stream().map(DataTreeModification::getRootNode).forEach(topo -> {
+ switch (topo.modificationType()) {
+ case SUBTREE_MODIFIED:
+ updateTunnelTopologyProvider(topo.dataAfter());
+ break;
+ case WRITE:
+ createTunnelTopologyProvider(topo.dataAfter());
+ break;
+ case DELETE:
+ removeTunnelTopologyProvider(topo.dataBefore());
+ break;
+ default:
+ }
+ });
}
private static boolean filterPcepTopologies(final TopologyTypes topologyTypes) {
import org.opendaylight.bgpcep.programming.tunnel.TunnelProgrammingUtil;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.AdministrativeStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Arguments3Builder;
private final UpdateLsp updateLsp;
UpdateTunnelInstructionExecutor(final PcepUpdateTunnelInput updateTunnelInput, final DataBroker dataProvider,
- final RpcConsumerRegistry rpcConsumerRegistry) {
+ final RpcService rpcService) {
super(updateTunnelInput);
this.updateTunnelInput = updateTunnelInput;
this.dataProvider = dataProvider;
- updateLsp = rpcConsumerRegistry.getRpc(UpdateLsp.class);
+ updateLsp = rpcService.getRpc(UpdateLsp.class);
}
@Override
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNode;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.common.Uint32;
private static final InstanceIdentifier<Topology> TUNNEL_TOPO_IID = InstanceIdentifier
.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(TUNNEL_TOPOLOGY_ID)).build();
- private ListenerRegistration<NodeChangedListener> listenerRegistration;
+ private Registration listenerRegistration;
@Before
public void setUp() throws InterruptedException, ExecutionException {
wTx.commit().get();
final NodeChangedListener nodeListener = new NodeChangedListener(getDataBroker(),
PCEP_TOPOLOGY_ID, TUNNEL_TOPO_IID);
- this.listenerRegistration = getDataBroker().registerDataTreeChangeListener(DataTreeIdentifier.create(
+ listenerRegistration = getDataBroker().registerTreeChangeListener(DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, PCEP_TOPO_IID.child(Node.class)), nodeListener);
}
@After
public void tearDown() {
- this.listenerRegistration.close();
+ listenerRegistration.close();
}
private void createNode(final NodeId nodeId, final String ipv4Address, final String lspName, final Uint32 lspId,
import org.opendaylight.bgpcep.programming.spi.Instruction;
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
import org.opendaylight.bgpcep.programming.spi.SchedulerException;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
@Mock
private RpcProviderService rpr;
@Mock
- private RpcConsumerRegistry rpcs;
+ private RpcService rpcs;
@Mock
private BundleContext bundleContext;
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.programming.rev150720.CancelInstruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.programming.rev150720.CancelInstructionInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.programming.rev150720.CancelInstructionOutput;
private final Timer timer;
private final String instructionId;
private final ServiceGroupIdentifier sgi;
- private final ClusterSingletonServiceRegistration csspReg;
+ private final Registration csspReg;
private final RpcProviderService rpcProviderRegistry;
@GuardedBy("this")
private Registration reg;
this.timer = requireNonNull(timer);
qid = KeyedInstanceIdentifier.builder(InstructionsQueue.class,
new InstructionsQueueKey(this.instructionId)).build();
- sgi = ServiceGroupIdentifier.create(this.instructionId + "-service-group");
- LOG.info("Creating Programming Service {}.", sgi.getName());
+ sgi = new ServiceGroupIdentifier(this.instructionId + "-service-group");
+ LOG.info("Creating Programming Service {}.", sgi.value());
csspReg = cssp.registerClusterSingletonService(this);
}
@Override
public synchronized void instantiateServiceInstance() {
- LOG.info("Instruction Queue service {} instantiated", sgi.getName());
+ LOG.info("Instruction Queue service {} instantiated", sgi.value());
reg = rpcProviderRegistry.registerRpcImplementations(ImmutableClassToInstanceMap.<Rpc<?, ?>>builder()
.put(CancelInstruction.class, this::cancelInstruction)
.put(CleanInstructions.class, this::cleanInstructions)
private synchronized void tryScheduleInstruction(final InstructionImpl instruction) {
final ListenableFuture<ExecutionResult<Details>> f = instruction.ready();
if (f != null) {
- Futures.addCallback(f, new FutureCallback<ExecutionResult<Details>>() {
+ Futures.addCallback(f, new FutureCallback<>() {
@Override
public void onSuccess(final ExecutionResult<Details> result) {
tryScheduleDependants(instruction);
}
}, MoreExecutors.directExecutor());
}
-
}
@Override
public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
- LOG.info("Closing Instruction Queue service {}", sgi.getName());
+ LOG.info("Closing Instruction Queue service {}", sgi.value());
if (reg != null) {
reg.close();
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.mockito.Mock;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
import org.opendaylight.yangtools.concepts.Registration;
abstract class AbstractProgrammingTest extends AbstractConcurrentDataBrokerTest {
@Mock
ClusterSingletonServiceProvider cssp;
@Mock
- ClusterSingletonServiceRegistration singletonServiceRegistration;
+ Registration singletonServiceRegistration;
@Mock
private Registration registration;
ClusterSingletonService singletonService;
@Before
public void setUp() throws Exception {
doAnswer(invocationOnMock -> {
- this.singletonService = (ClusterSingletonService) invocationOnMock.getArguments()[0];
- return this.singletonServiceRegistration;
- }).when(this.cssp).registerClusterSingletonService(any(ClusterSingletonService.class));
+ singletonService = invocationOnMock.getArgument(0);
+ return singletonServiceRegistration;
+ }).when(cssp).registerClusterSingletonService(any(ClusterSingletonService.class));
doAnswer(invocationOnMock -> {
- this.singletonService.closeServiceInstance().get();
+ singletonService.closeServiceInstance().get();
return null;
- }).when(this.singletonServiceRegistration).close();
+ }).when(singletonServiceRegistration).close();
- doReturn(this.registration).when(this.rpcRegistry).registerRpcImplementations(any());
+ doReturn(registration).when(rpcRegistry).registerRpcImplementations(any());
- doNothing().when(this.registration).close();
+ doNothing().when(registration).close();
}
}
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
- <artifactId>mdsal-singleton-common-api</artifactId>
+ <artifactId>mdsal-singleton-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.mdsal.singleton.api.ServiceGroupIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.programming.rev150720.SubmitInstructionInput;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.concepts.Registration;
Code Review / bgpcep.git / commitdiff