import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.primitives.UnsignedBytes;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandler;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandlerRegistry;
if (!Strings.isNullOrEmpty(macAddress)) {
return Optional.of(parseMacAddress(macAddress));
}
- return Optional.absent();
+ return Optional.empty();
}
private byte[] parseMacAddress(String macAddress) {
import static org.opendaylight.genius.alivenessmonitor.protocols.AlivenessMonitorAndProtocolsConstants.SEPERATOR;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.util.concurrent.FutureCallback;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
}
private Optional<PhysAddress> getMacAddress(EndpointType source) {
- Optional<PhysAddress> result = Optional.absent();
+ Optional<PhysAddress> result = Optional.empty();
if (source instanceof Interface) {
result = Optional.of(((Interface) source).getMacAddress());
}
import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.genius.alivenessmonitor.internal.AlivenessMonitor;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandler;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandlerRegistry;
import org.opendaylight.genius.alivenessmonitor.protocols.internal.AlivenessProtocolHandlerARP;
import org.opendaylight.genius.alivenessmonitor.protocols.internal.AlivenessProtocolHandlerLLDP;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandler;
import org.opendaylight.genius.alivenessmonitor.protocols.AlivenessProtocolHandlerRegistry;
import org.opendaylight.genius.alivenessmonitor.utils.AlivenessMonitorUtil;
import org.opendaylight.genius.mdsalutil.packet.utils.PacketUtil;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.util.Datastore.Operational;
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-adapter</artifactId>
- <type>test-jar</type>
<scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>yang-binding</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
<artifactId>southbound-api</artifactId>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
import java.util.List;
import java.util.function.Function;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.common.Uint64;
public interface TombstonedNodeManager {
<version>${project.version}</version>
<scope>test</scope>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-test-utils</artifactId>
*/
package org.opendaylight.genius.cloudscaler.rpcservice;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.CloudscalerRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ScaleinComputesEndInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ScaleinComputesEndOutput;
private final DataBroker dataBroker;
private final ComputeNodeManager computeNodeManager;
private final ManagedNewTransactionRunner txRunner;
- private final ItmTepClusteredListener itmTepClusteredListener;
+ //private final ItmTepClusteredListener itmTepClusteredListener;
//The following timestamp is not persisted across reboots
//upon reboot the timestamp will have a default value of that system timestamp
this.dataBroker = dataBroker;
this.computeNodeManager = computeNodeManager;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
- this.itmTepClusteredListener = new ItmTepClusteredListener(dataBroker);
- }
-
- @PostConstruct
- public void init() {
- itmTepClusteredListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+ //this.itmTepClusteredListener = new ItmTepClusteredListener(dataBroker);
}
@Override
input.getScaleinComputeNames().forEach(s -> tombstoneTheNode(s, tx, true));
input.getScaleinComputeNames().forEach(s -> LOG.info("Cloudscaler scalein-start {}", s));
try {
- tx.submit().checkedGet();
- } catch (TransactionCommitFailedException e) {
+ tx.commit().get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to tombstone all the nodes ", e);
ft.set(RpcResultBuilder.<ScaleinComputesStartOutput>failed().withError(RpcError.ErrorType.APPLICATION,
"Failed to tombstone all the nodes " + e.getMessage()).build());
input.getRecoverComputeNames().forEach(s -> tombstoneTheNode(s, tx, false));
input.getRecoverComputeNames().forEach(s -> LOG.info("Cloudscaler scalein-recover {}", s));
try {
- tx.submit().checkedGet();
- } catch (TransactionCommitFailedException e) {
+ tx.commit().get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to recover all the nodes ", e);
ft.set(RpcResultBuilder.<ScaleinComputesRecoverOutput>failed().withError(RpcError.ErrorType.APPLICATION,
"Failed to recover all the nodes " + e.getMessage()).build());
@SuppressWarnings("checkstyle:IllegalCatch")
public ListenableFuture<RpcResult<ScaleinComputesTepDeleteOutput>> scaleinComputesTepDelete(
ScaleinComputesTepDeleteInput input) {
- ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction();
+ ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction();
SettableFuture<RpcResult<ScaleinComputesTepDeleteOutput>> ft = SettableFuture.create();
Optional<TransportZones> tz;
try {
tz = readTx.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(TransportZones.class))
- .checkedGet();
- } catch (ReadFailedException e) {
+ .get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Cloudscaler Failed to read the transport zone {}", e.getMessage());
ft.set(RpcResultBuilder.<ScaleinComputesTepDeleteOutput>failed().withError(RpcError.ErrorType.APPLICATION,
"Failed to read the transport zone " + e.getMessage()).build());
return ft;
}
- class ItmTepClusteredListener extends AsyncClusteredDataTreeChangeListenerBase<Vteps, ItmTepClusteredListener> {
+ class ItmTepClusteredListener extends AbstractClusteredAsyncDataTreeChangeListener<Vteps> {
@Inject
ItmTepClusteredListener(DataBroker dataBroker) {
- super(Vteps.class, ItmTepClusteredListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,InstanceIdentifier.create(TransportZones.class)
+ .child(TransportZone.class).child(Vteps.class),
+ Executors.newSingleThreadExecutor("ItmTepClusteredListener", LOG));
}
@Override
- public InstanceIdentifier<Vteps> getWildCardPath() {
- return InstanceIdentifier.create(TransportZones.class)
- .child(TransportZone.class)
- .child(Vteps.class);
- }
-
- @Override
- protected void remove(InstanceIdentifier<Vteps> instanceIdentifier, Vteps tep) {
+ public void remove(InstanceIdentifier<Vteps> instanceIdentifier, Vteps tep) {
tepDeleteTimeStamp.put(tep.getDpnId(), System.currentTimeMillis());
}
@Override
- protected void update(InstanceIdentifier<Vteps> instanceIdentifier, Vteps vteps, Vteps t1) {
- }
-
- @Override
- protected void add(InstanceIdentifier<Vteps> instanceIdentifier, Vteps vteps) {
+ public void update(InstanceIdentifier<Vteps> instanceIdentifier, Vteps vteps, Vteps t1) {
}
@Override
- protected ItmTepClusteredListener getDataTreeChangeListener() {
- return ItmTepClusteredListener.this;
+ public void add(InstanceIdentifier<Vteps> instanceIdentifier, Vteps vteps) {
}
}
}
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ComputeNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.compute.nodes.ComputeNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.compute.nodes.ComputeNodeBuilder;
public ComputeNode getComputeNodeFromName(String computeName) throws ReadFailedException {
InstanceIdentifier<ComputeNode> computeIid = buildComputeNodeIid(computeName);
- return computeNodeCache.get(computeIid).orNull();
+ return computeNodeCache.get(computeIid).orElse(null);
}
public void deleteComputeNode(ReadWriteTransaction tx, ComputeNode computeNode) {
tx.delete(LogicalDatastoreType.CONFIGURATION, buildComputeNodeIid(computeNode.getComputeName()));
}
- public void add(@NonNull Node node) throws TransactionCommitFailedException {
+ public void add(@NonNull Node node) throws ExecutionException, InterruptedException {
OvsdbBridgeAugmentation bridgeAugmentation = node.augmentation(OvsdbBridgeAugmentation.class);
if (bridgeAugmentation != null && bridgeAugmentation.getBridgeOtherConfigs() != null) {
Uint64 datapathid = getDpnIdFromBridge(bridgeAugmentation);
.setDpnid(datapathid)
.setNodeid(nodeId)
.build();
- com.google.common.base.Optional<ComputeNode> computeNodeOptional = com.google.common.base.Optional.absent();
+ Optional<ComputeNode> computeNodeOptional = Optional.empty();
try {
computeNodeOptional = computeNodeCache.get(computeIid);
} catch (ReadFailedException e) {
}
public void putComputeDetailsInConfigDatastore(InstanceIdentifier<ComputeNode> computeIid,
- ComputeNode computeNode) throws TransactionCommitFailedException {
+ ComputeNode computeNode)
+ throws ExecutionException, InterruptedException {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, computeIid, computeNode);
- tx.submit().checkedGet();
+ tx.commit().get();
dpnIdVsComputeNode.put(computeNode.getDpnid(), computeNode);
//LOG.info("Write comute node details {}", computeNode);
}
- private void logErrorIfComputeNodeIsAlreadyTaken(Uint64 datapathid, String nodeId,
- com.google.common.base.Optional<ComputeNode> optional) {
+ private void logErrorIfComputeNodeIsAlreadyTaken(Uint64 datapathid, String nodeId, Optional<ComputeNode> optional) {
ComputeNode existingNode = optional.get();
if (!Objects.equals(existingNode.getNodeid(), nodeId)) {
LOG.error("ComputeNodeManager Compute is already connected by compute {}", existingNode);
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-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.ReadFailedException;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ComputeNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.compute.nodes.ComputeNode;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public boolean isDpnTombstoned(Uint64 dpnId) throws ReadFailedException {
+ public boolean isDpnTombstoned(Uint64 dpnId) {
if (dpnId == null) {
return false;
}
}
@Override
- public List<Uint64> filterTombStoned(List<Uint64> dpns) throws ReadFailedException {
+ public List<Uint64> filterTombStoned(List<Uint64> dpns) {
return dpns.stream().filter((dpn) -> {
- try {
- return !isDpnTombstoned(dpn);
- } catch (ReadFailedException e) {
- LOG.error("Failed to read {}", dpn);
- return true;
- }
+ return !isDpnTombstoned(dpn);
}).collect(Collectors.toList());
}
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<reference id="cacheProvider"
package org.opendaylight.genius.cloudscaler.tests;
import static org.junit.Assert.assertTrue;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.cloudscaler.api.ScaleInConstants;
import org.opendaylight.genius.cloudscaler.rpcservice.CloudscalerRpcServiceImpl;
import org.opendaylight.genius.cloudscaler.rpcservice.ComputeNodeManager;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ComputeNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ScaleinComputesRecoverInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ScaleinComputesRecoverOutput;
}
@Test public void testBridgeAdd()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
dataBroker.syncWrite(OPERATIONAL, buildNodeId(NODEID1), buildNode(NODEID1, COMPUTE1, DPN1_DATAPATHID));
dataBroker.syncWrite(OPERATIONAL, buildNodeId(NODEID2), buildNode(NODEID2, COMPUTE2, DPN2_DATAPATHID));
}
@Test public void testScaleinComputesStartRpc()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
testBridgeAdd();
ListenableFuture<RpcResult<ScaleinComputesStartOutput>> ft = scaleInRpcManager.scaleinComputesStart(
new ScaleinComputesStartInputBuilder().setScaleinComputeNames(
}
@Test public void testScaleinComputesRecoverRpc()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
testScaleinComputesStartRpc();
}
@Test public void testIsDpnTombstonedApi()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
testScaleinComputesStartRpc();
assertTrue("Dpn 1 should be marked as tombstoned", tombstonedNodeManager.isDpnTombstoned(DPN1));
}
@Test public void testfilterTombstoned()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
testScaleinComputesStartRpc();
List<Uint64> filtered = tombstonedNodeManager.filterTombStoned(Lists.newArrayList(DPN1, DPN2, DPN3, DPN4));
}
@Test public void testRecoveryCallback()
- throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException, TransactionCommitFailedException {
Set<Uint64> nodesRecoverd = new HashSet<>();
tombstonedNodeManager.addOnRecoveryCallback((dpnId) -> {
*/
package org.opendaylight.genius.cloudscaler.tests;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.Executors;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.caches.baseimpl.CacheManagersRegistry;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
public class CloudScalerServiceTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() {
- DataBroker dataBroker = DataBrokerTestModule.dataBroker();
+ protected void configureBindings() throws Exception {
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
bind(DataBroker.class).toInstance(dataBroker);
bind(CacheManagersRegistry.class).to(CacheManagersRegistryImpl.class);
bind(CacheProvider.class).to(GuavaCacheProvider.class);
<artifactId>mdsal-binding-test-utils</artifactId>
<scope>compile</scope>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>compile</scope>
<artifactId>sal-binding-broker-impl</artifactId>
<type>test-jar</type>
<scope>compile</scope>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>mdsalutil-api</artifactId>
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.testutils.interfacemanager.InterfaceHelper;
import org.opendaylight.genius.testutils.interfacemanager.InterfaceStateHelper;
import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yangtools.yang.common.Uint64;
}
public void addInterfaceInfo(InterfaceInfo interfaceInfo)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
if (optDataBroker.isPresent()) {
- // Can't use ifPresent() here because of checked exception from tx.submit().checkedGet();
+ // Can't use ifPresent() here because of checked exception from tx.commit().get();
DataBroker dataBroker = optDataBroker.get();
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.put(LogicalDatastoreType.OPERATIONAL,
InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
- tx.submit().checkedGet();
+ tx.commit().get();
addInterface(iface);
}
}
}
public void addTunnelInterface(TunnelInterfaceDetails tunnelInterfaceDetails)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
InterfaceInfo interfaceInfo = tunnelInterfaceDetails.getInterfaceInfo();
interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
if (optDataBroker.isPresent()) {
- // Can't use ifPresent() here because of checked exception from tx.submit().checkedGet();
+ // Can't use ifPresent() here because of checked exception from tx.commit().get();
DataBroker dataBroker = optDataBroker.get();
Interface iface = InterfaceHelper.buildVxlanTunnelInterfaceFromInfo(tunnelInterfaceDetails);
tx.put(LogicalDatastoreType.OPERATIONAL,
InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
- tx.submit().checkedGet();
+ tx.commit().get();
externalInterfaces.put(interfaceInfo.getInterfaceName(), true);
addInterface(iface);
}
package org.opendaylight.genius.testutils.interfacemanager;
import java.util.Collections;
-
-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.ReadFailedException;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
}
public static Interface readInterfaceFromConfigDs(String interfaceName,
- DataBroker dataBroker) throws ReadFailedException {
+ DataBroker dataBroker) throws
+ ExecutionException, InterruptedException, ExpectedDataObjectNotFoundException {
return SingleTransactionDataBroker.syncRead(
dataBroker,
LogicalDatastoreType.CONFIGURATION,
*/
package org.opendaylight.genius.idmanager;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
return Optional.of(id);
}
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.genius.idmanager;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
public interface IdHolder {
import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toCollection;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.yangtools.yang.binding.CodeHelpers.nonnull;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.CompletableFuture;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-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.ReadFailedException;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
try {
idPoolsOptional = singleTxDB.syncReadOptional(LogicalDatastoreType.CONFIGURATION, idPoolsInstance);
break;
- } catch (ReadFailedException e) {
+ } catch (ExecutionException e) {
LOG.error("Failed to read the id pools due to error. Retrying again...", e);
}
Thread.sleep(2000);
}
private List<Uint32> allocateIdFromLocalPool(String parentPoolName, String localPoolName,
- String idKey, long size) throws OperationFailedException, IdManagerException {
+ String idKey, long size) throws OperationFailedException, IdManagerException, ExecutionException,
+ InterruptedException {
LOG.debug("Allocating id from local pool {}. Parent pool {}. Idkey {}", localPoolName, parentPoolName, idKey);
String uniqueIdKey = idUtils.getUniqueKey(parentPoolName, idKey);
CompletableFuture<List<Uint32>> futureIdValues = new CompletableFuture<>();
}
private ReleaseIdOutputBuilder releaseIdFromLocalPool(String parentPoolName, String localPoolName, String idKey)
- throws ReadFailedException, IdManagerException {
+ throws IdManagerException, ReadFailedException, ExecutionException, InterruptedException {
String idLatchKey = idUtils.getUniqueKey(parentPoolName, idKey);
LOG.debug("Releasing ID {} from pool {}", idKey, localPoolName);
CountDownLatch latch = idUtils.getReleaseIdLatch(idLatchKey);
private List<Uint32> checkForIdInIdEntries(String parentPoolName, String idKey, String uniqueIdKey,
CompletableFuture<List<Uint32>> futureIdValues, boolean hasExistingFutureIdValues)
- throws IdManagerException, ReadFailedException {
+ throws IdManagerException, InterruptedException , ExecutionException {
InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier = idUtils.getIdPoolInstance(parentPoolName);
InstanceIdentifier<IdEntries> existingId = idUtils.getIdEntry(parentIdPoolInstanceIdentifier, idKey);
idUtils.lock(lockManager, uniqueIdKey);
updateLocalIdPoolCache(childIdPoolOpt.get(), parentPoolName);
}
}
- catch (ReadFailedException ex) {
+ catch (ExecutionException | InterruptedException ex) {
LOG.debug("Failed to read id pool {} due to {}", localPoolName, ex.getMessage());
}
if (localPool.get(parentPoolName) == null) {
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.infrautils.utils.concurrent.Executors;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredAsyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.genius.idmanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
*/
package org.opendaylight.genius.idmanager;
-import com.google.common.base.Optional;
import java.io.Serializable;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;
import org.eclipse.jdt.annotation.NonNull;
@Override
public Optional<Long> allocateId() {
long curTimeSec = System.currentTimeMillis() / 1000;
- Optional<Long> allocatedId = Optional.absent();
+ Optional<Long> allocatedId = Optional.empty();
if (isIdAvailable(curTimeSec)) {
Long count = availableIdCount.decrementAndGet();
if (count < 0L) {
*/
package org.opendaylight.genius.idmanager.jobs;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
-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.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.idmanager.IdLocalPool;
import org.opendaylight.genius.idmanager.IdManagerException;
import org.opendaylight.genius.idmanager.ReleasedIdHolder;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
}
private void cleanupExcessIds()
- throws IdManagerException, ReadFailedException, TransactionCommitFailedException {
+ throws IdManagerException, TransactionCommitFailedException, ExecutionException , InterruptedException {
// We can update the availableCount here... and update it in DS using IdHolderSyncJob
long totalAvailableIdCount = idLocalPool.getAvailableIds().getAvailableIdCount()
+ idLocalPool.getReleasedIds().getAvailableIdCount();
*/
package org.opendaylight.genius.idmanager.jobs;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
*/
package org.opendaylight.genius.idmanager.jobs;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.binding.testutils.AssertDataObjects;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(ID_POOL_NAME), parentIdPool);
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(localPoolName), childPool);
- tx.submit().get();
+ tx.commit().get();
AllocateIdInput allocateIdInput2 = new AllocateIdInputBuilder().setIdKey(TEST_KEY1).setPoolName(ID_POOL_NAME)
.build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(ID_POOL_NAME), parentIdPool);
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(localPoolName), childPool);
- tx.submit().get();
+ tx.commit().get();
// Wait for the changes to be available on the caches.
asyncEventsWaiter.awaitEventsConsumption();
requestIdsConcurrently(false);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(ID_POOL_NAME), parentIdPool);
tx.merge(LogicalDatastoreType.CONFIGURATION, getIdPoolIdentifier(localPoolName), childPool);
- tx.submit().get();
+ tx.commit().get();
requestIdsConcurrently(true);
coordinatorEventsWaiter.awaitEventsConsumption();
*/
package org.opendaylight.genius.idmanager.test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.TestableJobCoordinatorEventsWaiter;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.interfaces.testutils.TestIMdsalApiManager;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
public class IdManagerTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() {
+ protected void configureBindings() throws Exception {
bind(DataImportBootReady.class).toInstance(new DataImportBootReady() {});
bind(IdManagerService.class).to(IdManager.class);
bind(LockManagerService.class).to(LockManagerServiceImpl.class);
bind(LockListener.class);
bind(IdPoolListener.class);
bind(JobCoordinatorEventsWaiter.class).to(TestableJobCoordinatorEventsWaiter.class);
- DataBroker dataBroker = DataBrokerTestModule.dataBroker();
+
+ /*AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();*/
+ /***************/
+ AbstractConcurrentDataBrokerTest dataBrokerTest = new AbstractConcurrentDataBrokerTest(false) {};
+ dataBrokerTest.setup();
+ DataBroker dataBroker = dataBrokerTest.getDataBroker();
bind(DataBroker.class).toInstance(dataBroker);
}
}
*/
package org.opendaylight.genius.interfacemanager.globals;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.FlowInfoKey;
import org.opendaylight.genius.mdsalutil.GroupInfoKey;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.matches.MatchInPort;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.mdsalutil.matches.MatchVlanVid;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.common.Uint8;
public final class InterfaceServiceUtil {
* @deprecated Use {@link #buildServiceInfo(String, int)}.
*/
@Deprecated
- public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, int servicePriority,
+ public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, Uint8 servicePriority,
Uint64 cookie, List<Instruction> instructions) {
return buildServiceInfo(serviceName, servicePriority);
}
* @deprecated Use {@link #buildServiceInfo(String, int)}.
*/
@Deprecated
- public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, int servicePriority,
+ public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, Uint8 servicePriority,
Uint64 cookie) {
return buildServiceInfo(serviceName, servicePriority);
}
- public static ServicesInfo buildServiceInfo(String serviceName, int servicePriority) {
+ public static ServicesInfo buildServiceInfo(String serviceName, Uint8 servicePriority) {
List<BoundServices> boundService = new ArrayList<>();
- boundService.add(new BoundServicesBuilder().setServicePriority((short) servicePriority)
+ boundService.add(new BoundServicesBuilder().setServicePriority(servicePriority)
.setServiceName(serviceName).build());
return new ServicesInfoBuilder().setBoundServices(boundService)
.withKey(new ServicesInfoKey(serviceName, ServiceModeIngress.class)).build();
}
- public static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
+ public static BoundServices getBoundServices(String serviceName, Uint8 servicePriority, Uint16 flowPriority,
Uint64 cookie, List<Instruction> instructions) {
StypeOpenflowBuilder augBuilder = new StypeOpenflowBuilder().setFlowCookie(cookie).setFlowPriority(flowPriority)
.setInstruction(instructions);
matches.add(match);
}
- public static short getVlanId(String interfaceName, DataBroker broker) {
+ public static short getVlanId(String interfaceName, DataBroker broker) throws ExecutionException,
+ InterruptedException {
InstanceIdentifier<Interface> id = InstanceIdentifier.builder(Interfaces.class)
.child(Interface.class, new InterfaceKey(interfaceName)).build();
- Optional<Interface> ifInstance = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, id, broker);
+ Optional<Interface> ifInstance = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, id);
if (ifInstance.isPresent()) {
IfL2vlan vlanIface = ifInstance.get().augmentation(IfL2vlan.class);
return vlanIface.getVlanId() == null ? 0 : vlanIface.getVlanId().getValue().shortValue();
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.interfacemanager.exceptions.InterfaceAlreadyExistsException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
* @return The interface information.
* @throws ReadFailedException if an exception occurs while reading from the datastore.
*/
- Interface getInterfaceInfoFromConfigDataStore(ReadTransaction tx, String interfaceName) throws ReadFailedException;
+ Interface getInterfaceInfoFromConfigDataStore(ReadTransaction tx, String interfaceName)
+ throws ReadFailedException, ExecutionException, InterruptedException;
/**
* Create a VLAN interface.
* @return The child interfaces.
* @throws ReadFailedException if an exception occurs while reading from the datastore.
*/
- List<Interface> getChildInterfaces(ReadTransaction tx, String parentInterface) throws ReadFailedException;
+ List<Interface> getChildInterfaces(ReadTransaction tx, String parentInterface)
+ throws ReadFailedException, ExecutionException, InterruptedException;
/**
* Determine whether an interface is external.
* @return {@code true} if the interface is external, {@code false} if it isn't.
* @throws ReadFailedException if an exception occurs while reading from the datastore.
*/
- boolean isExternalInterface(ReadTransaction tx, String interfaceName) throws ReadFailedException;
+ boolean isExternalInterface(ReadTransaction tx, String interfaceName)
+ throws ReadFailedException, ExecutionException, InterruptedException;
String getPortNameForInterface(NodeConnectorId nodeConnectorId, String interfaceName);
<groupId>org.opendaylight.serviceutils</groupId>
<artifactId>srm-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.serviceutils</groupId>
+ <artifactId>listener-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
<artifactId>southbound-api</artifactId>
*/
package org.opendaylight.genius.interfacemanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.GRE_TRUNK_INTERFACE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.LOGICAL_GROUP_INTERFACE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.MPLS_OVER_GRE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.VLAN_INTERFACE;
import static org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.VXLAN_TRUNK_INTERFACE;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.regex.Pattern;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.actions.ActionSetTunnelDestinationIp;
import org.opendaylight.genius.mdsalutil.actions.ActionSetTunnelSourceIp;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
@Deprecated
public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, DataBroker broker) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Cannot read identifier", e);
*/
package org.opendaylight.genius.interfacemanager;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
@Override
public Interface getInterfaceInfoFromConfigDataStore(ReadTransaction tx, String interfaceName)
- throws ReadFailedException {
+ throws ExecutionException, InterruptedException {
return interfaceManagerCommonUtils.getInterfaceFromConfigDS(tx, new InterfaceKey(interfaceName));
}
try {
return SingleTransactionDataBroker
.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, boundServicesIId).isPresent();
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.warn("Error while reading [{}]", boundServicesIId, e);
return false;
}
@Override
public List<Interface> getChildInterfaces(String parentInterface) {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return getChildInterfaces(tx, parentInterface);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Error retrieving child interfaces of {} from config", parentInterface, e);
throw new RuntimeException("Error retrieving child interfaces of " + parentInterface + " from config", e);
}
}
@Override
- public List<Interface> getChildInterfaces(ReadTransaction tx, String parentInterface) throws ReadFailedException {
+ public List<Interface> getChildInterfaces(ReadTransaction tx, String parentInterface) throws
+ ExecutionException, InterruptedException {
InterfaceParentEntry parentEntry = interfaceMetaUtils.getInterfaceParentEntryFromConfigDS(tx, parentInterface);
if (parentEntry == null) {
LOG.debug("No parent entry found for {}", parentInterface);
}
@Override
- public boolean isExternalInterface(ReadTransaction tx, String interfaceName) throws ReadFailedException {
+ public boolean isExternalInterface(ReadTransaction tx, String interfaceName) throws
+ ExecutionException, InterruptedException {
return isExternalInterface(getInterfaceInfoFromConfigDataStore(tx, interfaceName));
}
try {
node = SingleTransactionDataBroker.syncRead(
dataBroker, LogicalDatastoreType.OPERATIONAL, nodeIid);
- } catch (ReadFailedException e) {
+ } catch (ExpectedDataObjectNotFoundException e) {
LOG.error("Failed to read Node for {} ", nodeIid, e);
return null;
}
*/
package org.opendaylight.genius.interfacemanager.commons;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadTransaction;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInput;
throws ExecutionException, InterruptedException {
InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class)
.child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
- return tx.read(id).get().toJavaUtil().map(MonitorIdInterface::getInterfaceName).orElse(null);
+ return tx.read(id).get().map(MonitorIdInterface::getInterfaceName).orElse(null);
}
private void removeMonitorIdInterfaceMap(TypedReadWriteTransaction<Operational> tx, Uint32 monitorId)
throws ExecutionException, InterruptedException {
InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class)
.child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
- return tx.read(id).get().toJavaUtil().map(InterfaceMonitorId::getMonitorId).orElse(null);
+ return tx.read(id).get().map(InterfaceMonitorId::getMonitorId).orElse(null);
}
public Uint32 createMonitorProfile(MonitorProfileCreateInput monitorProfileCreateInput) {
*/
package org.opendaylight.genius.interfacemanager.commons;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import org.apache.commons.lang3.tuple.Pair;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.matches.MatchInPort;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchTunnelDestinationIp;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchTunnelSourceIp;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Other;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
.child(Node.class, new NodeKey(nodeId))
.child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)).build();
- return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ncIdentifier, dataBroker).orNull();
+ return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ncIdentifier, dataBroker).orElse(null);
}
- public boolean isNodePresent(ReadTransaction tx, NodeConnectorId nodeConnectorId) throws ReadFailedException {
+ public boolean isNodePresent(ReadTransaction tx, NodeConnectorId nodeConnectorId) throws
+ ExecutionException, InterruptedException {
NodeId nodeID = IfmUtil.getNodeIdFromNodeConnectorId(nodeConnectorId);
InstanceIdentifier<Node> nodeInstanceIdentifier = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeID)).build();
- return tx.exists(LogicalDatastoreType.OPERATIONAL, nodeInstanceIdentifier).checkedGet();
+ return tx.exists(LogicalDatastoreType.OPERATIONAL, nodeInstanceIdentifier).get();
}
public static InstanceIdentifier<Interface> getInterfaceIdentifier(InterfaceKey interfaceKey) {
@Deprecated
@Nullable
public Interface getInterfaceFromConfigDS(String interfaceName) {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return getInterfaceFromConfigDS(tx, interfaceName);
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.error("Error retrieving interface {} from config", interfaceName, e);
throw new RuntimeException("Error retrieving interface " + interfaceName + " from config", e);
}
}
@Nullable
- public Interface getInterfaceFromConfigDS(ReadTransaction tx, String interfaceName) throws ReadFailedException {
+ public Interface getInterfaceFromConfigDS(ReadTransaction tx, String interfaceName) throws
+ ExecutionException, InterruptedException {
Interface iface = interfaceConfigMap.get(interfaceName);
if (iface != null) {
return iface;
}
InstanceIdentifier<Interface> interfaceId = getInterfaceIdentifier(new InterfaceKey(interfaceName));
- Optional<Interface> interfaceOptional = tx.read(LogicalDatastoreType.CONFIGURATION, interfaceId).checkedGet();
+ Optional<Interface> interfaceOptional = tx.read(LogicalDatastoreType.CONFIGURATION, interfaceId).get();
if (interfaceOptional.isPresent()) {
iface = interfaceOptional.get();
}
}
public Interface getInterfaceFromConfigDS(ReadTransaction tx, InterfaceKey interfaceKey)
- throws ReadFailedException {
+ throws ExecutionException, InterruptedException {
return getInterfaceFromConfigDS(tx, interfaceKey.getName());
}
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateFromOperDS(String interfaceName) {
return IfmUtil.read(LogicalDatastoreType.OPERATIONAL,
- IfmUtil.buildStateInterfaceId(interfaceName), dataBroker).orNull();
+ IfmUtil.buildStateInterfaceId(interfaceName), dataBroker).orElse(null);
}
public org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateFromOperDS(
TypedReadTransaction<Operational> tx, String interfaceName)
throws ExecutionException, InterruptedException {
- return tx.read(IfmUtil.buildStateInterfaceId(interfaceName)).get().orNull();
+ return tx.read(IfmUtil.buildStateInterfaceId(interfaceName)).get().orElse(null);
}
@Deprecated
.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateFromOperDS(
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId) {
- return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orNull();
+ return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orElse(null);
}
public void addTunnelIngressFlow(TypedWriteTransaction<Configuration> tx, IfTunnel tunnel, Uint64 dpnId,
*/
package org.opendaylight.genius.interfacemanager.commons;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedReadTransaction;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.BatchingUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeInterfaceInfo;
InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
BridgeRefEntry bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL,
- bridgeRefEntryIid, dataBroker).orNull();
+ bridgeRefEntryIid, dataBroker).orElse(null);
if (bridgeRefEntry != null) {
addBridgeRefEntryToCache(dpId, bridgeRefEntry);
}
BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpId);
InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
- bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker).orNull();
+ bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker).orElse(null);
if (bridgeRefEntry != null) {
addBridgeRefEntryToCache(dpId, bridgeRefEntry);
}
private BridgeEntry readBridgeEntryFromConfigDS(
InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier) {
- return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker).orNull();
+ return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker).orElse(null);
}
public static InstanceIdentifier<BridgeInterfaceEntry> getBridgeInterfaceEntryIdentifier(
}
public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx, String interfaceName)
- throws ReadFailedException {
+ throws ExecutionException, InterruptedException {
InterfaceParentEntryKey interfaceParentEntryKey = new InterfaceParentEntryKey(interfaceName);
InterfaceParentEntry interfaceParentEntry = getInterfaceParentEntryFromConfigDS(tx, interfaceParentEntryKey);
return interfaceParentEntry;
}
public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx,
- InterfaceParentEntryKey interfaceParentEntryKey) throws ReadFailedException {
+ InterfaceParentEntryKey interfaceParentEntryKey) throws ExecutionException, InterruptedException {
InstanceIdentifier<InterfaceParentEntry> intfParentIid =
getInterfaceParentEntryIdentifier(interfaceParentEntryKey);
}
public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(InstanceIdentifier<InterfaceParentEntry> intfId) {
- return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker).orNull();
+ return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker).orElse(null);
}
public InterfaceParentEntry getInterfaceParentEntryFromConfigDS(ReadTransaction tx,
- InstanceIdentifier<InterfaceParentEntry> intfId) throws ReadFailedException {
- return tx.read(LogicalDatastoreType.CONFIGURATION, intfId).checkedGet().orNull();
+ InstanceIdentifier<InterfaceParentEntry> intfId) throws ExecutionException, InterruptedException {
+ return tx.read(LogicalDatastoreType.CONFIGURATION, intfId).get().orElse(null);
}
public InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
public InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
InstanceIdentifier<InterfaceChildEntry> intfChildIid) {
- return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker).orNull();
+ return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker).orElse(null);
}
public void createLportTagInterfaceMap(String infName, Integer ifIndex) {
throws ExecutionException, InterruptedException {
InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class)
.child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
- return tx.read(id).get().toJavaUtil().map(TunnelInstanceInterface::getInterfaceName).orElse(null);
+ return tx.read(id).get().map(TunnelInstanceInterface::getInterfaceName).orElse(null);
}
public void deleteBridgeInterfaceEntry(BridgeEntryKey bridgeEntryKey,
}
InstanceIdentifier<Node> nodeIid =
bridgeRefEntry.getBridgeReference().getValue().firstIdentifierOf(Node.class);
- com.google.common.base.Optional<Node> optNode =
+ Optional<Node> optNode =
IfmUtil.read(LogicalDatastoreType.OPERATIONAL, nodeIid, dataBroker);
if (optNode.isPresent()) {
return optNode.get().getTerminationPoint();
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.LivenessState;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeInterfaceInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
private final InterfaceMetaUtils interfaceMetaUtils;
private final ListenerRegistration<CacheBridgeEntryConfigListener> registration;
- private final DataTreeIdentifier<BridgeEntry> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ private final DataTreeIdentifier<BridgeEntry> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(BridgeInterfaceInfo.class).child(BridgeEntry.class));
@Inject
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
private final InterfaceMetaUtils interfaceMetaUtils;
private final ListenerRegistration<CacheBridgeRefEntryListener> registration;
- private final DataTreeIdentifier<BridgeRefEntry> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ private final DataTreeIdentifier<BridgeRefEntry> treeId =
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(BridgeRefInfo.class).child(BridgeRefEntry.class));
@Inject
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.renderer.hwvtep.confighelpers.HwVTEPInterfaceConfigUpdateHelper;
import org.opendaylight.genius.interfacemanager.renderer.hwvtep.utilities.SouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.renderer.hwvtep.statehelpers.HwVTEPInterfaceStateUpdateHelper;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
package org.opendaylight.genius.interfacemanager.listeners;
-import com.google.common.base.Optional;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-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.ReadFailedException;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.InterfaceChildInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
} catch (ReadFailedException ex) {
LOG.error("ReadFailedException exception", ex);
}
- return Optional.absent();
+ return Optional.empty();
}
private InstanceIdentifier<InterfaceParentEntry> getInterfaceParentEntryIdentifier(String parentInterfaceName) {
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.checkerframework.checker.nullness.qual.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortReason;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
/**
* This Class is a Data Change Listener for FlowCapableNodeConnector updates.
* This creates an entry in the interface-state OperDS for every node-connector
*/
@Singleton
public class InterfaceInventoryStateListener
- extends AsyncClusteredDataTreeChangeListenerBase<FlowCapableNodeConnector, InterfaceInventoryStateListener>
+ extends AbstractClusteredAsyncDataTreeChangeListener<FlowCapableNodeConnector>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceInventoryStateListener.class);
final InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
@Reference final ServiceRecoveryRegistry serviceRecoveryRegistry,
final InterfacemgrProvider interfacemgrProvider) {
- super(FlowCapableNodeConnector.class, InterfaceInventoryStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class).child(NodeConnector.class)
+ .augmentation(FlowCapableNodeConnector.class),
+ Executors.newSingleThreadExecutor("InterfaceInventoryStateListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.idManager = idManagerService;
this.interfaceMetaUtils = interfaceMetaUtils;
this.portNameCache = portNameCache;
this.interfacemgrProvider = interfacemgrProvider;
- registerListener();
serviceRecoveryRegistry.addRecoverableListener(interfaceServiceRecoveryHandler.buildServiceRegistryKey(),
this);
}
@Override
public void registerListener() {
- this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- }
-
- @Override
- protected InstanceIdentifier<FlowCapableNodeConnector> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).child(NodeConnector.class)
- .augmentation(FlowCapableNodeConnector.class);
+ super.register();
}
@Override
- protected InterfaceInventoryStateListener getDataTreeChangeListener() {
- return InterfaceInventoryStateListener.this;
+ public void deregisterListener() {
+ close();
}
@Override
- protected void remove(InstanceIdentifier<FlowCapableNodeConnector> key,
+ public void remove(InstanceIdentifier<FlowCapableNodeConnector> key,
FlowCapableNodeConnector flowCapableNodeConnectorOld) {
String interfaceName = flowCapableNodeConnectorOld.getName();
EVENT_LOGGER.debug("IFM-InterfaceInventoryState,REMOVE {}", interfaceName);
}
@Override
- protected void update(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorOld,
+ public void update(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorOld,
FlowCapableNodeConnector fcNodeConnectorNew) {
String interfaceName = fcNodeConnectorNew.getName();
EVENT_LOGGER.debug("IFM-InterfaceInventoryState,UPDATE {},{}", fcNodeConnectorNew.getName(),
}
@Override
- protected void add(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorNew) {
+ public void add(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorNew) {
String interfaceName = fcNodeConnectorNew.getName();
EVENT_LOGGER.debug("IFM-InterfaceInventoryState,ADD {}", interfaceName);
if (interfacemgrProvider.isItmDirectTunnelsEnabled()
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
@Singleton
public class InterfaceStateListener
- extends AsyncClusteredDataTreeChangeListenerBase<Interface, InterfaceStateListener> {
+ extends AbstractClusteredAsyncDataTreeChangeListener<Interface> {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateListener.class);
private final ManagedNewTransactionRunner txRunner;
private final EntityOwnershipUtils entityOwnershipUtils;
final EntityOwnershipUtils entityOwnershipUtils,
@Reference final JobCoordinator coordinator,
final InterfaceManagerCommonUtils interfaceManagerCommonUtils) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(InterfacesState.class).child(Interface.class),
+ Executors.newSingleThreadExecutor("NodeConnectorStatsImpl", LOG));
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.entityOwnershipUtils = entityOwnershipUtils;
this.coordinator = coordinator;
this.interfaceManagerCommonUtils = interfaceManagerCommonUtils;
- this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
- @Override
+ /*@Override
protected InstanceIdentifier<Interface> getWildCardPath() {
return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
- }
+ }*/
@Override
- protected void remove(InstanceIdentifier<Interface> key, Interface interfaceStateOld) {
+ public void remove(InstanceIdentifier<Interface> key, Interface interfaceStateOld) {
interfaceManagerCommonUtils.removeFromInterfaceStateCache(interfaceStateOld);
}
@Override
- protected void update(InstanceIdentifier<Interface> key, Interface interfaceStateOld, Interface interfaceStateNew) {
+ public void update(InstanceIdentifier<Interface> key, Interface interfaceStateOld, Interface interfaceStateNew) {
interfaceManagerCommonUtils.addInterfaceStateToCache(interfaceStateNew);
}
@Override
- protected void add(InstanceIdentifier<Interface> key, Interface interfaceStateNew) {
+ public void add(InstanceIdentifier<Interface> key, Interface interfaceStateNew) {
interfaceManagerCommonUtils.addInterfaceStateToCache(interfaceStateNew);
if (!Tunnel.class.equals(interfaceStateNew.getType())
|| !entityOwnershipUtils.isEntityOwner(IfmConstants.INTERFACE_CONFIG_ENTITY,
});
}
- @Override
+ /*@Override
protected InterfaceStateListener getDataTreeChangeListener() {
return InterfaceStateListener.this;
- }
+ }*/
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
@Singleton
public class InterfaceTopologyStateListener
- extends AsyncClusteredDataTreeChangeListenerBase<OvsdbBridgeAugmentation, InterfaceTopologyStateListener>
+ extends AbstractClusteredAsyncDataTreeChangeListener<OvsdbBridgeAugmentation>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(InterfaceTopologyStateListener.class);
private final DataBroker dataBroker;
final SouthboundUtils southboundUtils,
final InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
@Reference final ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(OvsdbBridgeAugmentation.class, InterfaceTopologyStateListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class).child(Node.class).augmentation(OvsdbBridgeAugmentation.class).build(),
+ Executors.newSingleThreadExecutor("InterfaceTopologyStateListener", LOG));
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.interfaceMgrProvider = interfaceMgrProvider;
this.ovsInterfaceTopologyStateUpdateHelper = ovsInterfaceTopologyStateUpdateHelper;
this.interfaceMetaUtils = interfaceMetaUtils;
this.southboundUtils = southboundUtils;
- registerListener();
serviceRecoveryRegistry.addRecoverableListener(interfaceServiceRecoveryHandler.buildServiceRegistryKey(),
this);
}
@Override
public void registerListener() {
- this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<OvsdbBridgeAugmentation> getWildCardPath() {
- return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class)
- .augmentation(OvsdbBridgeAugmentation.class).build();
- }
-
- @Override
- protected InterfaceTopologyStateListener getDataTreeChangeListener() {
- return InterfaceTopologyStateListener.this;
+ public void deregisterListener() {
+ close();
}
private void runOnlyInOwnerNode(String jobDesc, Runnable job) {
}
@Override
- protected void remove(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
+ public void remove(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
OvsdbBridgeAugmentation bridgeOld) {
LOG.debug("Received Remove DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
identifier, bridgeOld);
}
@Override
- protected void update(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
+ public void update(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
OvsdbBridgeAugmentation bridgeOld,
OvsdbBridgeAugmentation bridgeNew) {
LOG.debug(
}
@Override
- protected void add(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
+ public void add(InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
OvsdbBridgeAugmentation bridgeNew) {
LOG.debug("Received Add DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
identifier, bridgeNew);
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers.OvsInterfaceTopologyStateUpdateHelper;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
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;
@Singleton
public class TerminationPointStateListener extends
- AsyncClusteredDataTreeChangeListenerBase<OvsdbTerminationPointAugmentation, TerminationPointStateListener>
+ AbstractClusteredAsyncDataTreeChangeListener<OvsdbTerminationPointAugmentation>
implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointStateListener.class);
private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
ovsInterfaceTopologyStateUpdateHelper,
final InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
@Reference final ServiceRecoveryRegistry serviceRecoveryRegistry) {
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class).child(Node.class)
+ .child(TerminationPoint.class).augmentation(OvsdbTerminationPointAugmentation.class).build(),
+ Executors.newSingleThreadExecutor("TerminationPointStateListener", LOG));
this.interfaceMgrProvider = interfaceMgrProvider;
this.entityOwnershipUtils = entityOwnershipUtils;
this.coordinator = coordinator;
this.interfaceManagerCommonUtils = interfaceManagerCommonUtils;
this.ovsInterfaceTopologyStateUpdateHelper = ovsInterfaceTopologyStateUpdateHelper;
this.dataBroker = dataBroker;
- registerListener();
serviceRecoveryRegistry.addRecoverableListener(interfaceServiceRecoveryHandler.buildServiceRegistryKey(),
this);
}
@Override
public void registerListener() {
- this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
+ super.register();
}
@Override
- protected InstanceIdentifier<OvsdbTerminationPointAugmentation> getWildCardPath() {
- return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class)
- .child(TerminationPoint.class).augmentation(OvsdbTerminationPointAugmentation.class).build();
+ public void deregisterListener() {
+ close();
}
@Override
- protected TerminationPointStateListener getDataTreeChangeListener() {
- return TerminationPointStateListener.this;
- }
-
- @Override
- protected void remove(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
+ public void remove(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
OvsdbTerminationPointAugmentation tpOld) {
// No ItmDirectTunnels or Internal Tunnel checking is done here as this DTCN only results in removal
// of interface entry from BFD internal cache. For internal tunnels when ItmDirectTunnel is enabled,
}
@Override
- protected void update(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
+ public void update(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
OvsdbTerminationPointAugmentation tpOld,
OvsdbTerminationPointAugmentation tpNew) {
if (interfaceMgrProvider.isItmDirectTunnelsEnabled()
}
@Override
- protected void add(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
+ public void add(InstanceIdentifier<OvsdbTerminationPointAugmentation> identifier,
OvsdbTerminationPointAugmentation tpNew) {
if (interfaceMgrProvider.isItmDirectTunnelsEnabled()
&& InterfaceManagerCommonUtils.isTunnelPort(tpNew.getName())
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers.OvsVlanMemberConfigRemoveHelper;
import org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers.OvsVlanMemberConfigUpdateHelper;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import static org.opendaylight.infrautils.utils.concurrent.Executors.newListeningScheduledThreadPool;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.listeners.InterfaceChildCache;
import org.opendaylight.genius.interfacemanager.listeners.PortNameCache;
import org.opendaylight.infrautils.metrics.MetricDescriptor;
import org.opendaylight.infrautils.metrics.MetricProvider;
import org.opendaylight.infrautils.utils.UncheckedCloseable;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.GetFlowStatisticsOutput;
import org.slf4j.LoggerFactory;
@Singleton
-public class NodeConnectorStatsImpl extends AsyncClusteredDataTreeChangeListenerBase<Node, NodeConnectorStatsImpl> {
+public class NodeConnectorStatsImpl extends AbstractClusteredAsyncDataTreeChangeListener<Node> {
private static final Logger LOG = LoggerFactory.getLogger(NodeConnectorStatsImpl.class);
final InterfaceChildCache interfaceChildCache,
final IfmConfig ifmConfigObj,
final @Reference MetricProvider metricProvider) {
- super(Node.class, NodeConnectorStatsImpl.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(Nodes.class).child(Node.class),
+ Executors.newSingleThreadExecutor("NodeConnectorStatsImpl", LOG));
this.opendaylightDirectStatisticsService = opendaylightDirectStatisticsService;
this.entityOwnershipUtils = entityOwnershipUtils;
this.portNameCache = portNameCache;
this.interfaceChildCache = interfaceChildCache;
this.ifmConfig = ifmConfigObj;
this.metricProvider = metricProvider;
- registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
portStatExecutorService = newListeningScheduledThreadPool(THREAD_POOL_SIZE, "Port Stats Request Task", LOG);
}
- @Override
- public InstanceIdentifier<Node> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class);
- }
-
- @Override
- protected NodeConnectorStatsImpl getDataTreeChangeListener() {
- return NodeConnectorStatsImpl.this;
- }
-
@Override
@PreDestroy
public void close() {
}
@Override
- protected void remove(InstanceIdentifier<Node> identifier, Node node) {
+ public void remove(InstanceIdentifier<Node> identifier, Node node) {
NodeId nodeId = node.getId();
String dpId = nodeId.getValue().split(":")[1];
if (nodes.contains(dpId)) {
}
@Override
- protected void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
+ public void update(InstanceIdentifier<Node> identifier, Node original, Node update) {
// TODO Auto-generated method stub
}
@Override
- protected void add(InstanceIdentifier<Node> identifier, Node node) {
+ public void add(InstanceIdentifier<Node> identifier, Node node) {
NodeId nodeId = node.getId();
if (entityOwnershipUtils.isEntityOwner(IfmConstants.SERVICE_ENTITY_TYPE, nodeId.getValue())) {
LOG.trace("Locally connected switch {}",nodeId.getValue());
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
*/
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.confighelpers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
*/
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.confighelpers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
*/
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.statehelpers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
*/
package org.opendaylight.genius.interfacemanager.renderer.hwvtep.utilities;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.interfacemanager.IfmUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.batching.ActionableResource;
import org.opendaylight.genius.utils.batching.ActionableResources;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.genius.interfacemanager.renderer.ovs.utilities;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.batching.ResourceHandler;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.genius.utils.batching.SubTransactionImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
buildSubTransactions(transactionObjects, identifier, update, SubTransaction.UPDATE);
}
+ @Override
+ public void updateContainer(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier
+ identifier, Object original, Object update, List<SubTransaction> transactionObjects) {
+ //no-op
+ }
+
@Override
public void create(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
Object data, List<SubTransaction> transactionObjects) {
*/
package org.opendaylight.genius.interfacemanager.renderer.ovs.utilities;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.Maps;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.commons.lang3.BooleanUtils;
-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.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.infrautils.caches.CacheConfigBuilder;
import org.opendaylight.infrautils.caches.CachePolicyBuilder;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
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.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
*/
package org.opendaylight.genius.interfacemanager.rpcservice;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-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.ReadFailedException;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
import org.opendaylight.genius.interfacemanager.listeners.IfIndexInterfaceCache;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
}
public void registerListener(final LogicalDatastoreType dsType, final DataBroker db) {
- final DataTreeIdentifier<ServicesInfo> treeId = new DataTreeIdentifier<>(dsType, getWildCardPath());
+ final DataTreeIdentifier<ServicesInfo> treeId = DataTreeIdentifier.create(dsType, getWildCardPath());
listenerRegistration = db.registerDataTreeChangeListener(treeId, FlowBasedServicesConfigListener.this);
}
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Other;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateAddable;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateRendererFactoryResolver;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory.FlowBasedServicesStateAddable;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
*/
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableSet;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.matches.MatchVlanVid;
import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchRegister;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
ServicesInfoKey servicesInfoKey = new ServicesInfoKey(interfaceName, serviceMode);
InstanceIdentifier.InstanceIdentifierBuilder<ServicesInfo> servicesInfoIdentifierBuilder = InstanceIdentifier
.builder(ServiceBindings.class).child(ServicesInfo.class, servicesInfoKey);
- return tx.read(servicesInfoIdentifierBuilder.build()).get().orNull();
+ return tx.read(servicesInfoIdentifierBuilder.build()).get().orElse(null);
}
public static NodeConnectorId getNodeConnectorIdFromInterface(String interfaceName,
public static BoundServicesState getBoundServicesState(ReadTransaction tx,
String interfaceName,
Class<? extends ServiceModeBase> serviceMode)
- throws ReadFailedException {
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<BoundServicesState> id = InstanceIdentifier.builder(BoundServicesStateList.class)
.child(BoundServicesState.class, new BoundServicesStateKey(interfaceName, serviceMode)).build();
- return tx.read(LogicalDatastoreType.OPERATIONAL, id).checkedGet().orNull();
+ return tx.read(LogicalDatastoreType.OPERATIONAL, id).get().orElse(null);
}
public static BoundServicesState getBoundServicesState(TypedReadTransaction<Operational> tx, String interfaceName,
Class<? extends ServiceModeBase> serviceMode) throws ExecutionException, InterruptedException {
InstanceIdentifier<BoundServicesState> id = InstanceIdentifier.builder(BoundServicesStateList.class)
.child(BoundServicesState.class, new BoundServicesStateKey(interfaceName, serviceMode)).build();
- return tx.read(id).get().orNull();
+ return tx.read(id).get().orElse(null);
}
public static void addBoundServicesState(TypedWriteTransaction<Operational> tx, String interfaceName,
package org.opendaylight.genius.interfacemanager.test;
import static java.util.concurrent.TimeUnit.MINUTES;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.BatchingUtils.EntityType.DEFAULT_OPERATIONAL;
import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.DPN_ID_1;
import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.DPN_ID_2;
import static org.opendaylight.genius.mdsalutil.NwConstants.DEFAULT_EGRESS_SERVICE_INDEX;
import static org.opendaylight.genius.mdsalutil.NwConstants.VLAN_INTERFACE_INGRESS_TABLE;
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorCountedEventsWaiter;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
import org.opendaylight.infrautils.testutils.concurrent.TestableQueues;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
SingleTransactionDataBroker db;
@Before
- public void start() throws InterruptedException, TransactionCommitFailedException {
+ public void start() throws InterruptedException, ExecutionException {
db = new SingleTransactionDataBroker(dataBroker);
// Create the bridge and make sure it is ready
}
@After
- public void stop() throws InterruptedException, TransactionCommitFailedException {
+ public void stop() throws InterruptedException, ExecutionException {
setupAndAssertBridgeDeletion();
}
- private void setupAndAssertBridgeDeletion() throws InterruptedException, TransactionCommitFailedException {
+ private void setupAndAssertBridgeDeletion() throws InterruptedException, ExecutionException {
OvsdbSouthboundTestUtil.deleteBridge(dataBroker);
InterfaceManagerTestUtil.waitTillOperationCompletes("bridge deletion",
coordinatorEventsWaiter,2, asyncEventsWaiter);
assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromOperationalDS(DPN_ID_1), null);
}
- private void setupAndAssertBridgeCreation() throws InterruptedException, TransactionCommitFailedException {
+ private void setupAndAssertBridgeCreation() throws InterruptedException, ExecutionException {
OvsdbSouthboundTestUtil.createBridge(dataBroker);
// a) Check bridgeRefEntry in cache and OperDS are same and use the
// right DPN_ID
coordinatorEventsWaiter,3, asyncEventsWaiter);
BridgeRefEntry bridgeRefEntry = IfmUtil
.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker)
- .orNull();
+ .orElse(null);
assertEqualBeans(bridgeRefEntry.getDpid(), DPN_ID_1);
// FIXME AsyncEventsWaiter does not help in this case, need to enhance -- TODO
//assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromCache(DPN_ID_1), bridgeRefEntry);
new InterfaceChildEntryKey(INTERFACE_NAME));
assertEqualBeans(ExpectedInterfaceChildEntry.interfaceChildEntry(INTERFACE_NAME),
dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
- interfaceChildEntryInstanceIdentifier).checkedGet().get());
+ interfaceChildEntryInstanceIdentifier).get());
// Then
// a) check if operational/ietf-interfaces-state is populated for the vlan interface
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface ifaceState =
dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
INTERFACE_NAME, Interface.OperStatus.Up, L2vlan.class, DPN_ID_1.toString(),
.builder(IfIndexesInterfaceMap.class)
.child(IfIndexInterface.class, new IfIndexInterfaceKey(ifaceState.getIfIndex())).build();
Assert.assertEquals(INTERFACE_NAME, dataBroker.newReadOnlyTransaction()
- .read(OPERATIONAL, ifIndexInterfaceInstanceIdentifier).checkedGet().get().getInterfaceName());*/
+ .read(OPERATIONAL, ifIndexInterfaceInstanceIdentifier).get().getInterfaceName());*/
// c) check expected flow entries were created in Interface Ingress
// Table
.build();
flowAssertTestUtils.assertFlowsInAnyOrder(ExpectedFlowEntries.newIngressFlow(),
- dataBroker.newReadOnlyTransaction().read(CONFIGURATION, ingressFlowInstanceId).checkedGet().get());
+ dataBroker.newReadOnlyTransaction().read(CONFIGURATION, ingressFlowInstanceId).get().get());
// d) check if default egress service is bound on the interface
InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = InstanceIdentifier
.child(ServicesInfo.class, new ServicesInfoKey(INTERFACE_NAME, ServiceModeEgress.class))
.child(BoundServices.class, new BoundServicesKey(DEFAULT_EGRESS_SERVICE_INDEX)).build();
assertEqualBeans(ExpectedServicesInfo.newboundService(), dataBroker.newReadOnlyTransaction()
- .read(CONFIGURATION, boundServicesInstanceIdentifier).checkedGet().get());
+ .read(CONFIGURATION, boundServicesInstanceIdentifier).get());
// Test all RPCs related to vlan-interfaces
checkVlanRpcs();
// Then
// a) check if operational/ietf-interfaces-state is updated for vlan interface
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), INTERFACE_NAME, Interface
.OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
waitTillOperationCompletes("disable interface op state", coordinatorEventsWaiter, 2, asyncEventsWaiter);
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
// Verify if operational/ietf-interface-state is marked down
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
INTERFACE_NAME, Interface.OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
coordinatorEventsWaiter, 5, asyncEventsWaiter);
// Verify if interfaces are deleted from oper/ietf-interfaces-state
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
IfmUtil.buildStateInterfaceId(PARENT_INTERFACE)).get());
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get());
// 3. Re-create the OF port to proceeed with vlan-member tests
// TODO Later use nicer abstraction for DB access here.. see
// ElanServiceTest
- Assert.assertEquals(Optional.absent(),
+ Assert.assertEquals(Optional.empty(),
dataBroker.newReadOnlyTransaction().read(CONFIGURATION, interfaceChildEntryInstanceIdentifier).get());
// Then
// a) check if operational/ietf-interfaces-state is deleted for the vlan
// interface
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(OPERATIONAL, IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get());
// b) check if lport-tag to interface mapping is deleted
- /*Assert.assertEquals(Optional.absent(),
+ /*Assert.assertEquals(Optional.empty(),
dataBroker.newReadOnlyTransaction().read(OPERATIONAL, ifIndexInterfaceInstanceIdentifier).get());*/
}
.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
// Verify if DPN-ID is updated in corresponding DS and cache
BridgeRefEntry bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker)
- .orNull();
+ .orElse(null);
assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromCache(DPN_ID_2), bridgeRefEntry);
// 1. Given
// TODO Later use nicer abstraction for DB access here.. see
// ElanServiceTest
assertEqualBeans(InterfaceMeta.newBridgeInterface(),
- dataBroker.newReadOnlyTransaction().read(CONFIGURATION, bridgeInterfaceEntryIid).checkedGet().get());
+ dataBroker.newReadOnlyTransaction().read(CONFIGURATION, bridgeInterfaceEntryIid).get());
// Then
// a) check if termination end point is created in
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface ifaceState =
dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
TUNNEL_INTERFACE_NAME, Interface.OperStatus.Up, Tunnel.class, DPN_ID_2.toString(),
ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
// Verify if operational/ietf-interface-state is still up
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
TUNNEL_INTERFACE_NAME, Interface.OperStatus.Up, Tunnel.class, DPN_ID_2.toString(),
waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
// Verify if operational/ietf-interface-state is marked down
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
TUNNEL_INTERFACE_NAME, Interface.OperStatus.Down, Tunnel.class, DPN_ID_2.toString(),
InterfaceManagerTestUtil.removeNode(dataBroker);
waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
// Verify if operational/ietf-interface-state is marked unknown
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
TUNNEL_INTERFACE_NAME, Interface.OperStatus.Unknown, Tunnel.class, DPN_ID_2.toString(),
waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
// Verify if operational-states are deleted
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get());
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get());
// Delete test
// Then
// a) check if tunnel is deleted from bridge-interface-info
- Assert.assertEquals(Optional.absent(),
+ Assert.assertEquals(Optional.empty(),
dataBroker.newReadOnlyTransaction().read(CONFIGURATION, bridgeInterfaceEntryIid).get());
// b) check if termination end point is deleted in
// config/network-topology
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION, tpIid).get());
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION, tpIid).get());
waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
}
.child(Table.class, new TableKey(NwConstants.LPORT_DISPATCHER_TABLE)).child(Flow.class,
lportDispatcherFlowKey).build();
flowAssertTestUtils.assertFlowsInAnyOrder(ExpectedFlowEntries.newLportDispatcherFlow(),
- dataBroker.newReadOnlyTransaction().read(CONFIGURATION, lportDispatcherFlowId).checkedGet().get());
+ dataBroker.newReadOnlyTransaction().read(CONFIGURATION, lportDispatcherFlowId).get().get());
// check whether service-binding state cache is populated
assertEqualBeans(ExpectedBoundServiceState.newBoundServiceState(), FlowBasedServicesUtils
waitTillOperationCompletes("test unbind ingress service api",
coordinatorEventsWaiter, 2, asyncEventsWaiter);
- Assert.assertEquals(Optional.absent(),
+ Assert.assertEquals(Optional.empty(),
dataBroker.newReadOnlyTransaction().read(CONFIGURATION, lportDispatcherFlowId).get());
// check service-state cache is cleaned up
// FIXME the extend file getting generated had some import issues, will revist later
//assertEqualBeans(null,
- // dataBroker.newReadOnlyTransaction().read(CONFIGURATION, egressDispatcherFlowId).checkedGet().get());
+ // dataBroker.newReadOnlyTransaction().read(CONFIGURATION, egressDispatcherFlowId).get());
Assert.assertNotNull(dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
- egressDispatcherFlowId).checkedGet().get());
+ egressDispatcherFlowId).get());
//10. test check whether service is bound on egress
Assert.assertTrue(interfaceManager.isServiceBoundOnInterfaceForEgress(NwConstants.EGRESS_ACL_SERVICE_INDEX,
interfaceManager.unbindService(INTERFACE_NAME, ServiceModeEgress.class, serviceInfo);
waitTillOperationCompletes("test unbind egress service api",
coordinatorEventsWaiter, 2, asyncEventsWaiter);
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
egressDispatcherFlowId).get());
// 12. Test fetching child interfaces of an interface
//assertEqualBeans(ExpectedInterfaceConfig.newVlanInterfaceConfig(INTERFACE_NAME_1, null),
// dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil.buildId(
- // INTERFACE_NAME_1)).checkedGet().get());
+ // INTERFACE_NAME_1)).get());
// 17. Update Parent Refs for VLAN interface
// FIXME Make IInterfaceManager truly async
assertEqualBeans(ExpectedInterfaceConfig.newVlanInterfaceConfig(INTERFACE_NAME_1, PARENT_INTERFACE_1),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
- .buildId(INTERFACE_NAME_1)).checkedGet().get());
+ .buildId(INTERFACE_NAME_1)).get());
// 18. Test creation of external l2vlan interfaces
// FIXME Make IInterfaceManager truly async
// to do proper assertion
//Assert.assertNotNull(dataBroker
// .newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
- // .buildId(INTERFACE_NAME_2)).checkedGet().get().augmentation(IfExternal.class));
+ // .buildId(INTERFACE_NAME_2)).get().augmentation(IfExternal.class));
// 19. update parent-refs
//interfaceManager.updateInterfaceParentRef(INTERFACE_NAME_2, PARENT_INTERFACE_2, true);
coordinatorEventsWaiter, 4, asyncEventsWaiter);
Assert.assertEquals(PARENT_INTERFACE_2, dataBroker
.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
- .buildId(INTERFACE_NAME_2)).checkedGet().get().augmentation(ParentRefs.class).getParentInterface());
+ .buildId(INTERFACE_NAME_2)).get().get().augmentation(ParentRefs.class).getParentInterface());
// 20. get list of vlan interfaces
// FIXME need to wait for https://git.opendaylight.org/gerrit/#/c/54811/ this to land
new InterfaceChildEntryKey(TRUNK_INTERFACE_NAME));
assertEqualBeans(ExpectedInterfaceChildEntry.interfaceChildEntry(TRUNK_INTERFACE_NAME),
dataBroker.newReadOnlyTransaction().read(CONFIGURATION, interfaceChildEntryInstanceIdentifier)
- .checkedGet().get());
+ .get());
// Then
// a) check if operational/ietf-interfaces-state is populated for the vlan interface
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
.interfaces.state.Interface ifaceState =
dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get().get();
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), TRUNK_INTERFACE_NAME,
Interface.OperStatus.Up, L2vlan.class, DPN_ID_1.toString(),
ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
IfIndexesInterfaceMap.class).child(
IfIndexInterface.class, new IfIndexInterfaceKey(ifaceState.getIfIndex())).build();
Assert.assertEquals(TRUNK_INTERFACE_NAME, dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- ifIndexInterfaceInstanceIdentifier).checkedGet().get().getInterfaceName());*/
+ ifIndexInterfaceInstanceIdentifier).get().getInterfaceName());*/
//Update test
// i) vlan member interface admin-state updated
//Then
// a) check if operational/ietf-interfaces-state is updated for vlan interface
ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
- IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).checkedGet().get();
+ IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get().get();
assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), TRUNK_INTERFACE_NAME,
Interface.OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
coordinatorEventsWaiter, 7, asyncEventsWaiter);
// 1. Then
// a)
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(CONFIGURATION, interfaceChildEntryInstanceIdentifier).get());
// b) check if operational/ietf-interfaces-state is deleted for the vlan interface
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get());
// FIXME can assert this only once ResourceBatchingManager becomes testable
// c) check if lport-tag to interface mapping is deleted
- /*Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
+ /*Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
ifIndexInterfaceInstanceIdentifier).get());*/
}
entryBuilder.setInterfaceType(interfaceType);
}
tx.put(LogicalDatastoreType.OPERATIONAL, intfid, entryBuilder.build(), true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
}
import static org.mockito.Mockito.mock;
-import java.net.UnknownHostException;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import java.util.concurrent.Executors;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.datastoreutils.testutils.AbstractTestableListener;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.binding.dom.adapter.BindingDOMEntityOwnershipServiceAdapter;
import org.opendaylight.mdsal.eos.dom.simple.SimpleDOMEntityOwnershipService;
public class InterfaceManagerTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() throws UnknownHostException {
+ protected void configureBindings() throws Exception {
// Bindings for services from this project
// Bindings for external services to "real" implementations
// Bindings to test infra (fakes & mocks)
- DataBrokerTestModule dataBrokerTestModule = new DataBrokerTestModule(false);
- DataBroker dataBroker = dataBrokerTestModule.getDataBroker();
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
bind(DataBroker.class).toInstance(dataBroker);
bind(DataTreeEventCallbackRegistrar.class).toInstance(mock(DataTreeEventCallbackRegistrar.class));
bind(ManagedNewTransactionRunner.class).toInstance(mock(ManagedNewTransactionRunner.class));
bind(InterfaceManagerService.class).to(InterfaceManagerServiceImpl.class);
bind(ServiceRecoveryRegistry.class).toInstance(mock(ServiceRecoveryRegistry.class));
EntityOwnershipService entityOwnershipService = new BindingDOMEntityOwnershipServiceAdapter(
- new SimpleDOMEntityOwnershipService(), dataBrokerTestModule.getBindingToNormalizedNodeCodec());
+ new SimpleDOMEntityOwnershipService(),
+ test.getDataBrokerTestCustomizer().getBindingToNormalized());
bind(EntityOwnershipService.class).toInstance(entityOwnershipService);
bind(EntityOwnershipUtils.class);
bind(AlivenessMonitorService.class).toInstance(mock(AlivenessMonitorService.class));
*/
package org.opendaylight.genius.interfacemanager.test;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.concurrent.ExecutionException;
+
import org.awaitility.core.ConditionTimeoutException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorCountedEventsWaiter;
import org.opendaylight.genius.interfacemanager.IfmConstants;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
return tpIid;
}
- static void deleteInterfaceConfig(DataBroker dataBroker, String ifaceName) throws TransactionCommitFailedException {
+ static void deleteInterfaceConfig(DataBroker dataBroker, String ifaceName)
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<Interface> vlanInterfaceEnabledInterfaceInstanceIdentifier = IfmUtil.buildId(
ifaceName);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.delete(CONFIGURATION, vlanInterfaceEnabledInterfaceInstanceIdentifier);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void updateInterfaceAdminState(DataBroker dataBroker, String ifaceName, boolean isEnabled)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<Interface> vlanInterfaceEnabledInterfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
InterfaceBuilder builder = new InterfaceBuilder().withKey(new InterfaceKey(ifaceName)).setName(ifaceName)
.setEnabled(isEnabled);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(CONFIGURATION, vlanInterfaceEnabledInterfaceInstanceIdentifier, builder.build());
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void updateTunnelMonitoringAttributes(DataBroker dataBroker, String ifaceName)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<Interface> tunnelInstanceIdentifier = IfmUtil.buildId(ifaceName);
InterfaceBuilder builder = new InterfaceBuilder().withKey(new InterfaceKey(ifaceName)).setName(ifaceName);
IfTunnel tunnel = new IfTunnelBuilder().setMonitorProtocol(TunnelMonitoringTypeBfd.class)
builder.addAugmentation(IfTunnel.class, tunnel);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(CONFIGURATION, tunnelInstanceIdentifier, builder.build());
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void putInterfaceConfig(DataBroker dataBroker, String ifaceName, ParentRefs parentRefs,
Class<? extends InterfaceType> ifType)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
Interface interfaceInfo;
if (!Tunnel.class.equals(ifType)) {
interfaceInfo = InterfaceManagerTestUtil.buildInterface(ifaceName, ifaceName, true, ifType,
InstanceIdentifier<Interface> interfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo, true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void putVlanInterfaceConfig(DataBroker dataBroker, String ifaceName, String parentRefs,
- IfL2vlan.L2vlanMode l2vlanMode) throws TransactionCommitFailedException {
+ IfL2vlan.L2vlanMode l2vlanMode)
+ throws ExecutionException, InterruptedException {
Interface interfaceInfo = InterfaceManagerTestUtil.buildInterface(ifaceName, ifaceName,
true, L2vlan.class, parentRefs, l2vlanMode);
InstanceIdentifier<Interface> interfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(CONFIGURATION, interfaceInstanceIdentifier, interfaceInfo, true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void createFlowCapableNodeConnector(DataBroker dataBroker, String interfaceName,
Class<? extends InterfaceType> ifType)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, true);
tx.put(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector, true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void updateFlowCapableNodeConnectorState(DataBroker dataBroker, String interfaceName,
- Class<? extends InterfaceType> ifType, boolean isLive) throws TransactionCommitFailedException {
+ Class<? extends InterfaceType> ifType, boolean isLive) throws ExecutionException, InterruptedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, isLive);
tx.merge(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo), nodeConnector, true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void removeFlowCapableNodeConnectorState(DataBroker dataBroker, Class<? extends InterfaceType> ifType)
- throws TransactionCommitFailedException {
+ throws ExecutionException, InterruptedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
tx.delete(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo));
- tx.submit().checkedGet();
+ tx.commit().get();
}
- static void removeNode(DataBroker dataBroker) throws TransactionCommitFailedException {
+ static void removeNode(DataBroker dataBroker) throws ExecutionException, InterruptedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<Node> nodeInstanceIdentifier = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(IfmUtil.buildDpnNodeId(DPN_ID_2))).build();
tx.delete(OPERATIONAL,nodeInstanceIdentifier);
- tx.submit().checkedGet();
+ tx.commit().get();
}
static void waitTillOperationCompletes(JobCoordinatorCountedEventsWaiter coordinatorEventsWaiter,
package org.opendaylight.genius.interfacemanager.test;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import com.google.common.collect.ImmutableBiMap;
import java.net.Inet4Address;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
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.Ipv6Address;
return new NodeId(uri);
}
- public static void createBridge(DataBroker dataBroker) throws TransactionCommitFailedException {
+ public static void createBridge(DataBroker dataBroker) throws ExecutionException, InterruptedException {
final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
- public static void updateBridge(DataBroker dataBroker, String datapathId) throws TransactionCommitFailedException {
+ public static void updateBridge(DataBroker dataBroker, String datapathId)
+ throws ExecutionException, InterruptedException {
final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
- public static void deleteBridge(DataBroker dataBroker) throws TransactionCommitFailedException {
+ public static void deleteBridge(DataBroker dataBroker) throws ExecutionException, InterruptedException {
final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
LOG.debug("Built with the intent to delete bridge data {}", bridgeIid.toString());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.delete(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid);
- tx.submit().checkedGet();
+ tx.commit().get();
}
public static InstanceIdentifier<Node> createInstanceIdentifier(NodeId nodeId) {
public static void createTerminationPoint(DataBroker dataBroker, String interfaceName,
Class<? extends InterfaceTypeBase> type, String externalId) throws
- TransactionCommitFailedException {
+ ExecutionException, InterruptedException {
final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
final InstanceIdentifier<Node> bridgeIid =
createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(OPERATIONAL, tpId, tpBuilder.build(), true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
public static void updateTerminationPoint(DataBroker dataBroker, String interfaceName,
Class<? extends InterfaceTypeBase> type) throws
- TransactionCommitFailedException {
+ ExecutionException, InterruptedException {
final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
final InstanceIdentifier<Node> bridgeIid =
createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(OPERATIONAL, tpId, tpBuilder.build(), true);
- tx.submit().checkedGet();
+ tx.commit().get();
}
public static NodeKey createNodeKey(String ip, Integer port) {
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import java.util.List;
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.genius.itm.api;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
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.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
<groupId>org.opendaylight.serviceutils</groupId>
<artifactId>rpc-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.serviceutils</groupId>
+ <artifactId>tools-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.genius</groupId>
<artifactId>mdsalutil-api</artifactId>
<artifactId>blueprint-maven-plugin-annotation</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc7223</artifactId>
import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Inject;
import javax.inject.Singleton;
-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.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.caches.CacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
if (dpnTepInterfaceInfo == null) {
try {
- com.google.common.base.Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
+ Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
if (dpnsTeps.isPresent()) {
DpnsTeps teps = dpnsTeps.get();
teps.nonnullRemoteDpns().forEach(remoteDpns -> {
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.BridgeTunnelInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryKey;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.OvsBridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntryKey;
*/
package org.opendaylight.genius.itm.cache;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-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.ReadFailedException;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.commons.lang3.StringUtils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
import org.opendaylight.genius.itm.cache.UnprocessedTunnelsStateCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
public TransportZone getTransportZone(String transportZoneName) {
InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(transportZoneName)).build();
- return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker).orNull();
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker).orElse(null);
}
/**
*/
public TransportZones getAllTransportZones() {
InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
- return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker).orNull();
+ return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker).orElse(null);
}
tunType = ItmUtils.TUNNEL_TYPE_MAP.get(tunnelType);
- InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
+ InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class);
+
Optional<TransportZones> tzones = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
TransportZone tzone = new TransportZoneBuilder().withKey(new TransportZoneKey(transportZoneName))
}
tzList.add(tzone);
TransportZones transportZones = new TransportZonesBuilder().setTransportZone(tzList).build();
+
+ /*InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class).
+ child(TransportZone.class, new TransportZoneKey(transportZoneName)).build();
+
+ TransportZone transportZone = new TransportZoneBuilder().setZoneName(transportZoneName)
+ .setTunnelType(tunType)
+ .withKey(new TransportZoneKey(transportZoneName)).build();*/
+
txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.put(LogicalDatastoreType.CONFIGURATION,
- path, transportZones, WriteTransaction.CREATE_MISSING_PARENTS)).get();
+ path, transportZones)).get();
}
public void configureTunnelMonitorParams(boolean monitorEnabled, String monitorProtocol) {
- InstanceIdentifier<TunnelMonitorParams> path = InstanceIdentifier.builder(TunnelMonitorParams.class).build();
+ InstanceIdentifier<TunnelMonitorParams> path = InstanceIdentifier.create(TunnelMonitorParams.class);
Optional<TunnelMonitorParams> storedTunnelMonitor = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
path, dataBroker);
Class<? extends TunnelMonitoringTypeBase> monitorType ;
TunnelMonitorParams tunnelMonitor = new TunnelMonitorParamsBuilder().setEnabled(monitorEnabled)
.setMonitorProtocol(monitorType).build();
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.merge(path, tunnelMonitor, true)), ItmUtils.DEFAULT_WRITE_CALLBACK,
+ tx -> tx.merge(path, tunnelMonitor)), ItmUtils.DEFAULT_WRITE_CALLBACK,
MoreExecutors.directExecutor());
}
}
*/
package org.opendaylight.genius.itm.confighelpers;
-import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
ExternalTunnel tnl = ItmUtils.buildExternalTunnel(teps.getDPNID().toString(),
extIp.stringValue(), tunType, trunkInterfaceName);
tx.merge(path, tnl, true);
+ ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
+
}
}
}
*/
package org.opendaylight.genius.itm.confighelpers;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
package org.opendaylight.genius.itm.confighelpers;
import static java.util.Collections.singletonList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
-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.ReadFailedException;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
private static void updateDpnTepInfoToConfig(TypedWriteTransaction<Configuration> tx, DPNTEPsInfo dpn,
DirectTunnelUtils directTunnelUtils) throws ExecutionException, InterruptedException, OperationFailedException {
LOG.debug("Updating CONFIGURATION datastore with DPN {} ", dpn);
- InstanceIdentifier<DpnEndpoints> dep = InstanceIdentifier.builder(DpnEndpoints.class).build() ;
+ InstanceIdentifier<DpnEndpoints> dep = InstanceIdentifier.create(DpnEndpoints.class) ;
List<DPNTEPsInfo> dpnList = new ArrayList<>() ;
dpnList.add(new DPNTEPsInfoBuilder(dpn)
.setDstId(directTunnelUtils.allocateId(ITMConstants.ITM_IDPOOL_NAME, dpn.getDPNID().toString())).build());
private static void updateDpnTepInterfaceInfoToConfig(DpnTepsState dpnTeps) {
LOG.debug("Updating CONFIGURATION datastore with DPN-Teps {} ", dpnTeps);
- InstanceIdentifier<DpnTepsState> dpnTepsII = InstanceIdentifier.builder(DpnTepsState.class).build() ;
- ITMBatchingUtils.update(dpnTepsII, dpnTeps, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
+ InstanceIdentifier<DpnTepsState> dpnTepsII = InstanceIdentifier.create(DpnTepsState.class);
+ ITMBatchingUtils.updateContainer(dpnTepsII, dpnTeps, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
}
private void addTunnelConfiguration(Interface iface, String ofTunnelPortName)
import static java.util.Collections.singletonList;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
-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.ReadFailedException;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
List<ListenableFuture<Void>> futures = new ArrayList<>();
List<String> tunnelList = ItmUtils.getInternalTunnelInterfaces(dataBroker);
LOG.debug("ItmMonitorIntervalWorker toggleTunnelMonitoring: List of tunnel interfaces: {}" , tunnelList);
- InstanceIdentifier<TunnelMonitorInterval> iid = InstanceIdentifier.builder(TunnelMonitorInterval.class).build();
+ InstanceIdentifier<TunnelMonitorInterval> iid = InstanceIdentifier.create(TunnelMonitorInterval.class);
TunnelMonitorInterval monitorInterval = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL,
- tx -> tx.merge(iid, monitorInterval, true)));
+ tx -> tx.merge(iid, monitorInterval)));
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> tunnelList.forEach(tunnel -> toggle(tunnel, tx))));
return futures;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
private List<ListenableFuture<Void>> toggleTunnelMonitoring() {
List<String> tunnelList = ItmUtils.getInternalTunnelInterfaces(dataBroker);
LOG.debug("toggleTunnelMonitoring: TunnelList size {}", tunnelList.size());
- InstanceIdentifier<TunnelMonitorParams> iid = InstanceIdentifier.builder(TunnelMonitorParams.class).build();
+ InstanceIdentifier<TunnelMonitorParams> iid = InstanceIdentifier.create(TunnelMonitorParams.class);
TunnelMonitorParams monitorParams = new TunnelMonitorParamsBuilder()
.setEnabled(enabled).setMonitorProtocol(monitorProtocol).build();
LOG.debug("toggleTunnelMonitoring: Updating Operational DS");
List<ListenableFuture<Void>> futures = new ArrayList<>();
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL,
- tx -> tx.merge(iid, monitorParams, true)));
+ tx -> tx.merge(iid, monitorParams)));
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> tunnelList.forEach(tunnel -> toggle(tunnel, tx))));
return futures;
*/
package org.opendaylight.genius.itm.confighelpers;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
private void toggleForDirectEnabled(DpnsTeps dpnTeps, TypedWriteTransaction<Datastore.Configuration> tx)
- throws ReadFailedException, InterruptedException, ExecutionException {
+ throws ReadFailedException {
List<RemoteDpns> remoteDpnTepNewList = new ArrayList<>();
RemoteDpns remoteDpnNew = null;
Optional<OvsBridgeRefEntry> ovsBridgeRefEntry = ovsBridgeRefEntryCache.get(dpnTeps.getSourceDpnId());
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.DcGatewayIpList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVteps;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
package org.opendaylight.genius.itm.confighelpers;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
InstanceIdentifier.builder(InterfaceChildInfo.class)
.child(InterfaceParentEntry.class, interfaceParentEntryKey);
InstanceIdentifier<InterfaceParentEntry> intfId = intfIdBuilder.build();
- return tx.read(intfId).get().orNull();
+ return tx.read(intfId).get().orElse(null);
}
}
}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.NotHostedTransportZones;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.NotHostedTransportZones;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.batching.ActionableResource;
import org.opendaylight.genius.utils.batching.ActionableResources;
import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
getQueue(entityType).add(ActionableResources.update(path, data));
}
+ public static <T extends DataObject> void updateContainer(InstanceIdentifier<T> path, T data,
+ EntityType entityType) {
+ LOG.debug("Adding to the Queue to batch the update DS Operation - Id {} data {}", path, data);
+ getQueue(entityType).add(ActionableResources.updateContainer(path, data));
+ }
+
+
public static <T extends DataObject> void write(InstanceIdentifier<T> path, T data, EntityType entityType) {
LOG.debug("Adding to the Queue to batch the write DS Operation - Id {} data {}", path, data);
getQueue(entityType).add(ActionableResources.create(path, data));
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
*/
package org.opendaylight.genius.itm.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.genius.itm.api.IITMProvider;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cache.TunnelStateCache;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
private final InterfaceStateListener ifStateListener;
private final EntityOwnershipService entityOwnershipService;
private final ItmDiagStatusProvider itmStatusProvider;
- private RpcProviderRegistry rpcProviderRegistry;
+ private RpcProviderService rpcProviderService;
private final ItmTunnelEventListener itmStateListener;
private final OvsdbNodeListener ovsdbChangeListener;
static short flag = 0;
import static java.util.Collections.emptyList;
-import com.google.common.base.Optional;
import com.google.common.collect.BiMap;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
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.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
public final class ItmUtils {
private static final Logger LOG = LoggerFactory.getLogger(ItmUtils.class);
- private static final String ITM_LLDP_FLOW_ENTRY = "ITM Flow Entry ::" + ITMConstants.LLDP_SERVICE_ID;
+ private static final String ITM_LLDP_FLOW_ENTRY = "ITM Flow Entry ::" + ITMConstants.LLDP_SERVICE_ID;
private static final String TUNNEL = "tun";
private static final IpPrefix DUMMY_IP_PREFIX = IpPrefixBuilder.getDefaultInstance(ITMConstants.DUMMY_PREFIX);
private static final long DEFAULT_MONITORING_INTERVAL = 100L;
.put(ITMConstants.TUNNEL_TYPE_VXLAN, TunnelTypeVxlan.class)
.build();
- private static final BiMap<String,Class<? extends TunnelTypeBase>> STRING_CLASS_IMMUTABLE_BI_MAP =
+ private static final BiMap<String, Class<? extends TunnelTypeBase>> STRING_CLASS_IMMUTABLE_BI_MAP =
ImmutableBiMap.copyOf(TUNNEL_TYPE_MAP);
private static final Uint64 COOKIE_ITM_LLD = Uint64.fromLongBits(
- ITMConstants.COOKIE_ITM.longValue() + ITMConstants.LLDP_SERVICE_ID).intern();
+ ITMConstants.COOKIE_ITM.longValue() + ITMConstants.LLDP_SERVICE_ID).intern();
private ItmUtils() {
}
*
* @deprecated Use
* {@link SingleTransactionDataBroker#syncReadOptional(DataBroker, LogicalDatastoreType, InstanceIdentifier)}
- * instead of this.
*/
@Deprecated
@SuppressWarnings("checkstyle:IllegalCatch")
public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, DataBroker broker) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
- } catch (Exception e) {
- throw new RuntimeException(e);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Read failed ", e);
+ return Optional.empty();
}
}
*
* @deprecated Use {@link ManagedNewTransactionRunner} instead of this.
*/
- @Deprecated
+ /*@Deprecated
public static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, DataBroker broker,
FutureCallback<Void> callback) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.put(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
+ Futures.addCallback(tx.commit(),callback, MoreExecutors.directExecutor());
+ }*/
/**
* Asynchronous non-blocking update to data store.
*
* @deprecated Use {@link ManagedNewTransactionRunner} instead of this.
*/
- @Deprecated
+ /*@Deprecated
public static <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data, DataBroker broker,
FutureCallback<Void> callback) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.merge(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
+ Futures.addCallback(tx.commit(), callback, MoreExecutors.directExecutor());
+ }*/
/**
* Asynchronous non-blocking single delete to data store.
*
* @deprecated Use {@link ManagedNewTransactionRunner} instead of this.
*/
- @Deprecated
+ /*@Deprecated
public static <T extends DataObject> void asyncDelete(LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, DataBroker broker,
FutureCallback<Void> callback) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.delete(datastoreType, path);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
+ Futures.addCallback(tx.commit(), callback, MoreExecutors.directExecutor());
+ }*/
/**
* Asynchronous non-blocking bulk delete to data store.
*
* @deprecated Use {@link ManagedNewTransactionRunner} instead of this.
*/
- @Deprecated
+ /*@Deprecated
public static <T extends DataObject> void asyncBulkRemove(final DataBroker broker,
final LogicalDatastoreType datastoreType,
List<InstanceIdentifier<T>> pathList,
for (InstanceIdentifier<T> path : pathList) {
tx.delete(datastoreType, path);
}
- Futures.addCallback(tx.submit(), callback ,MoreExecutors.directExecutor());
+ Futures.addCallback(tx.commit(), callback ,MoreExecutors.directExecutor());
}
- }
+ }*/
//ITM cleanup:portname and vlanId are removed, causes change in generated
//interface name: This has upgrade impact
tunnelTypeStr = ITMConstants.TUNNEL_TYPE_VXLAN;
}
String trunkInterfaceName = trunkInterfaceName(parentInterfaceName, localHostName, remoteHostName,
- tunnelTypeStr);
+ tunnelTypeStr);
LOG.trace("trunk interface name is {}", trunkInterfaceName);
return TUNNEL + getUniqueIdString(trunkInterfaceName);
}
}
if (LOG.isTraceEnabled()) {
LOG.trace("Releasing Id for trunkInterface - {}", trunkInterfaceName(parentInterfaceName, localHostName,
- remoteHostName, tunnelTypeStr));
+ remoteHostName, tunnelTypeStr));
}
}
private static String trunkInterfaceName(String parentInterfaceName, String localHostName, String remoteHostName,
- String tunnelType) {
+ String tunnelType) {
return parentInterfaceName + ":" + localHostName + ":" + remoteHostName + ":" + tunnelType;
}
public static String getLogicalTunnelGroupName(Uint64 srcDpnId, Uint64 destDpnId) {
String groupName = srcDpnId + ":" + destDpnId + ":" + ITMConstants.TUNNEL_TYPE_LOGICAL_GROUP_VXLAN;
LOG.trace("logical tunnel group name is {}", groupName);
- return TUNNEL + getUniqueIdString(groupName);
+ return TUNNEL + getUniqueIdString(groupName);
}
public static InetAddress getInetAddressFromIpAddress(IpAddress ip) {
public static TunnelEndPoints createTunnelEndPoints(Uint64 dpnId, IpAddress ipAddress, String portName,
boolean isOfTunnel, int vlanId, List<TzMembership> zones,
- Class<? extends TunnelTypeBase> tunnelType,
+ Class<? extends TunnelTypeBase> tunnelType,
String tos) {
// when Interface Mgr provides support to take in Dpn Id
return new TunnelEndPointsBuilder().withKey(new TunnelEndPointsKey(ipAddress, tunnelType))
public static TunnelEndPoints createDummyTunnelEndPoints(Uint64 dpnID, IpAddress ipAddress, boolean ofTunnel,
String tos, List<TzMembership> zones,
- Class<? extends TunnelTypeBase> tunnelType,
+ Class<? extends TunnelTypeBase> tunnelType,
String port, int vlanID) {
- return ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port, ofTunnel,vlanID, zones,
+ return ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port, ofTunnel, vlanID, zones,
tunnelType, tos);
}
List<TunnelOptions> tunOptions) {
return buildTunnelInterface(dpn, ifName, desc, enabled, tunType, localIp, remoteIp, internal,
- monitorEnabled, monitorProtocol, monitorInterval, useOfTunnel, null,
+ monitorEnabled, monitorProtocol, monitorInterval, useOfTunnel, null,
tunOptions);
}
builder.addAugmentation(ParentRefs.class, parentRefs);
Long monitoringInterval = null;
LOG.debug("buildTunnelInterface: monitorProtocol = {} and monitorInterval = {}",
- monitorProtocol.getName(),monitorInterval);
+ monitorProtocol.getName(), monitorInterval);
if (monitorInterval != null) {
monitoringInterval = monitorInterval.longValue();
*
* @deprecated Use
* {@link SingleTransactionDataBroker#syncWrite(DataBroker, LogicalDatastoreType, InstanceIdentifier, DataObject)}
- * instead of this.
*/
@Deprecated
public static <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType,
WriteTransaction tx = broker.newWriteOnlyTransaction();
tx.put(datastoreType, path, data, true);
try {
- tx.submit().get();
+ tx.commit().get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("ITMUtils:SyncWrite , Error writing to datastore (path, data) : ({}, {})", path, data);
throw new RuntimeException(e.getMessage(), e);
List<String> tunnelList = new ArrayList<>();
if (internalInterfaces.isEmpty()) {
tunnelList = getAllInternalTunnlInterfacesFromDS(dataBroker);
- }
- else {
+ } else {
LOG.debug("Internal Interfaces from Cache size: {}", internalInterfaces.size());
tunnelList.addAll(internalInterfaces);
}
if (internalInterfaces.isEmpty()) {
LOG.trace("ItmUtils.getInternalTunnelsFromCache invoking getAllInternalTunnlInterfacesFromDS");
tunnelList = getAllInternalTunnels(dataBroker);
- }
- else {
+ } else {
LOG.debug("No. of Internal Tunnel Interfaces in cache: {} ", internalInterfaces.size());
tunnelList.addAll(internalInterfaces);
}
}
@SuppressFBWarnings("RV_CHECK_FOR_POSITIVE_INDEXOF")
- public static ExternalTunnelKey getExternalTunnelKey(String dst , String src,
+ public static ExternalTunnelKey getExternalTunnelKey(String dst, String src,
Class<? extends TunnelTypeBase> tunType) {
final int srcIndex = src.indexOf("physicalswitch");
if (srcIndex > 0) {
private static ExternalTunnel getExternalTunnelFromDS(String interfaceName, DataBroker broker) {
List<ExternalTunnel> externalTunnels = getAllExternalTunnels(broker);
- if (externalTunnels != null) {
+ if (externalTunnels != null) {
for (ExternalTunnel tunnel : externalTunnels) {
String tunnelInterfaceName = tunnel.getTunnelInterfaceName();
if (tunnelInterfaceName != null && tunnelInterfaceName.equalsIgnoreCase(interfaceName)) {
public static String convertTunnelTypetoString(Class<? extends TunnelTypeBase> tunType) {
String tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
if (tunType.equals(TunnelTypeVxlan.class)) {
- tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN ;
+ tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
} else if (tunType.equals(TunnelTypeGre.class)) {
- tunnelType = ITMConstants.TUNNEL_TYPE_GRE ;
+ tunnelType = ITMConstants.TUNNEL_TYPE_GRE;
} else if (tunType.equals(TunnelTypeMplsOverGre.class)) {
tunnelType = ITMConstants.TUNNEL_TYPE_MPLSoGRE;
} else if (tunType.equals(TunnelTypeLogicalGroup.class)) {
zones.add(new TzMembershipBuilder().setZoneName(zoneName).build());
}
- public static List<TzMembership> createTransportZoneMembership(String zoneName) {
+ public static List<TzMembership> createTransportZoneMembership(String zoneName) {
List<TzMembership> zones = new ArrayList<>();
zones.add(new TzMembershipBuilder().setZoneName(zoneName).build());
return zones;
/**
* Gets the transport zone in TepsNotHosted list in the Operational Datastore, based on transport zone name.
*
- * @param unknownTz transport zone name
- *
+ * @param unknownTz transport zone name
* @param dataBroker data broker handle to perform read operations on Oper datastore
- *
* @return the TepsInNotHostedTransportZone object in the TepsNotHosted list in Oper DS
*/
public static TepsInNotHostedTransportZone getUnknownTransportZoneFromITMOperDS(
/**
* Gets the bridge datapath ID from Network topology Node's OvsdbBridgeAugmentation, in the Operational DS.
*
- * @param node Network Topology Node
- *
- * @param bridge bridge name
- *
+ * @param node Network Topology Node
+ * @param bridge bridge name
* @param dataBroker data broker handle to perform operations on datastore
- *
* @return the datapath ID of bridge in string form
*/
public static String getBridgeDpid(Node node, String bridge, DataBroker dataBroker) {
InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(IfmConstants.OVSDB_TOPOLOGY_ID))
- .child(Node.class,new NodeKey(brNodeId));
+ .child(Node.class, new NodeKey(brNodeId));
Optional<Node> opBridgeNode = ItmUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeIid, dataBroker);
* based on Bridge Augmentation.
*
* @param bridgeAugmentation bridge augmentation of OVSDB node
- *
- * @param dataBroker data broker handle to perform operations on datastore
- *
+ * @param dataBroker data broker handle to perform operations on datastore
* @return the Network Topology Node i.e. OVSDB node which is managing the specified bridge
*/
public static Node getOvsdbNode(OvsdbBridgeAugmentation bridgeAugmentation,
DataBroker dataBroker) {
Node ovsdbNode = null;
- Optional<Node> opOvsdbNode = Optional.absent();
+ Optional<Node> opOvsdbNode = Optional.empty();
if (bridgeAugmentation != null) {
InstanceIdentifier<Node> ovsdbNodeIid =
(InstanceIdentifier<Node>) bridgeAugmentation.getManagedBy().getValue();
* Network topology Node's OvsdbBridgeAugmentation in the Operational DS.
*
* @param augmentedNode Ovsdb Augmented Network Topology Node
- *
* @return the datapath ID of bridge in string form
*/
public static String getStrDatapathId(OvsdbBridgeAugmentation augmentedNode) {
/**
* Deletes the transport zone from Configuration datastore.
*
- * @param tzName transport zone name
+ * @param tzName transport zone name
* @param dataBroker data broker handle to perform operations on datastore
*/
public static void deleteTransportZoneFromConfigDS(String tzName, DataBroker dataBroker) {
* corresponding to tunnelType obtained in String format.
*
* @param tunnelType type of tunnel in string form
- *
* @return tunnel-type in TunnelTypeBase object
*/
public static Class<? extends TunnelTypeBase> getTunnelType(String tunnelType) {
public static List<TzMembership> removeTransportZoneMembership(TunnelEndPoints endPts, List<TzMembership> zones) {
LOG.trace(" RemoveTransportZoneMembership TEPs {}, Membership to be removed {} ", endPts, zones);
- List<TzMembership> existingTzList = new ArrayList<>(endPts.nonnullTzMembership()) ;
+ List<TzMembership> existingTzList = new ArrayList<>(endPts.nonnullTzMembership());
for (TzMembership membership : zones) {
existingTzList.remove(new TzMembershipBuilder().setZoneName(membership.getZoneName()).build());
}
for (TunnelEndPoints tep : dstDpn.nonnullTunnelEndPoints()) {
if (Objects.equals(tep.getIpAddress(), srcTep.getIpAddress())) {
List<TzMembership> tzMemberships = tep.nonnullTzMembership();
- LOG.debug("Original Membership size {}", tzMemberships.size()) ;
+ LOG.debug("Original Membership size {}", tzMemberships.size());
return tzMemberships;
}
}
}
public static StateTunnelList buildStateTunnelList(StateTunnelListKey tlKey, String name, boolean state,
- TunnelOperStatus tunOpStatus, IInterfaceManager ifaceManager,
+ TunnelOperStatus tunOpStatus, IInterfaceManager ifaceManager,
DataBroker broker) {
StateTunnelListBuilder stlBuilder = new StateTunnelListBuilder();
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
}
@NonNull
- public static Optional<InternalTunnel> getInternalTunnelFromDS(Uint64 srcDpn, Uint64 destDpn,
- Class<? extends TunnelTypeBase> type,
- DataBroker dataBroker) {
+ public static Optional<InternalTunnel> getInternalTunnelFromDS(Uint64 srcDpn, Uint64 destDpn,
+ Class<? extends TunnelTypeBase> type,
+ DataBroker dataBroker) {
InstanceIdentifier<InternalTunnel> pathLogicTunnel = InstanceIdentifier.create(TunnelList.class)
.child(InternalTunnel.class,
new InternalTunnelKey(destDpn, srcDpn, type));
/**
* Returns the transport zone from Configuration datastore.
*
- * @param tzName transport zone name
+ * @param tzName transport zone name
* @param dataBroker data broker handle to perform operations on datastore
* @return the TransportZone object in Config DS
*/
if (STRING_CLASS_IMMUTABLE_BI_MAP.containsKey(tunnelType)) {
tunType = STRING_CLASS_IMMUTABLE_BI_MAP.get(tunnelType);
}
- return tunType ;
+ return tunType;
}
public static List<Uint64> getDpIdFromTransportzone(DataBroker dataBroker, String tzone) {
*/
package org.opendaylight.genius.itm.impl;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-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.ReadFailedException;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
import java.util.List;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import java.util.List;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
*/
package org.opendaylight.genius.itm.itmdirecttunnels.listeners;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.cache.BfdStateCache;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.eclipse.jdt.annotation.NonNull;
-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.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.cache.BfdStateCache;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.genius.itm.listeners.RemoteDpnListener;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.genius.itm.itmdirecttunnels.listeners;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Callable;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryBuilder;
}
public void updateBfdConfiguration(Uint64 srcDpnId, RemoteDpns remoteDpn,
- com.google.common.base.@NonNull Optional<OvsBridgeRefEntry> ovsBridgeRefEntry) {
+ Optional<OvsBridgeRefEntry> ovsBridgeRefEntry) {
if (ovsBridgeRefEntry.isPresent()) {
LOG.debug("creating bridge interface on dpn {}", srcDpnId);
InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.confighelpers.ItmTunnelAggregationHelper;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.InterfaceChildInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntry;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.genius.itm.listeners;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-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.ReadFailedException;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.cache.TunnelStateCache;
import org.opendaylight.genius.itm.cache.UnprocessedTunnelsStateCache;
import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
stlBuilder.setOperState(tunnelOperStatus);
StateTunnelList stList = stlBuilder.build();
LOG.trace("Batching the updation of tunnel_state: {} for Id: {}", stList, stListId);
- ITMBatchingUtils.update(stListId, stList, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
+ ITMBatchingUtils.updateContainer(stListId, stList, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
} else {
LOG.debug("Tunnel is not yet added but an update has come in for {},so cache it", updated.getName());
unprocessedTunnelsStateCache.add(updated.getName(), tunnelOperStatus);
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.itm.commons.OvsdbTepInfo;
import org.opendaylight.genius.itm.confighelpers.OvsdbTepAddWorker;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
package org.opendaylight.genius.itm.listeners;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
package org.opendaylight.genius.itm.listeners;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.itm.recovery.impl.ItmServiceRecoveryHandler;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.RecoverableListener;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
*/
package org.opendaylight.genius.itm.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
*/
package org.opendaylight.genius.itm.listeners;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.infrautils.utils.concurrent.Executors;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredAsyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import javax.inject.Singleton;
import javax.management.JMException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
import static org.opendaylight.yangtools.yang.common.RpcResultBuilder.failed;
import com.google.common.base.Objects;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
-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.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldTunnelId;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults;
import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults.LogLevel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
RpcResultBuilder<GetTunnelInterfaceNameOutput> resultBld = null;
Uint64 sourceDpn = input.getSourceDpid();
Uint64 destinationDpn = input.getDestinationDpid();
- Optional<InternalTunnel> optTunnel = Optional.absent();
+ Optional<InternalTunnel> optTunnel = Optional.empty();
if (interfaceManager.isItmDirectTunnelsEnabled()) {
DpnTepInterfaceInfo interfaceInfo = dpnTepStateCache.getDpnTepInterface(sourceDpn, destinationDpn);
for (DPNTEPsInfo teps : meshedDpnList) {
TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0);
if (dstIp.equals(firstEndPt.getIpAddress())) {
- Optional<InternalTunnel> optTunnel = Optional.absent();
+ Optional<InternalTunnel> optTunnel = Optional.empty();
if (interfaceManager.isItmDirectTunnelsEnabled()) {
DpnTepInterfaceInfo interfaceInfo =
dpnTepStateCache.getDpnTepInterface(srcDpn, teps.getDPNID());
.setNodeId(nodeId).setTopologyId(input.getTopologyId()).build();
//TO DO: add retry if it fails
FluentFuture<Void> future = retryingTxRunner
- .callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(path, deviceVtep,
- true));
+ .callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(path,
+ deviceVtep, true));
future.addCallback(new FutureCallback<Void>() {
interface="org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService" />
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="entityOwnershipService"
interface="org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService" />
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.Futures;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.genius.itm.cache.UnprocessedTunnelsStateCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+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.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
private final java.lang.Class<? extends TunnelTypeBase> tunnelType2 = TunnelTypeGre.class;
private final InstanceIdentifier<TransportZone> transportZoneIdentifier = InstanceIdentifier
- .builder(TransportZones.class).child(TransportZone.class, new TransportZoneKey(transportZone1)).build();
+ .create(TransportZones.class).child(TransportZone.class, new TransportZoneKey(transportZone1));
private final InstanceIdentifier<TransportZones> transportZonesIdentifier =
InstanceIdentifier.builder(TransportZones.class).build();
private final InstanceIdentifier<TunnelMonitorInterval> tunnelMonitorIntervalIdentifier =
@Mock
private ItmConfig itmConfig;
@Mock
- private ReadOnlyTransaction mockReadTx;
+ private ReadTransaction mockReadTx;
@Mock
private WriteTransaction mockWriteTx;
.Interface>
ifStateOptionalNew = Optional.of(interfaceTestNew);
- doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZoneIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalTunnelMonitorInterval)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorInterval)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalTunnelMonitorParams)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorParams)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
- doReturn(Futures.immediateCheckedFuture(optionalVteps)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(optionalVteps)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(ifStateOptional)).when(mockReadTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(ifStateOptional)).when(mockReadTx)
.read(LogicalDatastoreType.OPERATIONAL,interfaceIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(ifStateOptionalNew)).when(mockReadTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(ifStateOptionalNew)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,interfaceIdentifierNew);
unprocessedTunnelsStateCache = new UnprocessedTunnelsStateCache();
interval, false, null);
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
- doReturn(FluentFuture.from(Futures.immediateCheckedFuture(CommitInfo.empty()))).when(mockWriteTx).commit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
+ doReturn(FluentFuture.from(FluentFutures.immediateFluentFuture(CommitInfo.empty()))).when(mockWriteTx).commit();
}
@Test
transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2)
.setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
- doReturn(Futures.immediateCheckedFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
- .CONFIGURATION,transportZonesIdentifier);
+ lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
+ .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
try {
tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
Optional<TransportZone> optionalTransportZone = Optional.of(transportZoneNew);
- doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZoneIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
- .CONFIGURATION,transportZonesIdentifier);
-
-
+ lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
+ .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
try {
tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
tepCommandHelper.createLocalCache(dpId2,tepIp1,transportZone1);
@Test
public void testConfigureTunnelType() throws ExecutionException, InterruptedException {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZoneIdentifier);
tepCommandHelper.configureTunnelType(transportZone1, "VXLAN");
.setTunnelType(TunnelTypeVxlan.class).build());
verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, transportZonesIdentifier,
- new TransportZonesBuilder().setTransportZone(newList).build(),true);
+ new TransportZonesBuilder().setTransportZone(newList).build());
}
@Test
tepCommandHelper.configureTunnelMonitorParams(enabled, "BFD");
verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier,tunnelMonitor,true);
+ verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier,
+ tunnelMonitor);
}
@SuppressWarnings("checkstyle:IllegalCatch")
@Test
public void testBuildTepsTunnelTypeGre() {
- doReturn(Futures.immediateCheckedFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
+ doReturn(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
try {
@Test
public void testBuildTepsTransportZoneAbsent() throws TepException {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZoneIdentifier);
tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
optionalTransportZones = Optional.of(transportZonesNew);
- doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
String output = null;
transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
optionalTransportZones = Optional.of(transportZones);
- doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
try {
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.Future;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
@Mock DataBroker dataBroker;
@Mock JobCoordinator jobCoordinator;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock TypedWriteTransaction<Datastore.Configuration> typedWriteTransaction;
@Mock TypedReadWriteTransaction<Datastore.Configuration> typedReadWriteTransaction;
lenient().doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
lenient().doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
doReturn("phy0").when(itmConfig).getPortname();
doReturn(Uint16.valueOf(100)).when(itmConfig).getVlanId();
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import junit.framework.TestCase;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.confighelpers.HwVtep;
import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelDeleteWorker;
import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
InstanceIdentifier<ExternalTunnel> path ;
@Mock DataBroker dataBroker;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IdManagerService idManagerService;
@Mock TypedWriteTransaction<Datastore.Configuration> typedWriteTransaction;
lenient().doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
lenient().doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
doReturn("phy0").when(itmConfig).getPortname();
doReturn(Uint16.valueOf(100)).when(itmConfig).getVlanId();
}
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.cache.OfEndPointCache;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcResult;
Future<RpcResult<AllocateIdOutput>> dstId2Output;
@Mock DataBroker dataBroker;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock ReadWriteTransaction mockReadWriteTx;
@Mock IMdsalApiManager mdsalApiManager;
@Mock IdManagerService idManagerService;
dstId1Output = RpcResultBuilder.success(expectedDstID1).buildFuture();
dstId2Output = RpcResultBuilder.success(expectedDstID2).buildFuture();
- doReturn(Futures.immediateCheckedFuture(tunnelMonitorParamsOptional)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorParamsOptional)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorParamsInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorIntervalOptional)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorIntervalIdentifier);
- doReturn(Futures.immediateCheckedFuture(tunnelMonitorParamsOptional)).when(mockReadWriteTx)
+ doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorParamsOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorParamsInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)).when(mockReadWriteTx)
+ doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorIntervalOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorIntervalIdentifier);
directTunnelUtils = new DirectTunnelUtils(idManagerService, mdsalApiManager, entityOwnershipUtils, itmConfig);
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockReadWriteTx).when(dataBroker).newReadWriteTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(mockReadWriteTx).submit();
+ doReturn(FluentFutures.immediateNullFluentFuture()).when(mockReadWriteTx).commit();
doReturn(true).when(mockReadWriteTx).cancel();
}
//Add some verifications
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan1,
- internalTunnel1,true);
+ internalTunnel1, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan2,
- internalTunnel2,true);
+ internalTunnel2, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsVxlan);
}
itmInternalTunnelAddWorker.buildAllTunnels(mdsalApiManager, cfgdDpnListGre, meshDpnListGre);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre1,
- internalTunnel1,true);
+ internalTunnel1, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre2,
- internalTunnel2,true);
+ internalTunnel2, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsGre);
}
itmInternalTunnelAddWorker.buildAllTunnels(mdsalApiManager, cfgdDpnListVxlan, meshDpnListGre);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierVxlan1,
- internalTunnel1,true);
+ internalTunnel1, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierGre2,
- internalTunnel2,true);
+ internalTunnel2, true);
verify(mockReadWriteTx).merge(LogicalDatastoreType.CONFIGURATION, dpnEndpointsIdentifier,
dpnEndpointsVxlan);
}
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
.build();
@Mock DataBroker dataBroker;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock ReadWriteTransaction mockReadWriteTx;
@Mock IdManagerService idManagerService;
@Mock IMdsalApiManager mdsalApiManager;
tunnelMonitorIntervalOptional = Optional.of(tunnelMonitorInterval);
internalTunnelOptional = Optional.of(internalTunnel);
- doReturn(Futures.immediateCheckedFuture(tunnelMonitorParamsOptional)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorParamsOptional)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,
tunnelMonitorParamsInstanceIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(tunnelMonitorParamsOptional)).when(mockReadWriteTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorParamsOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION,
tunnelMonitorParamsInstanceIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)).when(mockReadTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorIntervalOptional)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION,
tunnelMonitorIntervalIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(tunnelMonitorIntervalOptional)).when(mockReadWriteTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(tunnelMonitorIntervalOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION,
tunnelMonitorIntervalIdentifier);
- doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx)
+ doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx)
.read(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadWriteTx)
+ lenient().doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifier);
DPNTEPsInfoCache dpntePsInfoCache =
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockReadWriteTx).when(dataBroker).newReadWriteTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockReadWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockReadWriteTx).commit();
doReturn(true).when(mockReadWriteTx).cancel();
lenient().doReturn(false).when(itmConfig).isUseOfTunnels();
}
Optional<DpnEndpoints> dpnEndpointsOptional = Optional.of(dpnEndpoints);
- lenient().doReturn(Futures.immediateCheckedFuture(dpnEndpointsOptional)).when(mockReadTx).read(
+ lenient().doReturn(FluentFutures.immediateFluentFuture(dpnEndpointsOptional)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,dpnEndpointsIdentifier);
itmInternalTunnelDeleteWorker.deleteTunnels(mdsalApiManager, cfgdDpnListVxlan,meshDpnListVxlan);
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
@Mock DataBroker dataBroker;
@Mock JobCoordinator jobCoordinator;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IMdsalApiManager mdsalApiManager;
@Mock ItmConfig itmConfig;
dpnEndpointsOptional = Optional.of(dpnEndpoints);
transportZonesOptional = Optional.of(transportZones);
- doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier);
- doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier1);
- doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,internalTunnelIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(
+ lenient().doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
- lenient().doReturn(Futures.immediateCheckedFuture(dpnEndpointsOptional)).when(mockReadTx).read(
+ lenient().doReturn(FluentFutures.immediateFluentFuture(dpnEndpointsOptional)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,dpnEndpointsIdentifier);
- doReturn(Futures.immediateCheckedFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
DPNTEPsInfoCache dpntePsInfoCache =
transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
}
@Test
@Ignore
@Test
public void testGetInternalOrExternalInterfaceNameExtTunnelAbsent() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier);
itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
import static com.google.common.truth.Truth.assertThat;
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.genius.datastoreutils.testutils.TestableDataTreeChangeListenerModule;
import org.opendaylight.infrautils.caches.testutils.CacheModule;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpointsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
InstanceIdentifier<InternalTunnel> internalTunnelIdentifier = InstanceIdentifier.create(TunnelList.class)
.child(InternalTunnel.class, new InternalTunnelKey(ItmTestConstants.DP_ID_2, ItmTestConstants.DP_ID_1,
ItmTestConstants.TUNNEL_TYPE_VXLAN));
- InstanceIdentifier<DpnEndpoints> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class).build();
+ //InstanceIdentifier<DpnEndpoints> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class).build();
+
+
+ InstanceIdentifier<DPNTEPsInfo> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class)
+ .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(ItmTestConstants.DP_ID_1)).build();
+
InstanceIdentifier<Interface> interfaceIdentifier;
- InstanceIdentifier<TransportZones> transportZonesIdentifier = InstanceIdentifier.create(TransportZones.class);
+
+ InstanceIdentifier<TransportZone> transportZonesIdentifier = InstanceIdentifier.builder(TransportZones.class)
+ .child(TransportZone.class, new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
+
InstanceIdentifier<DeviceVteps> deviceVtepsIdentifier = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(ItmTestConstants.TZ_NAME))
.child(DeviceVteps.class, deviceVtepKey).build();
@Before
public void setUp() throws Exception {
+ //////db,txrunner
+
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
+
+
+ /*if (dataBroker != null)
+ {
+ String errMsg = "present db :" + txRunner;
+ throw new NullPointerException(errMsg);
+ }*/
+
deviceVteps = new DeviceVtepsBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3).withKey(new DeviceVtepsKey(
ItmTestConstants.IP_ADDRESS_3,ItmTestConstants.SOURCE_DEVICE))
.setNodeId(ItmTestConstants.SOURCE_DEVICE).setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(ItmTestConstants.DP_ID_1)
.withKey(new DPNTEPsInfoKey(ItmTestConstants.DP_ID_1)).setUp(true)
.setTunnelEndPoints(tunnelEndPointsListVxlan).build();
- cfgdDpnListVxlan.add(dpntePsInfoVxlan);
- dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
+ //cfgdDpnListVxlan.add(dpntePsInfoVxlan);
+ //dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
+
internalTunnel = new InternalTunnelBuilder()
.setTunnelInterfaceNames(Collections.singletonList(ItmTestConstants.PARENT_INTERFACE_NAME))
.setDestinationDPN(ItmTestConstants.DP_ID_2).setSourceDPN(ItmTestConstants.DP_ID_1)
transportZone = new TransportZoneBuilder().setZoneName(ItmTestConstants.TZ_NAME)
.setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
.withKey(new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
- transportZoneList.add(transportZone);
- transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
+ //transportZoneList.add(transportZone);
+ //transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
// build external tunnel objects
externalTunnel = new ExternalTunnelBuilder().setSourceDevice(ItmTestConstants.DP_ID_1.toString())
syncWrite(externalTunnelIdentifier, externalTunnel);
syncWrite(externalTunnelIdentifier2, externalTunnel2);
- // commit internal tunnel into config DS
+ /*if (dataBroker != null)
+ {
+ String errMsg = "present db :" + internalTunnelIdentifier + " present 2" + internalTunnel ;
+ throw new NullPointerException(errMsg);
+ }*/
+
+ // commit internal tunnel into config DS.
syncWrite(internalTunnelIdentifier, internalTunnel);
+
// commit dpnEndpoints into config DS
- syncWrite(dpnEndpointsIdentifier, dpnEndpoints);
+
+ syncWrite(dpnEndpointsIdentifier, dpntePsInfoVxlan);
// wait for completion of ITM config DS default-TZ creation task of DJC
coordinatorEventsWaiter.awaitEventsConsumption();
// commit TZ into config DS
- syncWrite(transportZonesIdentifier, transportZones);
+
+ syncWrite(transportZonesIdentifier, transportZone);
}
@Test
// check ExternalTunnelEndpoint is added in config DS
assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnelForRpcTest(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).get().get());
}
@Test
ListenableFuture<RpcResult<AddL2GwDeviceOutput>> rpcRes =
itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
+ coordinatorEventsWaiter.awaitEventsConsumption();
+ Thread.sleep(5000);
+
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
// check L2GwDevice is added in config DS
assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get().get());
}
+ @Ignore
@Test
public void testAddL2GwMlagDevice() throws Exception {
ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> rpcRes =
itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
+ coordinatorEventsWaiter.awaitEventsConsumption();
+ Thread.sleep(8000);
+
+
// check RPC response is SUCCESS
assertThat(rpcRes.get().isSuccessful()).isTrue();
// check L2GwMlagDevice is added in config DS
assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get().get());
assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject2(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier2).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier2).get().get());
}
@Test
assertThat(rpcRes.get().isSuccessful()).isTrue();
// check L2GwDevice is deleted from config DS
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get());
}
assertThat(rpcRes.get().isSuccessful()).isTrue();
// check L2GwMlagDevice is deleted from config DS
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get());
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier2).get());
}
// check ExternalTunnel From Dpns is added in config DS
assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnelForRpcTest(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).get().get());
}
@Test
assertThat(rpcRes.get().isSuccessful()).isTrue();
// check ExternalTunnel From Dpns is deleted from config DS
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew).get());
// check iface is removed
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier).get());
}
assertThat(removeExternalTunnelEndpoint.get().isSuccessful()).isTrue();
// check ExternalTunnelEndpoint is deleted from config DS
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew).get());
// check iface is removed
- assertThat(Optional.absent()).isEqualTo(dataBroker.newReadOnlyTransaction()
+ assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier).get());
}
// check ExternalTunnel From Dpns is added in config DS
assertEqualBeans(ExpectedInternalTunnelIdentifierObjects.newInternalTunnelObjVxLanOneToTwo(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier).get().get());
}
@Test
// check ExternalTunnel From Dpns is added in config DS
assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnel2ForRpcTest(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType
- .CONFIGURATION,externalTunnelIdentifier2).checkedGet().get());
+ .CONFIGURATION,externalTunnelIdentifier2).get().get());
// check for interfaceName
assertThat(ItmTestConstants.PARENT_INTERFACE_NAME).isEqualTo(rpcRes.get().getResult().getInterfaceName());
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import javax.inject.Inject;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.infrautils.caches.testutils.CacheModule;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZone;
ItmConfig itmConfigObj = new ItmConfigBuilder().setDefTzEnabled(false).build();
// write into config DS
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> tx.put(iid, itmConfigObj, true)).get();
+
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ iid,itmConfigObj));
+ coordinatorEventsWaiter.awaitEventsConsumption();
// read from config DS
- boolean defTzEnabled = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+ boolean defTzEnabled = SingleTransactionDataBroker.syncReadOptional(
dataBroker, LogicalDatastoreType.CONFIGURATION, iid).get().isDefTzEnabled();
Assert.assertEquals(defTzEnabled, false);
}
ItmConfig itmConfigObj = new ItmConfigBuilder().setDefTzEnabled(true).build();
// write into config DS
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> tx.put(iid, itmConfigObj, true)).get();
+ //txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+ // tx -> tx.put(iid, itmConfigObj, true));
+
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ iid,itmConfigObj)).get();
+
+ coordinatorEventsWaiter.awaitEventsConsumption();
+
// read from config DS
- boolean defTzEnabled = SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+ boolean defTzEnabled = SingleTransactionDataBroker.syncReadOptional(
dataBroker, LogicalDatastoreType.CONFIGURATION, iid).get().isDefTzEnabled();
Assert.assertEquals(defTzEnabled, true);
}
// set def-tz-tunnel-type to VXLAN
String defTzTunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
+ /*InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();*/
+
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
defTzTunnelType);
Assert.assertNotNull(tzonePath);
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithVxlanTunnelType(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
}
@Test
// set def-tz-tunnel-type to GRE
String defTzTunnelType = ITMConstants.TUNNEL_TYPE_GRE;
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(TunnelTypeGre.class)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
+
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
defTzTunnelType);
Assert.assertNotNull(tzonePath);
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithGreTunnelType(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
}
@Test
defTzTunnelType);
Assert.assertNotNull(tzonePath);
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, tzonePath).get());
}
// set def-tz-tunnel-type to VXLAN
String defTzTunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(TunnelTypeVxlan.class)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
InstanceIdentifier<TransportZone> tzonePath = processDefTzOnItmConfig(defTzEnabledFlag,
defTzTunnelType);
Assert.assertNotNull(tzonePath);
// check default-TZ is created with VXLAN tunnel type
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithVxlanTunnelType().getTunnelType(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzonePath)
- .checkedGet().get().getTunnelType());
+ .get().get().getTunnelType());
// now, change def-tz-tunnel-type to GRE
defTzTunnelType = ITMConstants.TUNNEL_TYPE_GRE;
+
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(TunnelTypeGre.class)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
+
tzonePath = processDefTzOnItmConfig(defTzEnabledFlag, defTzTunnelType);
Assert.assertNotNull(tzonePath);
// check default-TZ is re-created with GRE tunnel type
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithGreTunnelType().getTunnelType(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzonePath)
- .checkedGet().get().getTunnelType());
+ .get().get().getTunnelType());
}
@Test
itmProvider.createDefaultTransportZone(itmConfigObj);
coordinatorEventsWaiter.awaitEventsConsumption();
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(TunnelTypeGre.class)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ITMConstants.DEFAULT_TRANSPORT_ZONE);
Assert.assertNotNull(tzonePath);
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithGreTunnelType(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// now delete default-TZ first by setting def-tz-enabled flag to false
itmConfigObj = new ItmConfigBuilder().setDefTzEnabled(false).build();
itmProvider.createDefaultTransportZone(itmConfigObj);
coordinatorEventsWaiter.awaitEventsConsumption();
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, tzonePath).get());
}
// wait for start-up default-TZ creation task to get over
coordinatorEventsWaiter.awaitEventsConsumption();
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(TunnelTypeVxlan.class)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
InstanceIdentifier<TransportZone> tzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ITMConstants.DEFAULT_TRANSPORT_ZONE);
Assert.assertNotNull(tzonePath);
// check TEP is added into default-TZ
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithTep(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// remove tep from default-TZ
futures = ItmTepAutoConfigTestUtil.deleteTep(ItmTestConstants.DEF_TZ_TEP_IP, ItmTestConstants.DEF_BR_DPID,
futures.get();
// check TEP is deleted from default-TZ
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, vtepPath).get());
}
// check TZ is created with correct TZ name
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get().getZoneName());
// add tep
ListenableFuture<Void> futures = ItmTepAutoConfigTestUtil.addTep(ItmTestConstants.NB_TZ_TEP_IP,
// check TEP is added into TZ that is already created.
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// remove tep
futures = ItmTepAutoConfigTestUtil.deleteTep(ItmTestConstants.NB_TZ_TEP_IP, ItmTestConstants.DEF_BR_DPID,
futures.get();
// check TEP is deleted
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, vtepPath).get());
// for safe side, check TZ is present
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get().getZoneName());
}
@Test
// OvsdbNodeListener would be automatically listen on Node to add TEP
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future =
+ FluentFuture<? extends @NonNull CommitInfo> future =
OvsdbTestUtil.createNode(connInfo,tepIp,ITMConstants.DEFAULT_TRANSPORT_ZONE,dataBroker);
future.get();
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
+
// add bridge into node
future = OvsdbTestUtil.addBridgeIntoNode(connInfo, ItmTestConstants.DEF_BR_NAME,
ItmTestConstants.DEF_BR_DPID, dataBroker);
// check TEP is added into default-TZ
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithTep(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzonePath)
- .checkedGet().get());
+ .get().get());
// test TEP delete now,
// pass tep-ip with NULL value, tep-ip paramtere in external_ids will not be set.
Assert.assertNotNull(vtepPath);
// check TEP is deleted from default-TZ when TEP-Ip is removed from southbound
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, vtepPath).get());
}
// OvsdbNodeListener would be automatically listen on Node to add TEP
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future = OvsdbTestUtil.createNode(
+ FluentFuture<? extends @NonNull CommitInfo> future = OvsdbTestUtil.createNode(
connInfo, tepIp, ItmTestConstants.TZ_NAME, dataBroker);
future.get();
// check TEP is added into NB configured TZ
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzonePath)
- .checkedGet().get());
+ .get().get());
IpPrefix subnetMaskObj = ItmUtils.getDummySubnet();
coordinatorEventsWaiter.awaitEventsConsumption();
// check TEP is deleted from default-TZ when TEP-Ip is removed from southbound
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, vtepPath).get());
}
// create Network topology node
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future = OvsdbTestUtil.createNode(
+ FluentFuture<? extends @NonNull CommitInfo> future = OvsdbTestUtil.createNode(
connInfo, ItmTestConstants.NOT_HOSTED_TZ_TEP_IP, ItmTestConstants.NOT_HOSTED_TZ_NAME,
dataBroker);
future.get();
// check not hosted
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- notHostedtzPath).checkedGet().get());
+ notHostedtzPath).get().get());
future = OvsdbTestUtil.updateNode(connInfo, ItmTestConstants.NOT_HOSTED_TZ_TEP_IP, null,
ItmTestConstants.DEF_BR_NAME, dataBroker);
// wait for OvsdbNodeListener to perform config DS update through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
- Assert.assertEquals(Optional.absent(),dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(),dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.OPERATIONAL, notHostedtzPath).get());
}
// OvsdbNodeListener would be automatically listen on Node to add TEP
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future = OvsdbTestUtil.createNode(
+ FluentFuture<? extends @NonNull CommitInfo> future = OvsdbTestUtil.createNode(
connInfo, tepIp, ITMConstants.DEFAULT_TRANSPORT_ZONE, dataBroker);
future.get();
+ InstanceIdentifier<TransportZone> tzPath =
+ ItmUtils.getTZInstanceIdentifier(ITMConstants.DEFAULT_TRANSPORT_ZONE);
+ txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
+ tzPath, new TransportZoneBuilder().setZoneName(ITMConstants.DEFAULT_TRANSPORT_ZONE)
+ .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
+ .withKey(new TransportZoneKey(ITMConstants.DEFAULT_TRANSPORT_ZONE))
+ .build(), WriteTransaction.CREATE_MISSING_PARENTS)).get();
+
// add bridge into node
future = OvsdbTestUtil.addBridgeIntoNode(connInfo, ItmTestConstants.DEF_BR_NAME,
ItmTestConstants.DEF_BR_DPID, dataBroker);
future.get();
// wait for OvsdbNodeListener to perform config DS update through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
+ //Thread.sleep(5000);
// iid for default-TZ
InstanceIdentifier<TransportZone> defTzonePath = ItmTepAutoConfigTestUtil.getTzIid(
ITMConstants.DEFAULT_TRANSPORT_ZONE);
Assert.assertNotNull(defTzonePath);
+
// check TEP is added into default-TZ
+
+ /*if (dataBroker != null)
+ {
+ String errMsg = "present db :" + dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.CONFIGURATION, defTzonePath);
+ throw new NullPointerException(errMsg);
+ }*/
+
+
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithTep(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, defTzonePath)
- .checkedGet().get());
+ .get().get());
// update OVSDB node with tep-ip in local_ip list
tepIp = ItmTestConstants.NB_TZ_TEP_IP;
// when local_ip is updated from southbound
assertEqualBeans(ExpectedDefTransportZoneObjects.defTzWithUpdatedTepIp(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,defTzonePath)
- .checkedGet().get());
+ .get().get());
}
@Ignore
// OvsdbNodeListener would be automatically listen on Node to add TEP
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future = OvsdbTestUtil.createNode(
+ FluentFuture<? extends @NonNull CommitInfo> future = OvsdbTestUtil.createNode(
connInfo, tepIp, ITMConstants.DEFAULT_TRANSPORT_ZONE, dataBroker);
future.get();
// check TEP is added into default-TZ
assertEqualBeans(ExpectedDefTransportZoneObjects.newDefTzWithTep(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, defTzonePath)
- .checkedGet().get());
+ .get().get());
IpPrefix subnetMaskObj = ItmUtils.getDummySubnet();
InstanceIdentifier<Vteps> oldVTepPath = ItmTepAutoConfigTestUtil.getTepIid(subnetMaskObj,
coordinatorEventsWaiter.awaitEventsConsumption();
// check old TEP which was in default-TZ is deleted
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, oldVTepPath).get());
// check TEP is updated and now it is added into TZA transport-zone when tzname is updated
// to TZA from southbound
assertEqualBeans(ExpectedTransportZoneObjects.updatedTransportZone(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,tzaTzonePath)
- .checkedGet().get());
+ .get().get());
}
@Test
// OvsdbNodeListener would be automatically listen on Node to add TEP
ConnectionInfo connInfo = OvsdbTestUtil.getConnectionInfo(ItmTestConstants.OVSDB_CONN_PORT,
ItmTestConstants.LOCALHOST_IP);
- CheckedFuture<Void, TransactionCommitFailedException> future = OvsdbTestUtil.createNode(
+ FluentFuture<? extends @NonNull CommitInfo> future = OvsdbTestUtil.createNode(
connInfo, tepIp, ItmTestConstants.TZ_NAME, dataBroker);
future.get();
ItmTestConstants.TZ_NAME);
Assert.assertNotNull(tzonePath);
+ /*if (dataBroker != null)
+ {
+ String errMsg = "present db :" + dataBroker.newReadOnlyTransaction().
+ read(LogicalDatastoreType.CONFIGURATION, tzonePath);
+ throw new NullPointerException(errMsg);
+ }*/
+
// check TEP is added into TZ
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
IpPrefix subnetMaskObj = ItmUtils.getDummySubnet();
Assert.assertNotNull(newVTepPath);
// check old TEP having default-bridge-DPID is deleted
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, oldVTepPath).get());
// check TEP is updated with dpnId of br2 when br-name is updated to br2 from southbound
Assert.assertEquals(ItmTestConstants.INT_BR2_DPID, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, newVTepPath).checkedGet().get().getDpnId());
+ .read(LogicalDatastoreType.CONFIGURATION, newVTepPath).get().get().getDpnId());
}
@Test
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL, notHostedPath)
- .checkedGet().get());
+ .get().get());
}
@Test
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get());
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get());
//delete from not hosted list
future = ItmTepAutoConfigTestUtil.deleteTep(ItmTestConstants.NOT_HOSTED_TZ_TEP_IP,
ItmTestConstants.NOT_HOSTED_TZ_TEPDPN_ID, ItmTestConstants.NOT_HOSTED_TZ_NAME, dataBroker, txRunner);
future.get();
- Assert.assertEquals(Optional.absent(),
+ Assert.assertEquals(Optional.empty(),
dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get());
}
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get());
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get());
// create the same TZ
TransportZone transportZoneNorth = new TransportZoneBuilder().setZoneName(ItmTestConstants.NOT_HOSTED_TZ_NAME)
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects
.newTepNotHostedTransportZone().getUnknownVteps().get(0).getIpAddress().stringValue(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzPath)
- .checkedGet().get().getVteps().get(0).getIpAddress().stringValue());
+ .get().get().getVteps().get(0).getIpAddress().stringValue());
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone().getUnknownVteps()
.get(0).getDpnId(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzPath).checkedGet().get()
- .getVteps().get(0).getDpnId());
+ .read(LogicalDatastoreType.CONFIGURATION, tzPath).get()
+ .get().getVteps().get(0).getDpnId());
assertEqualBeans(ExpectedTepNotHostedTransportZoneObjects.newTepNotHostedTransportZone().getZoneName(),
dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tzPath)
- .checkedGet().get().getZoneName());
+ .get().get().getZoneName());
// check TZ is removed
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get());
}
// check TZ is created
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get().getZoneName());
// add tep
ListenableFuture<Void> futures =
// check TEP is added into TZ that is already created.
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// remove Transport Zone
txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.delete(LogicalDatastoreType.CONFIGURATION,
// for TEP movement through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
//verify delete
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet());
+
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get());
//check deleted tz moved to notHosted
InstanceIdentifier<TepsInNotHostedTransportZone> notHostedPath =
ItmTepAutoConfigTestUtil.getTepNotHostedInTZIid(ItmTestConstants.TZ_NAME);
Assert.assertNotNull(notHostedPath);
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getZoneName());
//readd the same tz
txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.CONFIGURATION,
// for TEP movement through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet());
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get());
+
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
}
@Test
// check TZ is created
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get().getZoneName());
// add tep
ListenableFuture<Void> futures =
// check TEP is added into TZ that is already created.
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// remove Transport Zone
txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.delete(LogicalDatastoreType.CONFIGURATION,
// for TEP movement through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
//verify delete
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet());
+
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get());
//check deleted tz moved to notHosted
InstanceIdentifier<TepsInNotHostedTransportZone> notHostedPath =
coordinatorEventsWaiter.awaitEventsConsumption();
Assert.assertNotNull(notHostedPath);
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getZoneName());
//create vtepList form unknownVtepList
List<Vteps> vtepsList = new ArrayList<>();
List<UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getUnknownVteps();
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getUnknownVteps();
for (UnknownVteps unknownVtep:unknownVtepsList) {
Vteps vteps = new VtepsBuilder().setDpnId(unknownVtep.getDpnId())
coordinatorEventsWaiter.awaitEventsConsumption();
// verify TZ is moved from notHosted to transport zone and their should be only one vtep in it.
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet());
+
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get());
+
assertEqualBeans(1, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get()
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get()
.getVteps().size());
}
// check TZ is created
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get().getZoneName());
// add tep
ListenableFuture<Void> futures =
// check TEP is added into TZ that is already created.
assertEqualBeans(ExpectedTransportZoneObjects.newTransportZone(),
dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get());
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get());
// remove Transport Zone
txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.delete(LogicalDatastoreType.CONFIGURATION,
// for TEP movement through transaction
coordinatorEventsWaiter.awaitEventsConsumption();
//verify delete
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet());
+
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get());
//check deleted tz moved to notHosted
InstanceIdentifier<TepsInNotHostedTransportZone> notHostedPath =
Assert.assertNotNull(notHostedPath);
Assert.assertEquals(ItmTestConstants.TZ_NAME, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getZoneName());
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getZoneName());
//create vtepList form unknownVtepList
List<Vteps> vtepsList = new ArrayList<>();
List<UnknownVteps> unknownVtepsList = dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getUnknownVteps();
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get().get().getUnknownVteps();
//modifing the dpnid and keeping the ip same.
for (UnknownVteps unknownVtep:unknownVtepsList) {
Vteps vteps = new VtepsBuilder().setDpnId(Uint64.valueOf(10))
coordinatorEventsWaiter.awaitEventsConsumption();
// verify TZ is moved from notHosted to transport zone and their should be only one vtep in it.
- Assert.assertEquals(Optional.absent(), dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet());
+
+ Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
+ .read(LogicalDatastoreType.OPERATIONAL, notHostedPath).get());
+
assertEqualBeans(1, dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.CONFIGURATION, tzonePath).checkedGet().get()
+ .read(LogicalDatastoreType.CONFIGURATION, tzonePath).get().get()
.getVteps().size());
}
}
*/
package org.opendaylight.genius.itm.tests;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.itm.confighelpers.OvsdbTepAddConfigHelper;
import org.opendaylight.genius.itm.confighelpers.OvsdbTepRemoveConfigHelper;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.NotHostedTransportZones;
return OvsdbTepRemoveConfigHelper.removeTepReceivedFromOvsdb(tepIp, strDpnId, tzName, dataBroker, tx).get(0);
}
- public static CheckedFuture<Void, TransactionCommitFailedException> writeItmConfig(
+ public static FluentFuture<? extends @NonNull CommitInfo> writeItmConfig(
InstanceIdentifier<ItmConfig> iid, ItmConfig itmConfig, DataBroker dataBroker) {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, iid, itmConfig);
- return tx.submit();
+ return tx.commit();
}
/* utility methods */
import static org.mockito.Mockito.mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.Executors;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.cloudscaler.api.TombstonedNodeManager;
import org.opendaylight.genius.cloudscaler.rpcservice.TombstonedNodeManagerImpl;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.binding.dom.adapter.BindingDOMEntityOwnershipServiceAdapter;
import org.opendaylight.mdsal.eos.dom.simple.SimpleDOMEntityOwnershipService;
public class ItmTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() {
+ protected void configureBindings() throws Exception {
// Bindings for services from this project
+ /*AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
+ bind(DataBroker.class).toInstance(dataBroker);*/
+
bind(ItmRpcService.class).to(ItmManagerRpcService.class);
bind(ItmProvider.class);
ItmConfig itmConfigObj = new ItmConfigBuilder()
bind(IdManagerService.class).to(IdManager.class);
bind(LockManagerService.class).to(LockManagerServiceImpl.class);
bind(JobCoordinatorEventsWaiter.class).to(TestableJobCoordinatorEventsWaiter.class);
- DataBrokerTestModule dataBrokerTestModule = new DataBrokerTestModule(false);
- DataBroker dataBroker = dataBrokerTestModule.getDataBroker();
+
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
+
+ /*AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new ConcurrentDataBrokerTestCustomizer(false);
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();*/
+
+ /*DataBrokerTestModule dataBrokerTestModule = new DataBrokerTestModule(false);
+ DataBroker dataBroker = dataBrokerTestModule.getDataBroker();*/
+
+ /*DataBrokerTestWiring dataBrokerTestWiring = new DataBrokerTestWiring();
+ DataBroker dataBroker = DataBrokerTestWiring.dataBroker();*/
+
bind(DataBroker.class).toInstance(dataBroker);
DataTreeEventCallbackRegistrar dataTreeEventCallbackRegistrar =
new DataTreeEventCallbackRegistrarImpl(dataBroker);
bind(ServiceRecoveryRegistry.class).toInstance(mock(ServiceRecoveryRegistry.class));
bind(ItmDiagStatusProvider.class).toInstance(mock(ItmDiagStatusProvider.class));
EntityOwnershipService entityOwnershipService = new BindingDOMEntityOwnershipServiceAdapter(
- new SimpleDOMEntityOwnershipService(), dataBrokerTestModule.getBindingToNormalizedNodeCodec());
+ new SimpleDOMEntityOwnershipService(), test.getDataBrokerTestCustomizer().getBindingToNormalized());
bind(EntityOwnershipService.class).toInstance(entityOwnershipService);
bind(EntityOwnershipUtils.class);
bind(TombstonedNodeManager.class).to(TombstonedNodeManagerImpl.class);
*/
package org.opendaylight.genius.itm.tests;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
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.IpAddressBuilder;
return connectionInfo;
}
- public static CheckedFuture<Void, TransactionCommitFailedException> createNode(
+ public static FluentFuture<? extends @NonNull CommitInfo> createNode(
ConnectionInfo connectionInfo, String tepIp, String tzName, DataBroker dataBroker)
throws Exception {
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.put(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode, true);
- return transaction.submit();
+ return transaction.commit();
}
- public static CheckedFuture<Void, TransactionCommitFailedException> updateNode(
+ public static FluentFuture<? extends @NonNull CommitInfo> updateNode(
ConnectionInfo connectionInfo, String tepIp, String tzName, String brName,
DataBroker dataBroker) throws Exception {
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
Node oldOvsdbNode = dataBroker.newReadOnlyTransaction()
- .read(LogicalDatastoreType.OPERATIONAL, iid).checkedGet().get();
+ .read(LogicalDatastoreType.OPERATIONAL, iid).get().get();
// build Node using its builder class
NodeBuilder nodeBuilder = new NodeBuilder();
//ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.put(LogicalDatastoreType.OPERATIONAL, iid, ovsdbNode, true);
- return transaction.submit();
+ return transaction.commit();
}
- public static CheckedFuture<Void, TransactionCommitFailedException> addBridgeIntoNode(
+ public static FluentFuture<? extends @NonNull CommitInfo> addBridgeIntoNode(
ConnectionInfo connectionInfo, String bridgeName, String dpid, DataBroker dataBroker) throws Exception {
NodeId ovsdbNodeId = SouthboundUtils.createNodeId(connectionInfo.getRemoteIp(),
connectionInfo.getRemotePort());
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.merge(LogicalDatastoreType.OPERATIONAL, bridgeIid,
bridgeNode, true);
- return tx.submit();
+ return tx.commit();
}
}
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.infrautils.utils.concurrent.Executors;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredAsyncDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.Locks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.locks.Lock;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.lockmanager.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailures;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailuresModule;
import org.opendaylight.genius.lockmanager.impl.LockManagerServiceImpl;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
<groupId>org.opendaylight.openflowplugin.libraries</groupId>
<artifactId>liblldp</artifactId>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-eos-binding-api</artifactId>
<groupId>org.opendaylight.serviceutils</groupId>
<artifactId>tools-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.serviceutils</groupId>
+ <artifactId>listener-api</artifactId>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>ipv6util-api</artifactId>
<artifactId>mdsal-binding-test-utils</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-spi</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-testutils</artifactId>
<groupId>com.google.guava</groupId>
<artifactId>guava-testlib</artifactId>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<type>test-jar</type>
- </dependency>
+ </dependency>!-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
+ </dependency>
</dependencies>
<build>
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
+/*
package org.opendaylight.genius.datastoreutils;
import com.google.common.base.Preconditions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+*/
/**
* Deprecated DS listener.
* @deprecated Please use
* {@link org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredAsyncDataTreeChangeListener}
* instead of this!
- */
+ *//*
+
@Deprecated
public abstract class AsyncClusteredDataTreeChangeListenerBase
<T extends DataObject, K extends ClusteredDataTreeChangeListener<T>>
}
}
}
+*/
* 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.genius.datastoreutils;
+
+/*package org.opendaylight.genius.datastoreutils;
import com.google.common.base.Preconditions;
import java.util.Collection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+*/
/**
* Deprecated DS listener.
* @deprecated Please use
* {@link org.opendaylight.serviceutils.tools.mdsal.listener.AbstractAsyncDataTreeChangeListener} instead of this!
- */
+ *//*
+
@Deprecated
public abstract class AsyncDataTreeChangeListenerBase<T extends DataObject, K extends DataTreeChangeListener<T>>
implements DataTreeChangeListener<T>, ChainableDataTreeChangeListener<T>, AutoCloseable {
listenerRegistration = db.registerDataTreeChangeListener(treeId, getDataTreeChangeListener());
}
- /**
+ */
+/**
* Subclasses override this and place initialization logic here, notably
* calls to registerListener(). Note that the overriding method MUST repeat
* the PostConstruct annotation, because JSR 250 specifies that lifecycle
* in a subclass without repeating the annotation, but this is wrong and not
* JSR 250 compliant, and while working in BP, then causes issues e.g. when
* wiring with Guice for tests, so do always repeat it.)
- */
+ *//*
+
@PostConstruct
protected void init() {
}
}
}
}
+*/
package org.opendaylight.genius.datastoreutils;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.serviceutils.tools.mdsal.listener.ChainableDataTreeChangeListener;
-import org.opendaylight.serviceutils.tools.mdsal.listener.ChainableDataTreeChangeListenerImpl;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.serviceutils.tools.listener.ChainableDataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.ChainableDataTreeChangeListenerImpl;
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
*/
package org.opendaylight.genius.datastoreutils;
-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.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import static java.util.Objects.requireNonNull;
import static org.opendaylight.genius.datastoreutils.TransactionCommitFailedExceptionMapper.SUBMIT_MAPPER;
-import com.google.common.base.Optional;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
/**
* Utility methods for single transaction DataBroker usage.
*
* @return If the data at the supplied path exists, returns an Optional
* object containing the data; if the data at the supplied path does
* not exist, returns Optional#absent().
- * @throws ReadFailedException in case of a technical (!) error while reading
+ *
+ * @throws ExecutionException in case of a technical (!) error while reading
+ *
+ * @throws InterruptedException in case of a technical (!) error while reading
*/
- public <T extends DataObject> Optional<T> syncReadOptional(
- LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
- throws ReadFailedException {
+ public <T extends DataObject> Optional<T> syncReadOptional(LogicalDatastoreType datastoreType,
+ InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
return syncReadOptional(broker, datastoreType, path);
}
public static <T extends DataObject> Optional<T> syncReadOptional(
DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
- throws ReadFailedException {
-
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- return tx.read(datastoreType, path).checkedGet();
+ throws ExecutionException, InterruptedException {
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
+ return tx.read(datastoreType, path).get();
}
}
public static <T extends DataObject> T syncRead(
DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
- throws ReadFailedException {
+ throws ExpectedDataObjectNotFoundException {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- Optional<T> optionalDataObject = tx.read(datastoreType, path).checkedGet();
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
+ Optional<T> optionalDataObject = tx.read(datastoreType, path).get();
if (optionalDataObject.isPresent()) {
return optionalDataObject.get();
} else {
throw new ExpectedDataObjectNotFoundException(datastoreType, path);
}
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("failed", e);
+ return null;
}
}
* purposes for code which does not yet correctly propagate
* technical exceptions. Prefer using
* {@link #syncReadOptional(DataBroker, LogicalDatastoreType, InstanceIdentifier)}.
+ *
+ * @param <T>
+ * DataObject subclass
+ * @param broker
+ * the broker
+ * @param datastoreType
+ * the {@link Datastore} type that will be accessed
+ * @param path
+ * Path which uniquely identifies subtree which client want to read
+ * @return If the data at the supplied path exists, returns the data.
+ *
*/
@Deprecated
public static <T extends DataObject> Optional<T> syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- return tx.read(datastoreType, path).checkedGet();
- } catch (ReadFailedException e) {
- LOG.error("ReadFailedException while reading data from {} store path {}; returning Optional.absent()",
- datastoreType, path, e);
- return Optional.absent();
+ try (ReadTransaction tx = broker.newReadOnlyTransaction()) {
+ return tx.read(datastoreType, path).get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("failed", e);
+ return Optional.empty();
}
}
throws TransactionCommitFailedException {
RetryingManagedNewTransactionRunner runner = new RetryingManagedNewTransactionRunner(broker, maxRetries);
- ListenableFutures.checkedGet(
- runner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.put(datastoreType, path, data, true)),
- SUBMIT_MAPPER);
+ ListenableFutures.checkedGet(runner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.put(datastoreType,path,data,true)), SUBMIT_MAPPER);
}
public <T extends DataObject> void syncUpdate(
DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data, int maxRetries)
throws TransactionCommitFailedException {
RetryingManagedNewTransactionRunner runner = new RetryingManagedNewTransactionRunner(broker, maxRetries);
- ListenableFutures.checkedGet(
- runner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(datastoreType, path, data, true)),
- SUBMIT_MAPPER);
+ ListenableFutures.checkedGet(runner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
+ tx.merge(datastoreType, path, data, true)), SUBMIT_MAPPER);
}
public <T extends DataObject> void syncDelete(
*/
package org.opendaylight.genius.datastoreutils;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
/**
*/
package org.opendaylight.genius.datastoreutils.hwvtep;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import java.util.concurrent.ExecutorService;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class HwvtepAbstractDataTreeChangeListener<T extends DataObject,K extends DataTreeChangeListener<T>>
- extends AsyncDataTreeChangeListenerBase<T,K> {
+ extends AbstractAsyncDataTreeChangeListener<T> {
private final HwvtepNodeHACache hwvtepNodeHACache;
- public HwvtepAbstractDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz,
- HwvtepNodeHACache hwvtepNodeHACache) {
- super(clazz, eventClazz);
+ public HwvtepAbstractDataTreeChangeListener(DataBroker dataBroker,DataTreeIdentifier dataTreeIdentifier,
+ ExecutorService executorService, HwvtepNodeHACache hwvtepNodeHACache) {
+ super(dataBroker, dataTreeIdentifier, executorService);
this.hwvtepNodeHACache = hwvtepNodeHACache;
}
@Override
- protected void remove(InstanceIdentifier<T> identifier, T del) {
+ public void remove(InstanceIdentifier<T> identifier, T del) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<T> identifier, T original, T update) {
+ public void update(InstanceIdentifier<T> identifier, T original, T update) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
}
@Override
- protected void add(InstanceIdentifier<T> identifier, T add) {
+ public void add(InstanceIdentifier<T> identifier, T add) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
*/
package org.opendaylight.genius.datastoreutils.hwvtep;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import java.util.concurrent.ExecutorService;
import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class HwvtepClusteredDataTreeChangeListener<
T extends DataObject, K extends ClusteredDataTreeChangeListener<T>>
- extends AsyncClusteredDataTreeChangeListenerBase<T, K> {
+ extends AbstractClusteredAsyncDataTreeChangeListener<T> {
private final HwvtepNodeHACache hwvtepNodeHACache;
- public HwvtepClusteredDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz,
- HwvtepNodeHACache hwvtepNodeHACache) {
- super(clazz, eventClazz);
+ public HwvtepClusteredDataTreeChangeListener(DataBroker dataBroker, DataTreeIdentifier dataTreeIdentifier,
+ ExecutorService executorService, HwvtepNodeHACache hwvtepNodeHACache) {
+ super(dataBroker, dataTreeIdentifier, executorService);
this.hwvtepNodeHACache = hwvtepNodeHACache;
}
@Override
- protected void remove(InstanceIdentifier<T> identifier, T del) {
+ public void remove(InstanceIdentifier<T> identifier, T del) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
}
@Override
- protected void update(InstanceIdentifier<T> identifier, T original, T update) {
+ public void update(InstanceIdentifier<T> identifier, T original, T update) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
}
@Override
- protected void add(InstanceIdentifier<T> identifier, T add) {
+ public void add(InstanceIdentifier<T> identifier, T add) {
if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
import java.util.function.Function;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Call back when expected instance was added or updated, with implicit {@link NextAction#UNREGISTER}.
* See {@link #onAddOrUpdate(LogicalDatastoreType, InstanceIdentifier, BiFunction)} for more details.
+ * @param <T>
+ * DataObject subclass
*/
default <T extends DataObject> void onAddOrUpdate(LogicalDatastoreType store, InstanceIdentifier<T> path,
BiConsumer<@Nullable T, T> callback) {
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
/**
* Strongly-typed representation of a datastore (configuration or operational).
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Future;
import java.util.function.Function;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.infrautils.utils.function.CheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
/**
* Managed transactions utility to simplify handling of new transactions and ensure they are always closed.
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.util.function.Function;
import javax.inject.Inject;
-
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction;
+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.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
/**
* Implementation of {@link ManagedNewTransactionRunner}. This is based on {@link ManagedTransactionFactoryImpl} but
* re-implements operations based on (read-)write transactions to cancel transactions which don't end up making any
@Override
public <R> R applyWithNewTransactionChainAndClose(Function<ManagedTransactionChain, R> chainConsumer) {
- try (BindingTransactionChain realTxChain = broker.createTransactionChain(new TransactionChainListener() {
+ try (TransactionChain realTxChain = broker.createTransactionChain(new TransactionChainListener() {
@Override
- public void onTransactionChainFailed(TransactionChain<?, ?> chain, AsyncTransaction<?, ?> transaction,
+ public void onTransactionChainFailed(TransactionChain chain, Transaction transaction,
Throwable cause) {
LOG.error("Error handling a transaction chain", cause);
}
@Override
- public void onTransactionChainSuccessful(TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(TransactionChain chain) {
// Nothing to do
}
})) {
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
/**
* Implementation of {@link ManagedTransactionChain}, based on {@link ManagedTransactionFactoryImpl}.
*/
class ManagedTransactionChainImpl extends ManagedTransactionFactoryImpl implements ManagedTransactionChain {
- ManagedTransactionChainImpl(BindingTransactionChain realTxChain) {
+ ManagedTransactionChainImpl(TransactionChain realTxChain) {
super(realTxChain);
}
}
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Future;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
/**
* Managed transaction factories provide managed transactions, <em>i.e.</em> transactions which are automatically
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import java.util.function.BiFunction;
import java.util.function.Supplier;
-
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.TransactionFactory;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.TransactionFactory;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(
Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
throws E, InterruptedException {
- try (ReadOnlyTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
+ try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
return txFunction.apply(wrappedTx);
}
public <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(
Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
throws E, InterruptedException {
- try (ReadOnlyTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
+ try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
txConsumer.accept(wrappedTx);
}
package org.opendaylight.genius.infra;
import com.google.common.util.concurrent.FluentFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
/**
package org.opendaylight.genius.infra;
import com.google.common.util.concurrent.FluentFuture;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
/**
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.Executor;
import javax.inject.Inject;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
/**
* Implementation of {@link ManagedNewTransactionRunner} with automatic transparent retries on transaction failure
* <h3>Details about the threading model used by this class</h3>
*
* <p>This class runs the first attempt to call the delegated {@link ManagedNewTransactionRunner},
- * which typically is a {@link ManagedNewTransactionRunnerImpl} which safely invokes {@link WriteTransaction#submit()},
+ * which typically is a {@link ManagedNewTransactionRunnerImpl} which safely invokes
+ * {@link WriteTransaction#commit()} ,
* in the using application's thread (like a {@link MoreExecutors#directExecutor()} would, if this were an
* {@link Executor}, which it's not).
*
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.function.Function;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedConsumer;
import org.opendaylight.infrautils.utils.function.InterruptibleCheckedFunction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
/**
* Implementation of {@link ManagedNewTransactionRunner} with automatic transparent retries.
return Objects.requireNonNull(delegate.callWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner),
"delegate.callWithNewWriteOnlyTransactionAndSubmit() == null")
.catchingAsync(Exception.class, exception -> {
- // as per AsyncWriteTransaction.submit()'s JavaDoc re. retries
+ // as per AsyncWriteTransaction.commit()'s JavaDoc re. retries
if (isRetriableException(exception) && tries - 1 > 0) {
return callWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner, tries - 1);
} else {
delegate.callWithNewWriteOnlyTransactionAndSubmit(txRunner),
"delegate.callWithNewWriteOnlyTransactionAndSubmit() == null");
return Futures.catchingAsync(future, OptimisticLockFailedException.class, optimisticLockFailedException -> {
- // as per AsyncWriteTransaction.submit()'s JavaDoc re. retries
+ // as per AsyncWriteTransaction.commit()'s JavaDoc re. retries
if (tries - 1 > 0) {
return callWithNewWriteOnlyTransactionAndSubmit(txRunner, tries - 1);
} else {
return Objects.requireNonNull(delegate.callWithNewWriteOnlyTransactionAndSubmit(datastoreType, txRunner),
"delegate.callWithNewWriteOnlyTransactionAndSubmit() == null")
.catchingAsync(OptimisticLockFailedException.class, optimisticLockFailedException -> {
- // as per AsyncWriteTransaction.submit()'s JavaDoc re. retries
+ // as per AsyncWriteTransaction.commit()'s JavaDoc re. retries
if (tries - 1 > 0) {
return callWithNewWriteOnlyTransactionAndSubmit(datastoreType, txRunner, tries - 1);
} else {
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.genius.infra;
-
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+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;
/**
* Adapter allowing managed, datastore-constrained transactions to be used with methods expecting
- * generic {@link org.opendaylight.controller.md.sal.binding.api.DataBroker} transactions.
+ * generic {@link org.opendaylight.mdsal.binding.api.DataBroker} transactions.
*
* <p>The adapted transactions maintain the following constraints: they cannot be cancelled or
* submitted (only the transaction manager can do this), and they cannot access a logical datastore
@Deprecated
public final class TransactionAdapter {
private TransactionAdapter() {
+
}
/**
if (datastoreTx instanceof TypedReadWriteTransactionImpl) {
TypedReadWriteTransactionImpl nonSubmitCancelableDatastoreReadWriteTransaction =
(TypedReadWriteTransactionImpl) datastoreTx;
- return new ReadWriteTransactionAdapter(nonSubmitCancelableDatastoreReadWriteTransaction.datastoreType,
- nonSubmitCancelableDatastoreReadWriteTransaction);
+ return new ReadWriteTransactionAdapter(nonSubmitCancelableDatastoreReadWriteTransaction
+ .datastoreType, nonSubmitCancelableDatastoreReadWriteTransaction);
}
throw new IllegalArgumentException(
"Unsupported TypedWriteTransaction implementation " + datastoreTx.getClass());
final LogicalDatastoreType datastoreType;
final TypedWriteTransaction<D> delegate;
- private WriteTransactionAdapter(LogicalDatastoreType datastoreType, TypedWriteTransaction<D> delegate) {
+ private WriteTransactionAdapter(LogicalDatastoreType datastoreType,
+ TypedWriteTransaction<D> delegate) {
this.datastoreType = datastoreType;
this.delegate = delegate;
}
@Override
- public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
+ public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path,
+ T data) {
checkStore(store);
delegate.put(path, data);
}
@Override
public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
+ boolean createMissingParents) {
checkStore(store);
delegate.put(path, data, createMissingParents);
}
@Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
+ public <T extends DataObject> void mergeParentStructurePut(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<T> path,
+ @NonNull T data) {
+ /////
+ }
+
+ @Override
+ public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path,
+ T data) {
checkStore(store);
delegate.merge(path, data);
}
@Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
+ public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path,
+ T data,
+ boolean createMissingParents) {
checkStore(store);
delegate.merge(path, data, createMissingParents);
}
+ @Override
+ public <T extends DataObject> void mergeParentStructureMerge(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<T> path,
+ @NonNull T data) {
+ //////
+ }
+
@Override
public boolean cancel() {
throw new UnsupportedOperationException("Managed transactions mustn't be cancelled");
}
void checkStore(LogicalDatastoreType store) {
- Preconditions.checkArgument(datastoreType.equals(store), "Invalid datastore %s used instead of %s", store,
- datastoreType);
+ Preconditions.checkArgument(datastoreType.equals(store), "Invalid "
+ + "datastore %s used instead of %s", store, datastoreType);
}
@Override
}
}
- private static final class ReadWriteTransactionAdapter<D extends Datastore> extends WriteTransactionAdapter<D>
+ private static final class ReadWriteTransactionAdapter<D extends Datastore> extends
+ WriteTransactionAdapter<D>
implements ReadWriteTransaction {
private final TypedReadWriteTransaction<D> delegate;
- private ReadWriteTransactionAdapter(LogicalDatastoreType datastoreType, TypedReadWriteTransaction<D> delegate) {
+ private ReadWriteTransactionAdapter(LogicalDatastoreType datastoreType,
+ TypedReadWriteTransaction<D> delegate) {
super(datastoreType, delegate);
this.delegate = delegate;
}
@Override
- public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(LogicalDatastoreType store,
+ public @NonNull <T extends DataObject> FluentFuture<Optional<T>> read(@NonNull LogicalDatastoreType
+ store,@NonNull
InstanceIdentifier<T> path) {
checkStore(store);
- return Futures.makeChecked(delegate.read(path),
- e -> new ReadFailedException("Error reading from the datastore", e));
+ return FluentFuture.from(delegate.read(path));
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
- InstanceIdentifier<?> path) {
+ public FluentFuture<Boolean> exists(LogicalDatastoreType store, InstanceIdentifier<?> path) {
checkStore(store);
- return Futures.makeChecked(delegate.exists(path),
- e -> new ReadFailedException("Error reading from the datastore", e));
+ return FluentFuture.from(delegate.exists(path));
}
}
}
*/
package org.opendaylight.genius.infra;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
/**
* Read transaction which is specific to a single logical datastore (configuration or operational). Designed for use
* with {@link ManagedNewTransactionRunner} (it doesn’t support explicit cancel or commit operations).
* @param <D> The logical datastore handled by the transaction.
*/
public interface TypedReadTransaction<D extends Datastore>
- extends AsyncTransaction<InstanceIdentifier<?>, DataObject> {
+ extends Transaction {
/**
* Reads an object from the given path.
*
*/
package org.opendaylight.genius.infra;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* for use with {@link ManagedNewTransactionRunner} (it doesn’t support explicit cancel or commit operations).
*
* @param <D> The logical datastore handled by the transaction.
- * @see org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction
+ * @see org.opendaylight.mdsal.binding.api.ReadWriteTransaction
*/
public interface TypedReadWriteTransaction<D extends Datastore>
extends TypedReadTransaction<D>, TypedWriteTransaction<D> {
*/
package org.opendaylight.genius.infra;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
abstract class TypedTransaction<D extends Datastore> {
// Temporarily package protected for TransactionAdapter
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* @see WriteTransaction
*/
public interface TypedWriteTransaction<D extends Datastore> extends
- AsyncTransaction<InstanceIdentifier<?>, DataObject> {
+ Transaction {
/**
* Writes an object to the given path.
*
package org.opendaylight.genius.infra;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.infra;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(LogicalDatastoreType store,
+ public <T extends DataObject> FluentFuture<Optional<T>> read(LogicalDatastoreType store,
InstanceIdentifier<T> path) {
return ((ReadWriteTransaction) delegate()).read(store, path);
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
- InstanceIdentifier<?> path) {
+ public FluentFuture<Boolean> exists(LogicalDatastoreType store, InstanceIdentifier<?> path) {
return ((ReadWriteTransaction) delegate()).exists(store, path);
}
}
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.infra;
-import org.opendaylight.controller.md.sal.binding.api.ForwardingWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.spi.ForwardingWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.genius.mdsalutil;
-import com.google.common.base.Optional;
import com.google.common.net.InetAddresses;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-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.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.actions.ActionDrop;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
*/
@Deprecated
public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
- try {
- return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, path);
- } catch (ReadFailedException e) {
- throw new RuntimeException(e);
- }
+ InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
+ return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, path);
}
/**
ncId.getValue().lastIndexOf(':')));
}
- public static String getInterfaceName(NodeConnectorRef ref, DataBroker dataBroker) {
+ public static String getInterfaceName(NodeConnectorRef ref, DataBroker dataBroker)
+ throws ExecutionException, InterruptedException {
NodeConnectorId nodeConnectorId = getNodeConnectorId(dataBroker, ref);
NodeId nodeId = getNodeIdFromNodeConnectorId(nodeConnectorId);
InstanceIdentifier<NodeConnector> ncIdentifier = InstanceIdentifier
.child(Node.class, new NodeKey(nodeId))
.child(NodeConnector.class,
new NodeConnectorKey(nodeConnectorId)).build();
- return read(dataBroker, LogicalDatastoreType.OPERATIONAL, ncIdentifier).toJavaUtil().map(
+ return read(dataBroker, LogicalDatastoreType.OPERATIONAL, ncIdentifier).map(
nc -> nc.augmentation(FlowCapableNodeConnector.class)).map(FlowCapableNodeConnector::getName).orElse(
null);
}
public static NodeConnectorId getNodeConnectorId(DataBroker dataBroker,
- NodeConnectorRef ref) {
+ NodeConnectorRef ref) throws ExecutionException, InterruptedException {
return ((Optional<NodeConnector>) read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- ref.getValue())).toJavaUtil().map(NodeConnector::getId).orElse(null);
+ ref.getValue())).map(NodeConnector::getId).orElse(null);
}
public static Action createNxOfInPortAction(final int actionKey, final int inPortVal) {
*/
package org.opendaylight.genius.mdsalutil;
-import com.google.common.base.Optional;
import com.google.common.net.InetAddresses;
import com.google.common.primitives.Ints;
import com.google.common.primitives.UnsignedBytes;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import org.apache.commons.net.util.SubnetUtils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
/**
* Returns the ids of the currently operative DPNs.
*/
- public static List<Uint64> getOperativeDPNs(DataBroker dataBroker) {
+ public static List<Uint64> getOperativeDPNs(DataBroker dataBroker) throws ExecutionException, InterruptedException {
List<Uint64> result = new LinkedList<>();
InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
- Optional<Nodes> nodesOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- nodesInstanceIdentifier);
+ Optional<Nodes> nodesOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, nodesInstanceIdentifier);
if (!nodesOptional.isPresent()) {
return result;
}
package org.opendaylight.genius.mdsalutil.actions;
import java.util.Collections;
-
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.GroupingLooseResolver;
package org.opendaylight.genius.mdsalutil.actions;
import java.util.Collections;
-
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
import org.opendaylight.openflowplugin.extension.api.GroupingLooseResolver;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BiFunction;
import java.util.stream.Stream;
import javax.annotation.PreDestroy;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-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.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.infrautils.caches.CacheProvider;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
requireNonNull(cacheProvider, "cacheProvider");
cache = CacheBuilder.newBuilder().build(new CacheLoader<K, Optional<V>>() {
@Override
- public Optional<V> load(K key) throws ReadFailedException {
+ public Optional<V> load(K key) throws ReadFailedException, ExecutionException, InterruptedException {
return broker.syncReadOptional(datastoreType, instanceIdFunction.apply(key));
}
});
case WRITE:
case SUBTREE_MODIFIED:
V dataAfter = rootNode.getDataAfter();
- cache.put(keyFunction.apply(path, dataAfter), Optional.fromNullable(dataAfter));
+ cache.put(keyFunction.apply(path, dataAfter), Optional.ofNullable(dataAfter));
added(path, dataAfter);
break;
case DELETE:
}
};
- listenerRegistration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(
+ listenerRegistration = dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(
datastoreType, listenerRegistrationPath), dataObjectListener);
}
*/
package org.opendaylight.genius.mdsalutil.cache;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.genius.utils.SuperTypeUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
*/
package org.opendaylight.genius.mdsalutil.interfaces;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
* @deprecated Use {@link #addFlow(TypedWriteTransaction, FlowEntity)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> installFlow(FlowEntity flowEntity);
+ FluentFuture<Void> installFlow(FlowEntity flowEntity);
/**
* Adds a flow.
* @deprecated Use {@link #addFlow(TypedWriteTransaction, Uint64, Flow)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> installFlow(Uint64 dpId, Flow flowEntity);
+ FluentFuture<Void> installFlow(Uint64 dpId, Flow flowEntity);
/**
* Adds a flow.
* @deprecated Use {@link #addFlow(TypedWriteTransaction, FlowEntity)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> installFlow(Uint64 dpId, FlowEntity flowEntity);
+ FluentFuture<Void> installFlow(Uint64 dpId, FlowEntity flowEntity);
/**
* Adds the given flow.
* @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, FlowEntity)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> removeFlow(FlowEntity flowEntity);
+ FluentFuture<Void> removeFlow(FlowEntity flowEntity);
/**
* Removes a flow.
* @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, Uint64, Flow)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> removeFlow(Uint64 dpId, Flow flowEntity);
+ FluentFuture<Void> removeFlow(Uint64 dpId, Flow flowEntity);
/**
* Removes the given flow.
import com.google.common.collect.ImmutableBiMap;
import java.util.Map;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg5;
short UPDATE = 2;
short DELETE = 3;
short READ = 4;
+ // MDSAL-534 Merge,Put with no create_missing_parents flag
+ short UPDATECONTAINER = 5;
InstanceIdentifier<?> getInstanceIdentifier();
final InstanceIdentifier<T> path, final T data) {
return new ActionableResourceImpl(identifier, path, ActionableResource.DELETE, data, null);
}
+
+ public static <T extends DataObject> @NonNull ActionableResource updateContainer(final
+ InstanceIdentifier<T> path, final T newData) {
+ return new ActionableResourceImpl(path, ActionableResource.UPDATECONTAINER, requireNonNull(newData),
+ null);
+ }
}
package org.opendaylight.genius.utils.batching;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
tx.merge(logicalDatastoreType, identifier, (DataObject) update, true);
}
+ @Override
+ public void updateContainer(WriteTransaction tx, LogicalDatastoreType logicalDatastoreType,
+ InstanceIdentifier identifier, Object original, Object update,
+ List<SubTransaction> transactionObjects) {
+ if (update != null && !(update instanceof DataObject)) {
+ return;
+ }
+ if (logicalDatastoreType != getDatastoreType()) {
+ return;
+ }
+
+ SubTransaction subTransaction = new SubTransactionImpl();
+ subTransaction.setAction(SubTransaction.UPDATE);
+ subTransaction.setInstance(update);
+ subTransaction.setInstanceIdentifier(identifier);
+ transactionObjects.add(subTransaction);
+
+ tx.merge(logicalDatastoreType, identifier, (DataObject) update);
+ }
+
@Override
public void create(WriteTransaction tx, final LogicalDatastoreType logicalDatastoreType,
final InstanceIdentifier identifier, final Object data, List<SubTransaction> transactionObjects) {
*/
package org.opendaylight.genius.utils.batching;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+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 java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+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.common.api.ReadFailedException;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
* @param identifier identifier to be read
* @return a CheckFuture containing the result of the read
*/
- public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(
+ public <T extends DataObject> FluentFuture<Optional<T>> read(
String resourceType, InstanceIdentifier<T> identifier) {
BlockingQueue<ActionableResource> queue = getQueue(resourceType);
if (queue != null) {
if (pendingModificationByResourceType.get(resourceType).contains(identifier)) {
SettableFuture<Optional<T>> readFuture = SettableFuture.create();
queue.add(new ActionableReadResource<>(identifier, readFuture));
- return Futures.makeChecked(readFuture, ReadFailedException.MAPPER);
+ return FluentFuture.from(Futures.makeChecked(readFuture, ReadFailedException.MAPPER));
} else {
ResourceHandler resourceHandler = resourceHandlerMapper.get(resourceType).getRight();
- try (ReadOnlyTransaction tx = resourceHandler.getResourceBroker().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = resourceHandler.getResourceBroker().newReadOnlyTransaction()) {
return tx.read(resourceHandler.getDatastoreType(), identifier);
}
}
}
- return Futures.immediateFailedCheckedFuture(new ReadFailedException(
+
+ return FluentFutures.immediateFailedFluentFuture(new ReadFailedException(
"No batch handler was registered for resource " + resourceType));
}
resHandler.update(tx, dsType, actResource.getInstanceIdentifier(), original,
updated,transactionObjects);
break;
+ case ActionableResource.UPDATECONTAINER:
+ Object updatedContainer = actResource.getInstance();
+ Object originalContainer = actResource.getOldInstance();
+ resHandler.updateContainer(tx, dsType, actResource.getInstanceIdentifier(),
+ originalContainer, updatedContainer,transactionObjects);
+ break;
case ActionableResource.DELETE:
resHandler.delete(tx, dsType, actResource.getInstanceIdentifier(), actResource.getInstance(),
transactionObjects);
}
}
+
long start = System.currentTimeMillis();
- ListenableFuture<Void> futures = tx.submit();
+ FluentFuture<? extends @NonNull CommitInfo> futures = tx.commit();
try {
futures.get();
LOG.error("Unable to determine Action for transaction object with id {}",
object.getInstanceIdentifier());
}
- ListenableFuture<Void> futureOperation = writeTransaction.submit();
+ FluentFuture<? extends @NonNull CommitInfo> futureOperation = writeTransaction.commit();
try {
futureOperation.get();
if (txMap.containsKey(object)) {
package org.opendaylight.genius.utils.batching;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public interface ResourceHandler {
void delete(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifer, Object vrfEntry,
List<SubTransaction> transactionObjects);
- void update(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier, Object original,
- Object update, List<SubTransaction> transactionObjects);
+ void update(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
+ Object original, Object update, List<SubTransaction> transactionObjects);
+
+ void updateContainer(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
+ Object original, Object update, List<SubTransaction> transactionObjects);
LogicalDatastoreType getDatastoreType();
package org.opendaylight.genius.utils.hwvtep;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.StreamSupport;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.IetfYangUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
* @deprecated Use {@link #addLogicalSwitch(TypedWriteTransaction, NodeId, LogicalSwitches)}.
*/
@Deprecated
- public static ListenableFuture<Void> addLogicalSwitch(DataBroker broker, NodeId nodeId,
- LogicalSwitches logicalSwitch) {
+ public static FluentFuture<? extends @NonNull CommitInfo> addLogicalSwitch(DataBroker broker, NodeId nodeId,
+ LogicalSwitches logicalSwitch) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
putLogicalSwitch(transaction,LogicalDatastoreType.CONFIGURATION, nodeId, logicalSwitch);
- return transaction.submit();
+ return transaction.commit();
}
@Deprecated
- public static ListenableFuture<Void> addLogicalSwitch(DataBroker broker, LogicalDatastoreType logicalDatastoreType,
+ public static FluentFuture<? extends @NonNull CommitInfo> addLogicalSwitch(DataBroker broker,
+ LogicalDatastoreType logicalDatastoreType,
NodeId nodeId,
LogicalSwitches logicalSwitch) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
putLogicalSwitch(transaction,logicalDatastoreType, nodeId, logicalSwitch);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @deprecated Use {@link #deleteLogicalSwitch(TypedWriteTransaction, NodeId, String)}.
*/
@Deprecated
- public static ListenableFuture<Void> deleteLogicalSwitch(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> deleteLogicalSwitch(DataBroker broker, NodeId nodeId,
String logicalSwitchName) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
deleteLogicalSwitch(transaction, nodeId, logicalSwitchName);
- return transaction.submit();
+ return transaction.commit();
}
/**
*/
@Deprecated
public static LogicalSwitches getLogicalSwitch(DataBroker broker, LogicalDatastoreType datastoreType, NodeId nodeId,
- String logicalSwitchName) {
+ String logicalSwitchName) throws ExecutionException, InterruptedException {
final InstanceIdentifier<LogicalSwitches> iid = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
- return MDSALUtil.read(broker, datastoreType, iid).orNull();
+ return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, iid).orElse(null);
}
/**
final InstanceIdentifier<LogicalSwitches> iid = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
try {
- return tx.read(iid).get().orNull();
+ return tx.read(iid).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException("Error reading logical switch " + iid, e);
}
* @return the physical port termination point
*/
public static TerminationPoint getPhysicalPortTerminationPoint(DataBroker broker,
- LogicalDatastoreType datastoreType, NodeId nodeId, String portName) {
+ LogicalDatastoreType datastoreType, NodeId nodeId, String portName) throws ExecutionException,
+ InterruptedException {
TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
InstanceIdentifier<TerminationPoint> iid = HwvtepSouthboundUtils.createTerminationPointId(nodeId, tpKey);
- return MDSALUtil.read(broker, datastoreType, iid).orNull();
+ return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, iid).orElse(null);
}
/**
* virtual network id
* @return the logical switches
*/
- public static LogicalSwitches getLogicalSwitches(DataBroker broker, String hwVtepNodeId, String vni) {
+ public static LogicalSwitches getLogicalSwitches(DataBroker broker, String hwVtepNodeId, String vni)
+ throws ExecutionException, InterruptedException {
NodeId nodeId = new NodeId(hwVtepNodeId);
InstanceIdentifier<LogicalSwitches> logicalSwitchesIdentifier = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(vni));
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, logicalSwitchesIdentifier).orNull();
+ return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION,
+ logicalSwitchesIdentifier).orElse(null);
}
/**
* @return the physical locator
*/
public static HwvtepPhysicalLocatorAugmentation getPhysicalLocator(DataBroker broker,
- LogicalDatastoreType datastoreType, NodeId nodeId, final IpAddress phyLocatorIp) {
+ LogicalDatastoreType datastoreType, NodeId nodeId, final IpAddress phyLocatorIp) throws
+ ExecutionException, InterruptedException {
HwvtepPhysicalLocatorAugmentation phyLocatorAug = HwvtepSouthboundUtils
.createHwvtepPhysicalLocatorAugmentation(phyLocatorIp);
InstanceIdentifier<HwvtepPhysicalLocatorAugmentation> iid = HwvtepSouthboundUtils
.createPhysicalLocatorInstanceIdentifier(nodeId, phyLocatorAug)
.augmentation(HwvtepPhysicalLocatorAugmentation.class);
- return MDSALUtil.read(broker, datastoreType, iid).orNull();
+ return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, iid).orElse(null);
}
/**
* @deprecated Use {@link #addRemoteUcastMacs(TypedWriteTransaction, NodeId, Iterable)}.
*/
@Deprecated
- public static ListenableFuture<Void> addRemoteUcastMacs(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> addRemoteUcastMacs(DataBroker broker, NodeId nodeId,
List<RemoteUcastMacs> lstRemoteUcastMacs) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
putRemoteUcastMacs(transaction, nodeId, lstRemoteUcastMacs);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @deprecated Use {@link #deleteRemoteUcastMac(TypedWriteTransaction, NodeId, String, MacAddress)}.
*/
@Deprecated
- public static ListenableFuture<Void> deleteRemoteUcastMac(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> deleteRemoteUcastMac(DataBroker broker, NodeId nodeId,
String logicalSwitchName, MacAddress mac) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
deleteRemoteUcastMac(transaction, nodeId, logicalSwitchName, mac);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @deprecated Use {@link #deleteRemoteUcastMacs(TypedWriteTransaction, NodeId, String, Iterable)}.
*/
@Deprecated
- public static ListenableFuture<Void> deleteRemoteUcastMacs(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> deleteRemoteUcastMacs(DataBroker broker, NodeId nodeId,
String logicalSwitchName, List<MacAddress> lstMac) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
deleteRemoteUcastMacs(transaction, nodeId, logicalSwitchName, lstMac);
- return transaction.submit();
+ return transaction.commit();
}
/**
* the lst remote mcast macs
* @return the listenable future
*/
- public static ListenableFuture<Void> addRemoteMcastMacs(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> addRemoteMcastMacs(DataBroker broker, NodeId nodeId,
List<RemoteMcastMacs> lstRemoteMcastMacs) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
putRemoteMcastMacs(transaction, nodeId, lstRemoteMcastMacs);
- return transaction.submit();
+ return transaction.commit();
}
/**
*/
@Deprecated
public static RemoteMcastMacs getRemoteMcastMac(DataBroker broker, LogicalDatastoreType datastoreType,
- NodeId nodeId, RemoteMcastMacsKey remoteMcastMacsKey) {
+ NodeId nodeId, RemoteMcastMacsKey remoteMcastMacsKey)
+ throws ExecutionException, InterruptedException {
final InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils
.createRemoteMcastMacsInstanceIdentifier(nodeId, remoteMcastMacsKey);
- return MDSALUtil.read(broker, datastoreType, iid).orNull();
+ return SingleTransactionDataBroker.syncReadOptional(broker, datastoreType, iid).orElse(null);
}
/**
final InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils
.createRemoteMcastMacsInstanceIdentifier(nodeId, remoteMcastMacsKey);
try {
- return tx.read(iid).get().orNull();
+ return tx.read(iid).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException("Error reading remote multicast MAC " + iid, e);
}
* @deprecated Use {@link #deleteRemoteMcastMac(TypedWriteTransaction, NodeId, RemoteMcastMacsKey)}.
*/
@Deprecated
- public static ListenableFuture<Void> deleteRemoteMcastMac(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> deleteRemoteMcastMac(DataBroker broker, NodeId nodeId,
RemoteMcastMacsKey remoteMcastMacsKey) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
deleteRemoteMcastMac(transaction, nodeId, remoteMcastMacsKey);
- return transaction.submit();
+ return transaction.commit();
}
/**
* the lst remote mcast macs key
* @return the listenable future
*/
- public static ListenableFuture<Void> deleteRemoteMcastMacs(DataBroker broker, NodeId nodeId,
+ public static FluentFuture<? extends @NonNull CommitInfo> deleteRemoteMcastMacs(DataBroker broker, NodeId nodeId,
List<RemoteMcastMacsKey> lstRemoteMcastMacsKey) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
deleteRemoteMcastMacs(transaction, nodeId, lstRemoteMcastMacsKey);
- return transaction.submit();
+ return transaction.commit();
}
/**
* @deprecated Use {@link #getHwVtepNode(TypedReadTransaction, NodeId)}.
*/
@Deprecated
- public static Node getHwVtepNode(DataBroker dataBroker, LogicalDatastoreType datastoreType, NodeId nodeId) {
- return MDSALUtil.read(dataBroker, datastoreType,
- HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)).orNull();
+ public static Node getHwVtepNode(DataBroker dataBroker, LogicalDatastoreType datastoreType, NodeId nodeId)
+ throws ExecutionException, InterruptedException {
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, datastoreType,
+ HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)).orElse(null);
}
/**
*/
public static Node getHwVtepNode(TypedReadTransaction<? extends Datastore> tx, NodeId nodeId) {
try {
- return tx.read(HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)).get().orNull();
+ return tx.read(HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException("Failed to read hwvtep node", e);
}
* @deprecated Use {@link #addUcastMacs(TypedWriteTransaction, String, Iterable, String, IpAddress)}.
*/
@Deprecated
- public static ListenableFuture<Void> installUcastMacs(DataBroker broker,
+ public static FluentFuture<? extends @NonNull CommitInfo> installUcastMacs(DataBroker broker,
String deviceNodeId, List<PhysAddress> macAddresses,
String logicalSwitchName, IpAddress remoteVtepIp) {
NodeId nodeId = new NodeId(deviceNodeId);
* @deprecated Use {@link #getDbVersion(TypedReadTransaction, NodeId)}.
*/
@Deprecated
- public static String getDbVersion(DataBroker broker, NodeId nodeId) {
+ public static String getDbVersion(DataBroker broker, NodeId nodeId) throws ExecutionException,
+ InterruptedException {
Node hwvtepNode = getHwVtepNode(broker, LogicalDatastoreType.OPERATIONAL, nodeId);
String dbVersion = "";
if (hwvtepNode != null) {
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Objects;
import org.junit.ComparisonFailure;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(FlowEntity flowEntity) {
+ public FluentFuture<Void> installFlow(FlowEntity flowEntity) {
storeFlow(flowEntity);
- return Futures.immediateCheckedFuture(null);
+ return FluentFutures.immediateNullFluentFuture();
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId,
- FlowEntity flowEntity) {
+ public FluentFuture<Void> installFlow(Uint64 dpId, FlowEntity flowEntity) {
// TODO should dpId be considered here? how? Copy clone FlowEntity and change its dpId?
return installFlow(flowEntity);
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+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.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.BucketInfo;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldVlanVid;
import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteActions;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
writeTx.put(LogicalDatastoreType.OPERATIONAL, flowNodeIdentifier, nodeBuilder.build());
writeTx.put(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class), nodes);
writeTx.put(LogicalDatastoreType.CONFIGURATION, flowNodeIdentifier, nodeBuilder.build());
- assertCommit(writeTx.submit());
+ assertCommit(writeTx.commit());
}
// Methods to test the install Flow and Group
<name>ODL :: genius :: ${project.artifactId}</name>
<dependencies>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
- </dependency>
+ </dependency>!-->
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-base</artifactId>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-testutils</artifactId>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>test</scope>
<type>test-jar</type>
+ </dependency>!-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>test</scope>
+ <type>test-jar</type>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.apache.aries.blueprint.annotation.service.Service;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.infrautils.utils.concurrent.Executors;
+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.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private <T extends DataObject> void on(Operation op, LogicalDatastoreType store, InstanceIdentifier<T> path,
BiFunction<T, T, NextAction> cb, Duration timeoutDuration,
@Nullable Consumer<DataTreeIdentifier<T>> timedOutCallback) {
- DataTreeIdentifier<T> dtid = new DataTreeIdentifier<>(store, path);
+ DataTreeIdentifier<T> dtid = DataTreeIdentifier.create(store, path);
DataTreeEventCallbackChangeListener<T> listener = new DataTreeEventCallbackChangeListener<>(op, cb, () -> {
if (timedOutCallback != null) {
timedOutCallback.accept(dtid);
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardStatsMXBean;
import org.opendaylight.controller.cluster.datastore.shardmanager.ShardManagerInfoMBean;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.infrautils.diagstatus.DiagStatusService;
import org.opendaylight.infrautils.diagstatus.MBeanUtils;
import org.opendaylight.infrautils.diagstatus.ServiceDescriptor;
import org.opendaylight.infrautils.diagstatus.ServiceState;
import org.opendaylight.infrautils.diagstatus.ServiceStatusProvider;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.opendaylight.genius.mdsalutil.internal;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.infrautils.utils.concurrent.Executors.newListeningSingleThreadExecutor;
+import static org.opendaylight.mdsal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
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.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
int batchInterval = Integer.getInteger("batch.wait.time", 500);
flowBatchingUtils.registerWithBatchManager(new MdSalUtilBatchHandler(dataBroker, batchSize, batchInterval));
- flowListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
- flowConfigListener.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
- groupListener.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
}
@Override
}
}
- private class GroupListener extends AsyncClusteredDataTreeChangeListenerBase<Group, GroupListener> {
+ private class GroupListener extends AbstractClusteredAsyncDataTreeChangeListener<Group> {
GroupListener() {
- super(Group.class, GroupListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class).child(Group.class),
+ Executors.newSingleThreadExecutor("GroupListener", LOG));
}
@Override
- protected void remove(InstanceIdentifier<Group> identifier, Group del) {
+ public void remove(InstanceIdentifier<Group> identifier, Group del) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, del);
}
}
@Override
- protected void update(InstanceIdentifier<Group> identifier, Group original, Group update) {
+ public void update(InstanceIdentifier<Group> identifier, Group original, Group update) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, update);
}
@Override
- protected void add(InstanceIdentifier<Group> identifier, Group add) {
+ public void add(InstanceIdentifier<Group> identifier, Group add) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, add);
}
-
- @Override
- protected InstanceIdentifier<Group> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class)
- .child(Group.class);
- }
-
- @Override
- protected GroupListener getDataTreeChangeListener() {
- return GroupListener.this;
- }
}
- private class FlowListener extends AsyncClusteredDataTreeChangeListenerBase<Flow, FlowListener> {
+ private class FlowListener extends AbstractClusteredAsyncDataTreeChangeListener<Flow> {
FlowListener() {
- super(Flow.class, FlowListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class).child(Table.class).child(Flow.class),
+ Executors.newSingleThreadExecutor("FlowListener", LOG));
}
@Override
- protected void remove(InstanceIdentifier<Flow> identifier, Flow del) {
+ public void remove(InstanceIdentifier<Flow> identifier, Flow del) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
notifyTaskIfRequired(dpId, del);
}
}
@Override
- protected void update(InstanceIdentifier<Flow> identifier, Flow original, Flow update) {
+ public void update(InstanceIdentifier<Flow> identifier, Flow original, Flow update) {
}
@Override
- protected void add(InstanceIdentifier<Flow> identifier, Flow add) {
+ public void add(InstanceIdentifier<Flow> identifier, Flow add) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
notifyTaskIfRequired(dpId, add);
}
- @Override
- protected InstanceIdentifier<Flow> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class)
- .child(Table.class).child(Flow.class);
- }
-
- @Override
- protected FlowListener getDataTreeChangeListener() {
- return FlowListener.this;
- }
}
- private class FlowConfigListener extends AsyncClusteredDataTreeChangeListenerBase<Flow, FlowConfigListener> {
+ private class FlowConfigListener extends AbstractClusteredAsyncDataTreeChangeListener<Flow> {
private final Logger flowLog = LoggerFactory.getLogger(FlowConfigListener.class);
FlowConfigListener() {
- super(Flow.class, FlowConfigListener.class);
+ super(dataBroker, LogicalDatastoreType.OPERATIONAL,InstanceIdentifier.create(Nodes.class).child(Node.class)
+ .augmentation(FlowCapableNode.class).child(Table.class).child(Flow.class),
+ Executors.newSingleThreadExecutor("FlowConfigListener", LOG));
}
@Override
- protected void remove(InstanceIdentifier<Flow> identifier, Flow del) {
+ public void remove(InstanceIdentifier<Flow> identifier, Flow del) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
flowLog.trace("FlowId {} deleted from Table {} on DPN {}",
del.getId().getValue(), del.getTableId(), dpId);
}
@Override
- protected void update(InstanceIdentifier<Flow> identifier, Flow original, Flow update) {
+ public void update(InstanceIdentifier<Flow> identifier, Flow original, Flow update) {
}
@Override
- protected void add(InstanceIdentifier<Flow> identifier, Flow add) {
+ public void add(InstanceIdentifier<Flow> identifier, Flow add) {
Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
flowLog.debug("FlowId {} added to Table {} on DPN {}",
add.getId().getValue(), add.getTableId(), dpId);
}
-
- @Override
- protected InstanceIdentifier<Flow> getWildCardPath() {
- return InstanceIdentifier.create(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class)
- .child(Table.class).child(Flow.class);
- }
-
- @Override
- protected FlowConfigListener getDataTreeChangeListener() {
- return FlowConfigListener.this;
- }
}
@SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(FlowEntity flowEntity) {
- return Futures.makeChecked(installFlowInternal(flowEntity),
- t -> new TransactionCommitFailedException("installFlow failed", t));
+ public FluentFuture<Void> installFlow(FlowEntity flowEntity) {
+ return installFlowInternal(flowEntity);
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId, Flow flowEntity) {
- return Futures.makeChecked(installFlowInternal(dpId, flowEntity),
- t -> new TransactionCommitFailedException("installFlow failed", t));
+ public FluentFuture<Void> installFlow(Uint64 dpId, Flow flowEntity) {
+ return installFlowInternal(dpId, flowEntity);
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId, FlowEntity flowEntity) {
- return Futures.makeChecked(installFlowInternal(dpId, flowEntity.getFlowBuilder().build()),
- t -> new TransactionCommitFailedException("installFlow failed", t));
+ public FluentFuture<Void> installFlow(Uint64 dpId, FlowEntity flowEntity) {
+ return installFlowInternal(dpId, flowEntity.getFlowBuilder().build());
}
@Override
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> removeFlow(Uint64 dpId, Flow flowEntity) {
- return Futures.makeChecked(removeFlowNewInternal(dpId, flowEntity),
- t -> new TransactionCommitFailedException("removeFlow failed", t));
+ public FluentFuture<Void> removeFlow(Uint64 dpId, Flow flowEntity) {
+ return removeFlowNewInternal(dpId, flowEntity);
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> removeFlow(FlowEntity flowEntity) {
- return Futures.makeChecked(removeFlowInternal(flowEntity),
- t -> new TransactionCommitFailedException("removeFlow failed", t));
+ public FluentFuture<Void> removeFlow(FlowEntity flowEntity) {
+ return removeFlowInternal(flowEntity);
}
@Override
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupId, nodeDpn);
try {
return singleTxDb.syncReadOptional(LogicalDatastoreType.CONFIGURATION, groupInstanceId).isPresent();
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.warn("Exception while reading group {} for Node {}", groupId, nodeDpn.key());
}
return false;
Optional<Flow> flowOptional = singleTxDb.syncReadOptional(LogicalDatastoreType.CONFIGURATION,
flowInstanceId);
return flowOptional.isPresent();
- } catch (ReadFailedException e) {
+ } catch (ExecutionException | InterruptedException e) {
LOG.warn("Exception while reading flow {} for dpn {}", flowKey, dpId);
}
return false;
package org.opendaylight.genius.mdsalutil.internal;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.utils.batching.ResourceHandler;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.genius.utils.batching.SubTransactionImpl;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
buildSubTransactions(transactionObjects, identifier, update, SubTransaction.UPDATE);
}
+ @Override
+ public void updateContainer(WriteTransaction tx, LogicalDatastoreType datastoreType,
+ InstanceIdentifier identifier, Object original, Object update,
+ List<SubTransaction> transactionObjects) {
+ ///no-op
+ }
+
@Override
public void create(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
Object data, List<SubTransaction> transactionObjects) {
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.USES_ONE_KEY;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.complexUsesAugment;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.path;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.topLevelList;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListeningScheduledExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.Uninterruptibles;
import java.time.Duration;
-import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.test.ConstantSchemaAbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar.NextAction;
import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.TwoLevelList;
+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.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public DataTreeEventCallbackRegistrarTest() throws Exception {
// Argument true to make sure we use the multi-threaded DataTreeChangeListenerExecutor
// because otherwise we hit a deadlock :( with this test!
- ConstantSchemaAbstractDataBrokerTest dataBrokerTest = new ConstantSchemaAbstractDataBrokerTest(true) {
+ /*ConstantSchemaAbstractDataBrokerTest dataBrokerTest = new ConstantSchemaAbstractDataBrokerTest(true) {
@Override
protected Set<YangModuleInfo> getModuleInfos() throws Exception {
return ImmutableSet.of(BindingReflections.getModuleInfo(TwoLevelList.class),
}
};
+ dataBrokerTest.setup();
+ db = dataBrokerTest.getDataBroker();
+ db1 = new SingleTransactionDataBroker(db);*/
+ AbstractConcurrentDataBrokerTest dataBrokerTest =
+ new AbstractConcurrentDataBrokerTest(true) {};
dataBrokerTest.setup();
db = dataBrokerTest.getDataBroker();
db1 = new SingleTransactionDataBroker(db);
+
}
@Test
AtomicBoolean timedOut = new AtomicBoolean(false);
dataTreeEventCallbackRegistrar.onAdd(OPERATIONAL, FOO_PATH, topLevelList -> { /* NOOP */ },
Duration.ofMillis(50), iid -> {
- if (iid.equals(new DataTreeIdentifier<>(OPERATIONAL, FOO_PATH))) {
+ if (iid.equals(DataTreeIdentifier.create(OPERATIONAL, FOO_PATH))) {
timedOut.set(true);
}
}
package org.opendaylight.genius.mdsalutil.internal;
import java.util.Collection;
-
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yangtools.yang.binding.DataObject;
public abstract class AbstractMockForwardingRulesManager<D extends DataObject> implements DataTreeChangeListener<D> {
import java.util.concurrent.atomic.AtomicInteger;
import org.awaitility.Awaitility;
import org.hamcrest.Matchers;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+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.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
}
private void registerListener(final DataBroker db) {
- final DataTreeIdentifier<Flow> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<Flow> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
listenerRegistration = db.registerDataTreeChangeListener(treeId, MockFlowForwarder.this);
}
import java.util.concurrent.atomic.AtomicInteger;
import org.awaitility.Awaitility;
import org.hamcrest.Matchers;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+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.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
}
private void registerListener(final DataBroker db) {
- final DataTreeIdentifier<Group> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ final DataTreeIdentifier<Group> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
getWildCardPath());
listenerRegistration = db.registerDataTreeChangeListener(treeId, MockGroupForwarder.this);
}
<artifactId>mockito-core</artifactId>
<scope>compile</scope>
</dependency>
- <dependency>
+ <!--<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<scope>compile</scope>
<artifactId>sal-binding-broker-impl</artifactId>
<type>test-jar</type>
<scope>compile</scope>
+ </dependency>!-->
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <scope>compile</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <type>test-jar</type>
+ <scope>compile</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
import java.util.function.Supplier;
import javax.inject.Inject;
-
import org.awaitility.Awaitility;
import org.awaitility.core.ConditionTimeoutException;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinatorMonitor;
*/
package org.opendaylight.genius.datastoreutils.testutils;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
*/
package org.opendaylight.genius.datastoreutils.testutils;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ForwardingDataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ForwardingReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ForwardingWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.spi.ForwardingDataBroker;
+import org.opendaylight.mdsal.binding.spi.ForwardingReadWriteTransaction;
+import org.opendaylight.mdsal.binding.spi.ForwardingWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
}
}
- public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> handleRead(
- BiFunction<LogicalDatastoreType, InstanceIdentifier<T>, CheckedFuture<Optional<T>, ReadFailedException>>
+ public <T extends DataObject> FluentFuture<Optional<T>> handleRead(
+ BiFunction<LogicalDatastoreType, InstanceIdentifier<T>, FluentFuture<Optional<T>>>
readMethod,
LogicalDatastoreType store, InstanceIdentifier<T> path) {
if (howManyFailingReads.decrementAndGet() == -1) {
if (readException == null) {
return readMethod.apply(store, path);
} else {
- return Futures.immediateFailedCheckedFuture(readException);
+ return FluentFuture.from(Futures.immediateFailedFuture(readException));
}
}
public ReadWriteTransaction newReadWriteTransaction() {
return new ForwardingReadWriteTransaction(delegate.newReadWriteTransaction()) {
@Override
- public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(
+ public <T extends DataObject> FluentFuture<Optional<T>> read(
LogicalDatastoreType store, InstanceIdentifier<T> path) {
return handleRead(super::read, store, path);
}
*/
package org.opendaylight.genius.datastoreutils.testutils;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import com.google.inject.AbstractModule;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import java.util.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
/**
* Guice Module which correctly binds the {@link DataBrokerFailures}.
*/
public class DataBrokerFailuresModule extends AbstractModule {
- private final DataBroker realDataBroker;
+ private DataBroker realDataBroker;
public DataBrokerFailuresModule(DataBroker realDataBroker) {
this.realDataBroker = realDataBroker;
}
- public DataBrokerFailuresModule() {
- this(DataBrokerTestModule.dataBroker());
+ public DataBrokerFailuresModule() throws Exception {
+ AbstractBaseDataBrokerTest dataBrokerTest = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ dataBrokerTest.setup();
+ this.realDataBroker = dataBrokerTest.getDataBroker();
}
@Override
package org.opendaylight.genius.datastoreutils.testutils;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+
/**
* DataTreeChangeListener which decorates a TestableDataTreeChangeListener
import java.util.concurrent.ExecutorService;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+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.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.slf4j.Logger;
package org.opendaylight.genius.datastoreutils.testutils;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
/**
* DataTreeChangeListener useful for testing in asynchronous scenarios.
import com.google.inject.Key;
import com.google.inject.Provides;
import com.google.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
import org.opendaylight.genius.datastoreutils.testutils.infra.AutoCloseableModule;
-import org.opendaylight.serviceutils.tools.mdsal.listener.ChainableDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.serviceutils.tools.listener.ChainableDataTreeChangeListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.atomic.AtomicLong;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.awaitility.core.ConditionTimeoutException;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinatorMonitor;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.Executors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.AbstractBaseDataBrokerTest;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTestCustomizer;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.sal.core.compat.LegacyDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
/**
* Legacy (Controller) DataBroker test wiring which wraps an MD-SAL DataBroker.
@Override
public DOMDataBroker createDOMDataBroker() {
- return new LegacyDOMDataBrokerAdapter(domDataBroker);
+ return domDataBroker;
}
};
}
import org.junit.Test;
import org.junit.rules.MethodRule;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailures;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailuresModule;
import org.opendaylight.infrautils.inject.guice.testutils.AnnotationsModule;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
/**
* Unit test for DataBrokerFailuresImpl.
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
import org.opendaylight.genius.datastoreutils.testutils.TestableDataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
-
import org.junit.Assert;
import org.junit.ClassRule;
import org.junit.Rule;
import static com.google.common.truth.Truth.assertThat;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.infrautils.testutils.Asserts;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
public class DatastoreTest {
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import static org.opendaylight.infrautils.testutils.Asserts.assertThrows;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailuresImpl;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
}
@Before
- public void beforeTest() {
- testableDataBroker = new DataBrokerFailuresImpl(new DataBrokerTestModule(true).getDataBroker());
+ public void beforeTest() throws Exception {
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ testableDataBroker = new DataBrokerFailuresImpl(test.getDataBroker());
managedNewTransactionRunner = createManagedNewTransactionRunnerToTest(testableDataBroker);
singleTransactionDataBroker = new SingleTransactionDataBroker(testableDataBroker);
}
public void testCallWithNewWriteOnlyTransactionAndSubmitPutButLaterException() throws Exception {
assertTrue(assertThrows(ExecutionException.class,
() -> {
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(writeTx -> {
+ managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(writeTx -> {
writeTx.put(LogicalDatastoreType.OPERATIONAL, TEST_PATH, newTestDataObject());
// We now throw an arbitrary kind of checked (not unchecked!) exception here
throw new IOException("something didn't quite go as expected...");
fail("This should have led to an ExecutionException!");
}).getCause() instanceof IOException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof IOException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof IOException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof IOException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof IOException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof TransactionCommitFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof TransactionCommitFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof TransactionCommitFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof TransactionCommitFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof TransactionCommitFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof OptimisticLockFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof OptimisticLockFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof OptimisticLockFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
fail("This should have led to an ExecutionException!");
}).getCause() instanceof OptimisticLockFailedException);
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
assertThat(e.getCause() instanceof OptimisticLockFailedException).isTrue();
}
assertThat(
- singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isAbsent();
+ singleTransactionDataBroker.syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewWriteOnlyTransactionAndSubmitCannotCommit() {
assertThrows(ExecutionException.class,
() -> managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
- AsyncWriteTransaction::commit).get());
+ WriteTransaction::commit).get());
}
@Test
public void testCallWithNewReadWriteTransactionAndSubmitCannotCommit() {
assertThrows(ExecutionException.class,
() -> managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(
- AsyncWriteTransaction::commit).get());
+ WriteTransaction::commit).get());
}
@Test
public void testCallWithNewWriteOnlyTransactionAndSubmitCannotCancel() {
assertThrows(ExecutionException.class,
() -> managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(
- AsyncWriteTransaction::cancel).get());
+ WriteTransaction::cancel).get());
}
@Test
public void testCallWithNewReadWriteTransactionAndSubmitCannotCancel() {
assertThrows(ExecutionException.class,
() -> managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(
- AsyncWriteTransaction::cancel).get());
+ WriteTransaction::cancel).get());
}
}
package org.opendaylight.genius.infra.tests;
import static org.junit.Assert.assertEquals;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import org.junit.Test;
-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.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
/**
* 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.genius.infra.tests;
+/* org.opendaylight.genius.infra.tests;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.path;
import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.topLevelList;
import static org.opendaylight.infrautils.testutils.Asserts.assertThrows;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailuresImpl;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.TransactionAdapter;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
* Test for {@link TransactionAdapter}.
*/
// This is a test for a deprecated class
-@SuppressWarnings("deprecation")
+/*@SuppressWarnings("deprecation")
public class TransactionAdapterTest {
private static final InstanceIdentifier<TopLevelList> TEST_PATH = path(TOP_FOO_KEY);
return topLevelList(TOP_FOO_KEY, fooAugment);
}
-}
+}*/
package org.opendaylight.genius.networkutils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
void releaseRD(String rdKey) throws ExecutionException, InterruptedException;
- Optional<IdPool> getRDPool() throws ReadFailedException;
+ Optional<IdPool> getRDPool() throws ReadFailedException, ExecutionException, InterruptedException;
}
\ No newline at end of file
*/
package org.opendaylight.genius.networkutils;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.opendaylight.yangtools.yang.common.Uint64;
void releaseVNI(String vniKey) throws ExecutionException, InterruptedException;
- Optional<IdPool> getVxlanVniPool() throws ReadFailedException;
+ Optional<IdPool> getVxlanVniPool() throws ReadFailedException, ExecutionException, InterruptedException;
}
\ No newline at end of file
package org.opendaylight.genius.networkutils.impl;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
-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.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.networkutils.RDUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
@Inject
public RDUtilsImpl(NetworkConfig networkConfig, IdManagerService idManagerService,
- @Reference DataBroker dataBroker) throws ReadFailedException {
+ @Reference DataBroker dataBroker) throws InterruptedException, ExecutionException {
this.idManagerService = idManagerService;
this.dataBroker = dataBroker;
this.networkConfig = networkConfig;
}
@Override
- public Optional<IdPool> getRDPool() throws ReadFailedException {
+ public Optional<IdPool> getRDPool() throws ExecutionException, InterruptedException {
return SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, buildIdPoolInstanceIdentifier(NwConstants.ODL_RD_POOL_NAME));
}
- private void validateAndCreateRDPool() throws ReadFailedException {
+ private void validateAndCreateRDPool() throws InterruptedException, ExecutionException {
long lowLimit = 0L;
Uint32 highConfig = networkConfig.getOpendaylightRdCount();
long highLimit = highConfig == null ? 0 : highConfig.toJava();
package org.opendaylight.genius.networkutils.impl;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
-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.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.networkutils.VniUtils;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
@Inject
public VniUtilsImpl(NetworkConfig networkConfig, IdManagerService idManagerService,
- @Reference DataBroker dataBroker) throws ReadFailedException {
+ @Reference DataBroker dataBroker) throws InterruptedException, ExecutionException {
this.idManagerService = idManagerService;
this.dataBroker = dataBroker;
this.networkConfig = networkConfig;
}
@Override
- public Optional<IdPool> getVxlanVniPool() throws ReadFailedException {
+ public Optional<IdPool> getVxlanVniPool() throws ExecutionException, InterruptedException {
return SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, buildIdPoolInstanceIdentifier(NwConstants.ODL_VNI_POOL_NAME));
}
- private void validateAndCreateVxlanVniPool() throws ReadFailedException {
+ private void validateAndCreateVxlanVniPool() throws InterruptedException, ExecutionException {
/*
* 1. If VNI Pool doesn't exist create it.
* 2. If VNI Pool exists, but the range value is changed incorrectly
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.networkutils.RDUtils;
import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
import org.opendaylight.infrautils.testutils.LogCaptureRule;
import org.opendaylight.infrautils.testutils.LogRule;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private @Inject RDUtils rdUtils;
@Test
- public void testDefaultVniPoolCreated() throws ReadFailedException {
+ public void testDefaultVniPoolCreated() throws ReadFailedException , InterruptedException, ExecutionException {
IdPool idPool = vniUtils.getVxlanVniPool().get();
assertThat(idPool.getPoolName()).isEqualTo(NwConstants.ODL_VNI_POOL_NAME);
}
}
@Test
- public void testDefaultRDPoolCreated() throws ReadFailedException {
+ public void testDefaultRDPoolCreated() throws ReadFailedException, ExecutionException, InterruptedException {
IdPool idPool = rdUtils.getRDPool().get();
assertThat(idPool.getPoolName()).isEqualTo(NwConstants.ODL_RD_POOL_NAME);
}
import static org.mockito.Mockito.mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.Executors;
import org.opendaylight.daexim.DataImportBootReady;
import org.opendaylight.genius.idmanager.IdManager;
import org.opendaylight.genius.lockmanager.impl.LockManagerServiceImpl;
import org.opendaylight.genius.networkutils.impl.RDUtilsImpl;
import org.opendaylight.genius.networkutils.impl.VniUtilsImpl;
import org.opendaylight.infrautils.inject.guice.testutils.AbstractGuiceJsr250Module;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractBaseDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTestCustomizer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.networkutils.config.rev181129.NetworkConfig;
public class NetworkUtilTestModule extends AbstractGuiceJsr250Module {
@Override
- protected void configureBindings() {
- DataBrokerTestModule dataBrokerTestModule = new DataBrokerTestModule(false);
- DataBroker dataBroker = dataBrokerTestModule.getDataBroker();
+ protected void configureBindings() throws Exception {
+ AbstractBaseDataBrokerTest test = new AbstractBaseDataBrokerTest() {
+ @Override
+ protected AbstractDataBrokerTestCustomizer createDataBrokerTestCustomizer() {
+ return new AbstractDataBrokerTestCustomizer() {
+ @Override
+ public ListeningExecutorService getCommitCoordinatorExecutor() {
+ return MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+ }
+ };
+ }
+ };
+ test.setup();
+ DataBroker dataBroker = test.getDataBroker();
bind(DataBroker.class).toInstance(dataBroker);
bind(NetworkConfig.class).toInstance(mock(NetworkConfig.class));
bind(IdManagerService.class).to(IdManager.class);
Code Review / genius.git / commitdiff