import com.google.common.base.Stopwatch;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.application.rib.tables.routes.Ipv4RoutesCaseBuilder;
final WriteTransaction wTx = this.txChain.newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.CONFIGURATION, this.appIID, appRib);
- Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.info("Empty Structure created for Application Peer Benchmark {}", AppPeerBenchmark.this.appRibId);
}
final WriteTransaction dTx = this.txChain.newWriteOnlyTransaction();
dTx.delete(LogicalDatastoreType.CONFIGURATION, this.appIID);
try {
- dTx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ dTx.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
LOG.warn("Failed to clean-up BGP Application RIB.", e);
}
this.txChain.close();
wt.delete(LogicalDatastoreType.CONFIGURATION, routeIId);
}
if (i % batch == 0) {
- wt.submit();
+ wt.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
wt = this.txChain.newWriteOnlyTransaction();
}
address = increasePrefix(address);
}
- wt.submit();
+ wt.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Route batch stored.");
+ }
+
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to store route batch.", throwable);
+ }
+ }, MoreExecutors.directExecutor());
return stopwatch.stop().elapsed(TimeUnit.MILLISECONDS);
}
import static java.util.concurrent.TimeUnit.SECONDS;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.HashMap;
import java.util.HashSet;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.spi.state.BGPPeerState;
import org.opendaylight.protocol.bgp.rib.spi.state.BGPRibState;
try {
updateBGPStats(wTx);
- Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(CommitInfo result) {
LOG.debug("Successfully committed BGP stats update");
}
final WriteTransaction wTx = this.transactionChain.newWriteOnlyTransaction();
this.instanceIdentifiersCache.keySet().iterator()
.forEachRemaining(ribId -> removeStoredOperationalState(ribId, wTx));
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successfully operational stats removed.");
+ }
+
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to clean up operational stats", throwable);
+ }
+ }, MoreExecutors.directExecutor());
}
this.transactionChain.close();
this.scheduler.shutdown();
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.extended.community.ExtendedCommunity;
*/
package org.opendaylight.protocol.bgp.rib.impl;
+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 com.google.common.util.concurrent.MoreExecutors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Arrays;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.protocol.bgp.rib.impl.state.BGPPeerStateImpl;
import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils;
rib.getLocalTablesKeys(), afiSafisGracefulAdvertized);
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- final synchronized ListenableFuture<Void> removePeer(
+ final synchronized FluentFuture<? extends CommitInfo> removePeer(
@Nonnull final DOMTransactionChain chain,
@Nullable final YangInstanceIdentifier peerPath) {
if (peerPath != null) {
LOG.info("AdjRibInWriter closed per Peer {} removed", peerPath);
final DOMDataWriteTransaction tx = chain.newWriteOnlyTransaction();
tx.delete(LogicalDatastoreType.OPERATIONAL, peerPath);
- final ListenableFuture<Void> future = tx.submit();
- Futures.addCallback(future, new FutureCallback<Void>() {
+ final FluentFuture<? extends CommitInfo> future = tx.commit();
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Peer {} removed", peerPath);
}
}, MoreExecutors.directExecutor());
return future;
}
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
synchronized YangInstanceIdentifier createPeerPath() {
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collections;
import java.util.Locale;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.ApplicationPeer.RegisterAppPeerListener;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContext;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
final ImmutableMap<TablesKey, TableContext> tb = createNewTableInstances(peerPath, registry, tableTypes,
addPathTablesType, tx);
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
if (registerAppPeerListener != null) {
LOG.trace("Application Peer Listener registered");
registerAppPeerListener.register();
final TableContext ctx = this.tables.get(tableTypes);
tx.merge(LogicalDatastoreType.OPERATIONAL, ctx.getTableId().node(Attributes.QNAME)
.node(ATTRIBUTES_UPTODATE_TRUE.getNodeType()), ATTRIBUTES_UPTODATE_TRUE);
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("Write Attributes uptodate, succeed");
}
final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
ctx.writeRoutes(tx, nlri, attributes);
LOG.trace("Write routes {}", nlri);
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("Write routes {}, succeed", nlri);
}
LOG.trace("Removing routes {}", nlri);
final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
ctx.removeRoutes(tx, nlri);
- Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("Removing routes {}, succeed", nlri);
}
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.net.InetAddresses;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+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.Collections;
import java.util.HashSet;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
import org.opendaylight.protocol.bgp.rib.impl.state.BGPSessionStateImpl;
}
}
}
- tx.submit();
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
private synchronized void processRoutesTable(final DataTreeCandidateNode node,
}
}
- // FIXME ListenableFuture<?> should be used once closeServiceInstance uses wildcard too
@Override
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public synchronized ListenableFuture<Void> close() {
+ public synchronized FluentFuture<? extends CommitInfo> close() {
setActive(false);
if (this.registration != null) {
this.registration.close();
if (this.effectiveRibInWriter != null) {
this.effectiveRibInWriter.close();
}
- final ListenableFuture<Void> future;
+ final FluentFuture<? extends CommitInfo> future;
if (this.chain != null) {
future = removePeer(this.chain, this.peerPath);
this.chain.close();
this.chain = null;
} else {
- future = Futures.immediateFuture(null);
+ future = CommitInfo.emptyFluentFuture();
}
if (this.writerChain != null) {
this.writerChain.close();
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.net.InetAddresses;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPError;
import org.opendaylight.protocol.bgp.parser.impl.message.update.LocalPreferenceAttributeParser;
setActive(true);
}
- // FIXME ListenableFuture<?> should be used once closeServiceInstance uses wildcard too
@Override
- public synchronized ListenableFuture<Void> close() {
- final ListenableFuture<Void> future = releaseConnection();
+ public synchronized FluentFuture<? extends CommitInfo> close() {
+ final FluentFuture<? extends CommitInfo> future = releaseConnection();
this.chain.close();
setActive(false);
return future;
}
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- private synchronized ListenableFuture<Void> cleanup() {
+ private synchronized FluentFuture<? extends CommitInfo> cleanup() {
// FIXME: BUG-196: support graceful
this.adjRibOutListenerSet.values().forEach(AdjRibOutListener::close);
this.adjRibOutListenerSet.clear();
}
@Override
- public synchronized ListenableFuture<Void> releaseConnection() {
+ public synchronized FluentFuture<? extends CommitInfo> releaseConnection() {
LOG.info("Closing session with peer");
this.sessionUp = false;
closeRegistration();
if (this.rpcRegistration != null) {
this.rpcRegistration.close();
}
- final ListenableFuture<Void> future = cleanup();
+ final FluentFuture<? extends CommitInfo> future = cleanup();
if (this.session != null) {
try {
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
import org.opendaylight.protocol.bgp.rib.impl.state.peer.PrefixesInstalledCounters;
}
}
if (tx != null) {
- tx.submit();
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
}
import static java.util.Objects.requireNonNull;
import com.google.common.primitives.UnsignedInteger;
+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.Map;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.mode.api.RouteEntry;
import org.opendaylight.protocol.bgp.rib.impl.state.rib.TotalPathsCounter;
tx.merge(LogicalDatastoreType.OPERATIONAL,
this.locRibTableIID.builder().child(Attributes.class).build(),
new AttributesBuilder().setUptodate(true).build());
- tx.submit();
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
final InstanceIdentifier<Tables> tableId = this.ribIId.builder().child(Peer.class)
.child(EffectiveRibIn.class).child(Tables.class, this.tk).build();
} catch (final Exception e) {
LOG.error("Failed to completely propagate updates {}, state is undefined", changes, e);
} finally {
- tx.submit();
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
}
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
tx.put(LogicalDatastoreType.OPERATIONAL, tableId.build(), table.build());
try {
- tx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e1) {
+ tx.commit().get();
+ } catch (final InterruptedException | ExecutionException e1) {
LOG.error("Failed to initiate LocRIB for key {}", key, e1);
}
} else {
trans.put(LogicalDatastoreType.OPERATIONAL, this.yangRibId, ribInstance);
try {
- trans.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ trans.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
LOG.error("Failed to initiate RIB {}", this.yangRibId, e);
}
this.localTablesKeys.forEach(this::createLocRibWriter);
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (!this.isServiceInstantiated) {
LOG.trace("RIB {} already closed", this.ribId.getValue());
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
LOG.info("Close RIB {}", this.ribId.getValue());
this.isServiceInstantiated = false;
final DOMDataWriteTransaction t = this.domChain.newWriteOnlyTransaction();
t.delete(LogicalDatastoreType.OPERATIONAL, getYangRibId());
- final ListenableFuture<Void> cleanFuture = t.submit();
+ final FluentFuture<? extends CommitInfo> cleanFuture = t.commit();
+ cleanFuture.addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.info("RIB cleaned {}", RIBImpl.this.ribId.getValue());
+ }
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to clean RIB {}",
+ RIBImpl.this.ribId.getValue(), throwable);
+ }
+ }, MoreExecutors.directExecutor());
this.domChain.close();
return cleanFuture;
}
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Objects;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.ApplicationPeer;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
}
@Override
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (this.bgpAppPeerSingletonService != null) {
return this.bgpAppPeerSingletonService.closeServiceInstance();
}
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
@Override
new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, yangIId));
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (!this.isServiceInstantiated) {
LOG.trace("Application peer already closed {}", this.appRibId.getValue());
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
LOG.info("Application peer instance closed {}", this.appRibId.getValue());
this.isServiceInstantiated = false;
import javax.annotation.concurrent.GuardedBy;
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
}
@Override
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized ListenableFuture<? extends CommitInfo> closeServiceInstance() {
LOG.info("BGPClusterSingletonService {} close service instance", this.serviceGroupIdentifier.getValue());
this.instantiated.set(false);
- final List<ListenableFuture<Void>> futurePeerCloseList = this.peers.values().stream()
+ final List<ListenableFuture<? extends CommitInfo>> futurePeerCloseList = this.peers.values().stream()
.map(PeerBean::closeServiceInstance).collect(Collectors.toList());
- final SettableFuture<Void> done = SettableFuture.create();
- Futures.addCallback(Futures.allAsList(futurePeerCloseList), new FutureCallback<List<Void>>() {
+ final SettableFuture<? extends CommitInfo> done = SettableFuture.create();
+
+ final ListenableFuture<List<CommitInfo>> futureResult = Futures.allAsList(futurePeerCloseList);
+ Futures.addCallback(futureResult, new FutureCallback<List<? extends CommitInfo>>() {
@Override
- public void onSuccess(final List<Void> result) {
- done.setFuture(BGPClusterSingletonService.this.ribImpl.closeServiceInstance());
+ public void onSuccess(final List<? extends CommitInfo> result) {
+ done.setFuture(Futures.transform(BGPClusterSingletonService.this.ribImpl.closeServiceInstance(),
+ input -> null, MoreExecutors.directExecutor()));
}
@Override
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
+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 com.google.common.util.concurrent.MoreExecutors;
import java.util.Collection;
import java.util.HashMap;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroup;
this.tableTypeRegistry = requireNonNull(mappingService);
this.networkInstanceIId = InstanceIdentifier.create(NetworkInstances.class)
.child(NetworkInstance.class, new NetworkInstanceKey(networkInstanceName));
- Futures.addCallback(initializeNetworkInstance(dataBroker, this.networkInstanceIId), new FutureCallback<Void>() {
+ initializeNetworkInstance(dataBroker, this.networkInstanceIId).addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.debug("Network Instance {} initialized successfully.", networkInstanceName);
}
@Override
- public void onFailure(final Throwable t) {
- LOG.error("Failed to initialize Network Instance {}.", networkInstanceName, t);
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to initialize Network Instance {}.", networkInstanceName, throwable);
}
}, MoreExecutors.directExecutor());
}
}
- private static ListenableFuture<Void> initializeNetworkInstance(
+ private static FluentFuture<? extends CommitInfo> initializeNetworkInstance(
final DataBroker dataBroker, final InstanceIdentifier<NetworkInstance> networkInstance) {
final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
wTx.merge(LogicalDatastoreType.CONFIGURATION, networkInstance,
new NetworkInstanceBuilder().setName(networkInstance.firstKeyOf(NetworkInstance.class).getName())
.setProtocols(new ProtocolsBuilder().build()).build());
- return wTx.submit();
+ return wTx.commit();
}
@VisibleForTesting
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.FluentFuture;
import io.netty.util.concurrent.Future;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import javax.annotation.concurrent.GuardedBy;
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BgpExtendedMessageUtil;
import org.opendaylight.protocol.bgp.parser.spi.MultiprotocolCapabilitiesUtil;
}
@Override
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (this.bgpPeerSingletonService != null) {
- final ListenableFuture<Void> fut = this.bgpPeerSingletonService.closeServiceInstance();
+ final FluentFuture<? extends CommitInfo> fut = this.bgpPeerSingletonService.closeServiceInstance();
this.bgpPeerSingletonService = null;
return fut;
}
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
@Override
}
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- private synchronized ListenableFuture<Void> closeServiceInstance() {
+ private synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (!this.isServiceInstantiated) {
LOG.info("Peer {} already closed", this.neighborAddress);
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
LOG.info("Close Peer {}", this.neighborAddress);
this.isServiceInstantiated = false;
this.connection.cancel(true);
this.connection = null;
}
- final ListenableFuture<Void> future = this.bgpPeer.close();
+ final FluentFuture<? extends CommitInfo> future = this.bgpPeer.close();
removePeer(this.dispatcher.getBGPPeerRegistry());
return future;
}
package org.opendaylight.protocol.bgp.rib.impl.config;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
void instantiateServiceInstance();
- ListenableFuture<Void> closeServiceInstance();
+ FluentFuture<? extends CommitInfo> closeServiceInstance();
Boolean containsEqualConfiguration(Neighbor neighbor);
}
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.toTableTypes;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.BGPRibRoutingPolicyFactory;
return this.ribImpl.getDataBroker();
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- ListenableFuture<Void> closeServiceInstance() {
+ FluentFuture<? extends CommitInfo> closeServiceInstance() {
if (this.ribImpl != null) {
return this.ribImpl.closeServiceInstance();
}
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
@Override
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
private DOMDataWriteTransaction domTransWrite;
@Mock
- private CheckedFuture<?, ?> future;
+ private FluentFuture<? extends CommitInfo> future;
@Mock
private Optional<Rib> o;
doReturn(this.domChain).when(this.dom).createTransactionChain(any(BGPPeer.class));
doReturn(this.transWrite).when(this.chain).newWriteOnlyTransaction();
doReturn(false).when(this.o).isPresent();
- doReturn(this.o).when(this.future).checkedGet();
- doReturn(this.future).when(this.domTransWrite).submit();
+ doReturn(this.o).when(this.future).get();
+ doReturn(this.future).when(this.domTransWrite).commit();
doNothing().when(this.future).addListener(any(Runnable.class), any(Executor.class));
doNothing().when(this.transWrite).put(eq(LogicalDatastoreType.OPERATIONAL),
any(InstanceIdentifier.class), any(DataObject.class), eq(true));
doNothing().when(this.transWrite).put(eq(LogicalDatastoreType.OPERATIONAL),
any(InstanceIdentifier.class), any(DataObject.class));
- doReturn(this.future).when(this.transWrite).submit();
+ doReturn(this.future).when(this.transWrite).commit();
}
public Collection<DataTreeCandidate> ipv4Input(final YangInstanceIdentifier target,
import static org.junit.Assert.assertNotNull;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContext;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
import org.opendaylight.protocol.bgp.rib.spi.IdentifierUtils;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- Mockito.doReturn("MockedTrans").when(this.tx).toString();
- Mockito.doReturn(this.tx).when(this.chain).newWriteOnlyTransaction();
- final CheckedFuture<?, ?> checkedFuture = Mockito.mock(CheckedFuture.class);
- Mockito.doNothing().when(checkedFuture).addListener(any(), any());
- Mockito.doReturn(checkedFuture).when(this.tx).submit();
- Mockito.doNothing().when(this.tx).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any(YangInstanceIdentifier.class), Mockito.any(NormalizedNode.class));
- Mockito.doNothing().when(this.tx).merge(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any(YangInstanceIdentifier.class), Mockito.any(NormalizedNode.class));
- Mockito.doReturn(this.context).when(this.registry).getRIBSupportContext(Mockito.any(TablesKey.class));
- Mockito.doNothing().when(this.context).createEmptyTableStructure(Mockito.eq(this.tx), Mockito.any(YangInstanceIdentifier.class));
+ doReturn("MockedTrans").when(this.tx).toString();
+ doReturn(this.tx).when(this.chain).newWriteOnlyTransaction();
+ final FluentFuture<? extends CommitInfo> fluentFuture = mock(FluentFuture.class);
+ doNothing().when(fluentFuture).addListener(any(), any());
+ doReturn(fluentFuture).when(this.tx).commit();
+ doNothing().when(this.tx).put(eq(LogicalDatastoreType.OPERATIONAL),
+ any(YangInstanceIdentifier.class), any(NormalizedNode.class));
+ doNothing().when(this.tx).merge(eq(LogicalDatastoreType.OPERATIONAL),
+ any(YangInstanceIdentifier.class), any(NormalizedNode.class));
+ doReturn(this.context).when(this.registry).getRIBSupportContext(any(TablesKey.class));
+ doNothing().when(this.context).createEmptyTableStructure(eq(this.tx), any(YangInstanceIdentifier.class));
}
@Test
public void testTransform() {
this.writer = AdjRibInWriter.create(YangInstanceIdentifier.of(Rib.QNAME), PeerRole.Ebgp, this.chain);
assertNotNull(this.writer);
- final YangInstanceIdentifier peerPath = YangInstanceIdentifier.builder().node(Rib.QNAME).node(Peer.QNAME).nodeWithKey(Peer.QNAME,
- AdjRibInWriter.PEER_ID_QNAME, this.peerIp).build();
+ final YangInstanceIdentifier peerPath = YangInstanceIdentifier.builder().node(Rib.QNAME)
+ .node(Peer.QNAME).nodeWithKey(Peer.QNAME,
+ AdjRibInWriter.PEER_ID_QNAME, this.peerIp).build();
this.writer.transform(new PeerId(this.peerIp), peerPath, this.registry, this.tableTypes, ADD_PATH_TABLE_MAPS);
verifyPeerSkeletonInsertedCorrectly(peerPath);
// verify supported tables were inserted for ipv4
- Mockito.verify(this.tx).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.eq(peerPath.node(SupportedTables.QNAME)
- .node(RibSupportUtils.toYangKey(SupportedTables.QNAME, K4))), Mockito.any(NormalizedNode.class));
+ verify(this.tx).put(eq(LogicalDatastoreType.OPERATIONAL), eq(peerPath.node(SupportedTables.QNAME)
+ .node(RibSupportUtils.toYangKey(SupportedTables.QNAME, K4))), any(NormalizedNode.class));
verifyUptodateSetToFalse(peerPath);
}
private void verifyUptodateSetToFalse(final YangInstanceIdentifier peerPath) {
- final YangInstanceIdentifier path = peerPath.node(AdjRibIn.QNAME).node(Tables.QNAME).node(RibSupportUtils.toYangTablesKey(K4))
+ final YangInstanceIdentifier path = peerPath.node(AdjRibIn.QNAME)
+ .node(Tables.QNAME).node(RibSupportUtils.toYangTablesKey(K4))
.node(Attributes.QNAME).node(AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE.getNodeType());
- Mockito.verify(this.tx).merge(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.eq(path), Mockito.eq(AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE));
+ verify(this.tx).merge(eq(LogicalDatastoreType.OPERATIONAL), eq(path)
+ , eq(AdjRibInWriter.ATTRIBUTES_UPTODATE_FALSE));
}
private void verifyPeerSkeletonInsertedCorrectly(final YangInstanceIdentifier peerPath) {
- Mockito.verify(this.tx).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.eq(peerPath),
- Mockito.eq(this.writer.peerSkeleton(IdentifierUtils.peerKey(peerPath), this.peerIp)));
+ verify(this.tx).put(eq(LogicalDatastoreType.OPERATIONAL), eq(peerPath),
+ eq(this.writer.peerSkeleton(IdentifierUtils.peerKey(peerPath), this.peerIp)));
}
}
\ No newline at end of file
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.List;
-import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
public class ParserToSalTest extends DefaultRibPoliciesMockTest {
private static final String TEST_RIB_ID = "testRib";
- private static final TablesKey TABLE_KEY = new TablesKey(LinkstateAddressFamily.class, LinkstateSubsequentAddressFamily.class);
+ private static final TablesKey TABLE_KEY
+ = new TablesKey(LinkstateAddressFamily.class, LinkstateSubsequentAddressFamily.class);
private static final InstanceIdentifier<BgpRib> BGP_IID = InstanceIdentifier.create(BgpRib.class);
private BGPMock mock;
private AbstractRIBExtensionProviderActivator baseact, lsact;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
import org.opendaylight.protocol.bgp.parser.BgpExtendedMessageUtil;
doNothing().when(this.tx).put(eq(LogicalDatastoreType.OPERATIONAL),
any(YangInstanceIdentifier.class), any(NormalizedNode.class));
doNothing().when(this.tx).delete(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class));
- final CheckedFuture<?, ?> future = mock(CheckedFuture.class);
+ final FluentFuture<? extends CommitInfo> fluentFuture = mock(FluentFuture.class);
doAnswer(invocation -> {
final Runnable callback = (Runnable) invocation.getArguments()[0];
callback.run();
return null;
- }).when(future).addListener(any(Runnable.class), any(Executor.class));
- doReturn(future).when(this.tx).submit();
- doReturn(mock(Optional.class)).when(future).checkedGet();
+ }).when(fluentFuture).addListener(any(Runnable.class), any(Executor.class));
+ doReturn(fluentFuture).when(this.tx).commit();
+ doReturn(mock(Optional.class)).when(fluentFuture).get();
}
@Test
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.netty.util.concurrent.Future;
import java.net.InetSocketAddress;
import java.util.Collections;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.parser.BgpTableTypeImpl;
import org.opendaylight.protocol.bgp.rib.impl.BGPPeerTrackerImpl;
any(YangInstanceIdentifier.class));
doNothing().when(this.domDW).merge(eq(LogicalDatastoreType.OPERATIONAL),
any(YangInstanceIdentifier.class), any(NormalizedNode.class));
- final CheckedFuture<?, ?> checkedFuture = mock(CheckedFuture.class);
+ final FluentFuture<? extends CommitInfo> checkedFuture = mock(FluentFuture.class);
doAnswer(invocation -> {
final Runnable callback = (Runnable) invocation.getArguments()[0];
callback.run();
return null;
}).when(checkedFuture).addListener(Mockito.any(Runnable.class), Mockito.any(Executor.class));
- doReturn(checkedFuture).when(this.domDW).submit();
- doReturn(null).when(checkedFuture).checkedGet();
+ doReturn(checkedFuture).when(this.domDW).commit();
doReturn(null).when(checkedFuture).get();
doReturn(true).when(checkedFuture).isDone();
doReturn("checkedFuture").when(checkedFuture).toString();
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.NeighborBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.NeighborKey;
-import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroup;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.peer.group.PeerGroupBuilder;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.Bgp;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Neighbors;
*/
package org.opendaylight.protocol.bgp.testtool;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.List;
import java.util.concurrent.atomic.LongAdder;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.impl.BGPSessionImpl;
import org.opendaylight.protocol.bgp.rib.spi.BGPSession;
import org.opendaylight.protocol.bgp.rib.spi.BGPSessionListener;
}
@Override
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public ListenableFuture<?> releaseConnection() {
+ public FluentFuture<? extends CommitInfo> releaseConnection() {
LOG.info("Client Listener: Connection released.");
- return Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
void printCount(final String localAddress) {
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
+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 com.google.common.util.concurrent.MoreExecutors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.atomic.AtomicBoolean;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.RibReference;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.rib.LocRib;
private ListenerRegistration<AbstractTopologyBuilder<T>> listenerRegistration = null;
@GuardedBy("this")
private BindingTransactionChain chain = null;
- @GuardedBy("this")
- private boolean closed = false;
+ private AtomicBoolean closed = new AtomicBoolean(false);
@GuardedBy("this")
@VisibleForTesting
protected long listenerScheduledRestartTime = 0;
return this.topology;
}
- @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Unrecognised NullableDecl")
- public final synchronized ListenableFuture<Void> close() {
- if (this.closed) {
+ public final synchronized FluentFuture<? extends CommitInfo> close() {
+ if (this.closed.getAndSet(true)) {
LOG.trace("Transaction chain was already closed.");
- Futures.immediateFuture(null);
+ return CommitInfo.emptyFluentFuture();
}
- this.closed = true;
LOG.info("Shutting down builder for {}", getInstanceIdentifier());
unregisterDataChangeListener();
- final ListenableFuture<Void> future = destroyOperationalTopology();
+ final FluentFuture<? extends CommitInfo> future = destroyOperationalTopology();
destroyTransactionChain();
return future;
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
public synchronized void onDataTreeChanged(final Collection<DataTreeModification<T>> changes) {
- if (this.closed) {
+ if (this.closed.get()) {
LOG.trace("Transaction chain was already closed, skipping update.");
return;
}
LOG.warn("Data change {} (transaction {}) was not completely propagated to listener {}", change,
trans.getIdentifier(), this, exc);
// trans.cancel() is not supported by PingPongTransactionChain, so we just skip the problematic change
- // trans.submit() must be called first to unlock the current transaction chain, to make the chain
+ // trans.commit() must be called first to unlock the current transaction chain, to make the chain
// closable so we cannot exit the #onDataTreeChanged() yet
transactionInError.set(true);
break;
}
}
- Futures.addCallback(trans.submit(), new FutureCallback<Void>() {
+ trans.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
- // as we are enforcing trans.submit(), in some cases the transaction execution actually could be
+ public void onSuccess(final CommitInfo result) {
+ // as we are enforcing trans.commit(), in some cases the transaction execution actually could be
// successfully even when an exception is captured, thus #onTransactionChainFailed() never get invoked.
// Though the transaction chain remains usable,
// the data loss will not be able to be recovered. Thus we schedule a listener restart here
new TopologyBuilder().setKey(this.topologyKey).setServerProvided(Boolean.TRUE)
.setTopologyTypes(this.topologyTypes)
.setLink(Collections.emptyList()).setNode(Collections.emptyList()).build(), true);
- Futures.addCallback(trans.submit(), new FutureCallback<Void>() {
+ trans.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("Transaction {} committed successfully", trans.getIdentifier());
}
/**
* Destroy the current operational topology data. Note a valid transaction must be provided.
*/
- private synchronized ListenableFuture<Void> destroyOperationalTopology() {
+ private synchronized FluentFuture<? extends CommitInfo> destroyOperationalTopology() {
requireNonNull(this.chain, "A valid transaction chain must be provided.");
final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
trans.delete(LogicalDatastoreType.OPERATIONAL, getInstanceIdentifier());
- final ListenableFuture<Void> future = trans.submit();
- Futures.addCallback(future, new FutureCallback<Void>() {
+ final FluentFuture<? extends CommitInfo> future = trans.commit();
+ future.addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final CommitInfo result) {
LOG.trace("Operational topology removed {}", AbstractTopologyBuilder.this.topology);
}
import static java.util.Objects.requireNonNull;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import org.opendaylight.bgpcep.bgp.topology.provider.AbstractTopologyBuilder;
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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
}
@Override
- public ListenableFuture<Void> closeServiceInstance() {
+ public FluentFuture<? extends CommitInfo> closeServiceInstance() {
LOG.info("Close Topology Singleton Service {}", getIdentifier());
return this.topologyBuilder.close();
}
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(NetworkTopology.class).build(),
new NetworkTopologyBuilder().setTopology(Collections.emptyList()).build());
- wTx.submit();
+ wTx.commit();
}
}
// delete route
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.ipv4RouteIID);
- wTx.submit();
+ wTx.commit();
readDataOperational(getDataBroker(), this.ipv4TopoBuilder.getInstanceIdentifier(), topology -> {
assertEquals(0, topology.getNode().size());
return topology;
private void updateIpv4Route(final Ipv4Route data) {
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, this.ipv4RouteIID, data, true);
- wTx.submit();
+ wTx.commit();
}
private static Ipv4Route createIpv4Route(final String nextHop) {
// delete route
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.ipv6RouteIID);
- wTx.submit();
+ wTx.commit();
readDataOperational(getDataBroker(), this.ipv6TopoBuilder.getInstanceIdentifier(), topology -> {
assertEquals(0, topology.getNode().size());
return topology;
private void updateIpv6Route(final Ipv6Route data) {
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, this.ipv6RouteIID, data, true);
- wTx.submit();
+ wTx.commit();
}
private static Ipv6Route createIpv6Route(final String netxHop) {
// remove
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.linkstateRouteIID);
- wTx.submit();
+ wTx.commit();
readDataOperational(getDataBroker(), this.linkstateTopoBuilder.getInstanceIdentifier(), topology -> {
assertEquals(0, topology.getNode().size());
assertEquals(0, topology.getLink().size());
private void updateLinkstateRoute(final LinkstateRoute data) {
final WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, this.linkstateRouteIID, data, true);
- wTx.submit();
+ wTx.commit();
}
private static LinkstateRoute createLinkstateNodeRoute(final ProtocolId protocolId, final String nodeName,
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+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;
}
@Override
- public synchronized ListenableFuture<Void> closeServiceInstance() {
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
LOG.info("BMP Monitor Singleton Service {} instance closed, Monitor Id {}",
getIdentifier().getValue(), this.monitorId.getValue());
if (this.channel != null) {
final DOMDataWriteTransaction wTx = this.domDataBroker.newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.yangMonitorId);
LOG.info("BMP monitoring station {} closed.", this.monitorId.getValue());
- return wTx.submit();
+ return wTx.commit();
}
@Nonnull
.addChild(ImmutableNodes.mapNodeBuilder(Router.QNAME).build())
.build());
try {
- wTx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ wTx.commit().get();
+ } catch (final ExecutionException | InterruptedException e) {
LOG.error("Failed to initiate BMP Monitor {}.", this.monitorId.getValue(), e);
}
}
import static org.opendaylight.protocol.bmp.impl.app.TablesUtil.BMP_ATTRIBUTES_QNAME;
import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.prefixes.DestinationIpv4Builder;
this.tables = createTableInstance(tableTypes, tablesRoot, tx, ribExtensions, tree).build();
LOG.debug("New RIB table {} structure installed.", tablesRoot.toString());
- tx.submit();
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
public static BmpRibInWriter create(@Nonnull final YangInstanceIdentifier tablesRootPath,
final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
ctx.writeRoutes(tx, nlri, attributes);
LOG.trace("Write routes {}", nlri);
- tx.submit();
- }
-
- private synchronized void removeRoutes(final MpUnreachNlri nlri) {
- final TablesKey key = new TablesKey(nlri.getAfi(), nlri.getSafi());
- final TableContext ctx = this.tables.get(key);
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
- if (ctx == null) {
- LOG.debug("No table for {}, not accepting NLRI {}", key, nlri);
- return;
- }
- LOG.trace("Removing routes {}", nlri);
- final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
- ctx.removeRoutes(tx, nlri);
- tx.submit();
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
/**
return b.build();
}
+ private synchronized void removeRoutes(final MpUnreachNlri nlri) {
+ final TablesKey key = new TablesKey(nlri.getAfi(), nlri.getSafi());
+ final TableContext ctx = this.tables.get(key);
+
+ if (ctx == null) {
+ LOG.debug("No table for {}, not accepting NLRI {}", key, nlri);
+ return;
+ }
+ LOG.trace("Removing routes {}", nlri);
+ final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
+ ctx.removeRoutes(tx, nlri);
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
+ }
+
/**
* Create MPUnreach for the prefixes to be handled in the same way as linkstate routes.
*
final DOMDataWriteTransaction tx = this.chain.newWriteOnlyTransaction();
final TableContext ctxPre = this.tables.get(tableTypes);
tx.merge(LogicalDatastoreType.OPERATIONAL, ctxPre.getTableId().node(BMP_ATTRIBUTES_QNAME)
- .node(ATTRIBUTES_UPTODATE_TRUE.getNodeType()),
- ATTRIBUTES_UPTODATE_TRUE);
- tx.submit();
+ .node(ATTRIBUTES_UPTODATE_TRUE.getNodeType()), ATTRIBUTES_UPTODATE_TRUE);
+ tx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
}
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.api.BmpSession;
import org.opendaylight.protocol.bmp.impl.spi.BmpRouter;
// it means the session was closed before it was written to datastore
final DOMDataWriteTransaction wTx = this.domDataBroker.newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.routerYangIId);
- wTx.submit().checkedGet();
- } catch (final TransactionCommitFailedException e) {
+ wTx.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
LOG.error("Failed to remove BMP router data from DS.", e);
}
this.sessionManager.removeSessionListener(this);
.withChild(ImmutableNodes.leafNode(ROUTER_ID_QNAME, this.routerIp))
.withChild(ImmutableNodes.leafNode(ROUTER_STATUS_QNAME, DOWN))
.withChild(ImmutableNodes.mapNodeBuilder(Peer.QNAME).build()).build());
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
private synchronized void onInitiate(final InitiationMessage initiation) {
.withChild(ImmutableNodes.leafNode(ROUTER_INFO_QNAME, getStringInfo(initiation.getTlvs()
.getStringInformation())))
.withChild(ImmutableNodes.leafNode(ROUTER_STATUS_QNAME, UP)).build());
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
private synchronized void onPeerUp(final PeerUpNotification peerUp) {
import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Locale;
import java.util.Set;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.impl.spi.BmpRouterPeer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public final class BmpRouterPeerImpl implements BmpRouterPeer {
+ private static final Logger LOG = LoggerFactory.getLogger(BmpRouterPeerImpl.class);
private static final String TIMESTAMP_SEC = "timestamp-sec";
private static final QName PEER_ID_QNAME = create(Peer.QNAME, "peer-id").intern();
final Set<TablesKey> peerTables = setPeerTables(peerUp.getReceivedOpen());
final DOMDataWriteTransaction wTx = this.domTxChain.newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL, this.peerYangIId, createPeerEntry(peerUp));
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
this.prePolicyWriter = BmpRibInWriter.create(this.peerYangIId.node(PrePolicyRib.QNAME).node(BMP_TABLES_QNAME),
this.domTxChain, extensions, peerTables, tree);
this.postPolicyWriter = BmpRibInWriter.create(this.peerYangIId.node(PostPolicyRib.QNAME).node(BMP_TABLES_QNAME),
final DOMDataWriteTransaction wTx = this.domTxChain.newWriteOnlyTransaction();
wTx.merge(LogicalDatastoreType.OPERATIONAL, this.peerYangIId.node(Stats.QNAME),
createStats(statsReports, statsReports.getPeerHeader().getTimestampSec()));
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
}
}
final DOMDataWriteTransaction wTx = this.domTxChain.newWriteOnlyTransaction();
wTx.merge(LogicalDatastoreType.OPERATIONAL, this.peerYangIId.node(Mirrors.QNAME),
createMirrors(mirror, mirror.getPeerHeader().getTimestampSec()));
- wTx.submit();
- }
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
+ }
private synchronized void onPeerDown() {
final DOMDataWriteTransaction wTx = this.domTxChain.newWriteOnlyTransaction();
wTx.delete(LogicalDatastoreType.OPERATIONAL, this.peerYangIId);
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
close();
}
import static java.util.Objects.requireNonNull;
import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
import java.net.InetSocketAddress;
import java.util.Collection;
import java.util.HashMap;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bmp.api.BmpDispatcher;
import org.opendaylight.protocol.bmp.impl.app.BmpMonitoringStationImpl;
import org.opendaylight.protocol.bmp.impl.spi.BmpMonitoringStation;
public synchronized void init() {
final DOMDataWriteTransaction wTx = this.bmpDeployerDependencies.getDomDataBroker().newWriteOnlyTransaction();
wTx.merge(LogicalDatastoreType.OPERATIONAL, BMP_MONITOR_YII, EMPTY_PARENT_NODE);
- wTx.submit();
+ wTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.trace("Successful commit");
+ }
+
+ @Override
+ public void onFailure(final Throwable trw) {
+ LOG.error("Failed commit", trw);
+ }
+ }, MoreExecutors.directExecutor());
this.registration = this.bmpDeployerDependencies.getDataBroker().registerDataTreeChangeListener(
new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, ODL_BMP_MONITORS_IID), this);
}
Code Review / bgpcep.git / commitdiff