Remove GENIUS UTIL references in FibManager Module

Remove references to
org.opendaylight.genius.infra.ManagedNewTransactionRunner in
fibmanager-impl

JIRA: NETVIRT-1704

Signed-off-by: Karthikeyan Krishnan <karthikeyangceb007@gmail.com>
Change-Id: I748246b873a8afe92123e339b446cfdceedb5863

diff --git a/fibmanager/api/src/main/java/org/opendaylight/netvirt/fibmanager/api/IFibManager.java b/fibmanager/api/src/main/java/org/opendaylight/netvirt/fibmanager/api/IFibManager.java
index e0a929e048530b6e19cf48580cd3a4be8ef309b1..b98953bc4e6da46fff4b729e1f12f653c052e5b9 100644 (file)
--- a/fibmanager/api/src/main/java/org/opendaylight/netvirt/fibmanager/api/IFibManager.java
+++ b/fibmanager/api/src/main/java/org/opendaylight/netvirt/fibmanager/api/IFibManager.java
@@ -11,10 +11,10 @@ package org.opendaylight.netvirt.fibmanager.api;
 import com.google.common.util.concurrent.FutureCallback;
 import java.util.List;
 import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.genius.infra.Datastore.Configuration;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore.Configuration;
+import org.opendaylight.mdsal.binding.util.TypedWriteTransaction;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.RouterInterface;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
@@ -23,7 +23,7 @@ import org.opendaylight.yangtools.yang.common.Uint64;
 
 public interface IFibManager {
     void populateFibOnNewDpn(Uint64 dpnId, Uint32 vpnId, String rd,
-                             @Nullable FutureCallback<List<Void>> callback);
+                             @Nullable FutureCallback<List<?>> callback);
 
     void cleanUpExternalRoutesOnDpn(Uint64 dpnId, Uint32 vpnId, String rd,
                                     String localNextHopIp, String remoteNextHopIp);
@@ -32,7 +32,7 @@ public interface IFibManager {
                                      String localNextHopIp, String remoteNextHopIp);
 
     void cleanUpDpnForVpn(Uint64 dpnId, Uint32 vpnId, String rd,
-                          @Nullable FutureCallback<List<Void>> callback);
+                          @Nullable FutureCallback<List<?>> callback);
 
     void setConfTransType(String service, String transportType);
 

diff --git a/fibmanager/impl/pom.xml b/fibmanager/impl/pom.xml
index 17358d239986a7e72dddfd2f9c3cc587734f32b2..f8fda964200044b613323cd351a96156cb864053 100644 (file)
--- a/fibmanager/impl/pom.xml
+++ b/fibmanager/impl/pom.xml
@@ -37,6 +37,10 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
             <artifactId>mdsalutil-api</artifactId>
             <version>${genius.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.opendaylight.mdsal</groupId>
+            <artifactId>mdsal-binding-util</artifactId>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>bgpmanager-api</artifactId>

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BaseVrfEntryHandler.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BaseVrfEntryHandler.java
index f533f4b94b9603ab51826350f0573f2f96696961..21f7aadd0ba323c7b577d203fc7fc43018fce003 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BaseVrfEntryHandler.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BaseVrfEntryHandler.java
@@ -26,8 +26,6 @@ import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
@@ -59,6 +57,10 @@ import org.opendaylight.genius.utils.batching.SubTransactionImpl;
 import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.util.TransactionAdapter;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;
 import org.opendaylight.netvirt.fibmanager.api.FibHelper;
@@ -243,8 +245,9 @@ public class BaseVrfEntryHandler implements AutoCloseable {
                                       @Nullable List<InstructionInfo> instructions, int addOrRemove,
                                       WriteTransaction tx, @Nullable List<SubTransaction> subTxns) {
         if (tx == null) {
-            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                newTx -> makeConnectedRoute(dpId, vpnId, vrfEntry, rd, instructions, addOrRemove, newTx, subTxns)),
+            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+                newTx -> makeConnectedRoute(dpId, vpnId, vrfEntry, rd, instructions, addOrRemove,
+                        TransactionAdapter.toWriteTransaction(newTx), subTxns)),
                 LOG, "Error making connected route");
             return;
         }
@@ -450,7 +453,9 @@ public class BaseVrfEntryHandler implements AutoCloseable {
                     (before, after) -> {
                         LOG.info("programRemoteFib: waited for and got interface state {}", absentInterfaceStateIid);
                         LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                            (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null)),
+                                Datastore.CONFIGURATION,
+                            (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry,
+                                    TransactionAdapter.toWriteTransaction(wtx), rd, adjacencyResults, null)),
                             LOG, "Failed to program remote FIB {}", absentInterfaceStateIid);
                         return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
                     },
@@ -458,7 +463,9 @@ public class BaseVrfEntryHandler implements AutoCloseable {
                     (iid) -> {
                         LOG.error("programRemoteFib: timed out waiting for {}", absentInterfaceStateIid);
                         LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                            (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry, wtx, rd, adjacencyResults, null)),
+                                Datastore.CONFIGURATION,
+                            (wtx) -> programRemoteFib(remoteDpnId, vpnId, vrfEntry,
+                                    TransactionAdapter.toWriteTransaction(wtx), rd, adjacencyResults, null)),
                             LOG, "Failed to program timed-out remote FIB {}", absentInterfaceStateIid);
                     });
                 return;
@@ -515,9 +522,10 @@ public class BaseVrfEntryHandler implements AutoCloseable {
                                   final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional,
                                   @Nullable WriteTransaction tx) {
         if (tx == null) {
-            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
                 newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry,
-                        extraRouteOptional, newTx)), LOG, "Error deleting remote route");
+                        extraRouteOptional, TransactionAdapter.toWriteTransaction(newTx))),
+                    LOG, "Error deleting remote route");
             return;
         }
 

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BgpRouteVrfEntryHandler.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BgpRouteVrfEntryHandler.java
index db2a9758df879224f278eedd138847e7d8d85611..92f6da7a6b312c6375a5b58ed11c854ad78a4ad5 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BgpRouteVrfEntryHandler.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/BgpRouteVrfEntryHandler.java
@@ -22,8 +22,6 @@ import javax.inject.Inject;
 import javax.inject.Singleton;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
 import org.opendaylight.genius.mdsalutil.NwConstants;
@@ -43,6 +41,10 @@ import org.opendaylight.genius.utils.batching.SubTransaction;
 import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.util.TransactionAdapter;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
 import org.opendaylight.serviceutils.upgrade.UpgradeState;
@@ -330,8 +332,9 @@ public class BgpRouteVrfEntryHandler extends BaseVrfEntryHandler implements Reso
                                      WriteTransaction tx,
                                      List<SubTransaction> subTxns) {
         if (tx == null) {
-            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                newTx -> createRemoteFibEntry(remoteDpnId, vpnId, rd, vrfEntry, newTx, subTxns)), LOG,
+            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+                newTx -> createRemoteFibEntry(remoteDpnId, vpnId, rd, vrfEntry,
+                        TransactionAdapter.toWriteTransaction(newTx), subTxns)), LOG,
                 "Error creating remote FIB entry");
             return;
         }
@@ -369,9 +372,10 @@ public class BgpRouteVrfEntryHandler extends BaseVrfEntryHandler implements Reso
                                   final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional,
                                   @Nullable WriteTransaction tx, List<SubTransaction> subTxns) {
         if (tx == null) {
-            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+            LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
                 newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry,
-                        extraRouteOptional, newTx)), LOG, "Error deleting remote route");
+                        extraRouteOptional, TransactionAdapter.toWriteTransaction(newTx))),
+                    LOG, "Error deleting remote route");
             return;
         }
 

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/EvpnVrfEntryHandler.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/EvpnVrfEntryHandler.java
index 36d566a91319ec67b33a79a617bb747ed256a178..e8878651de714121640fbfc91277e7362223b693 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/EvpnVrfEntryHandler.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/EvpnVrfEntryHandler.java
@@ -7,7 +7,7 @@
  */
 package org.opendaylight.netvirt.fibmanager;
 
-import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
 
 import com.google.common.base.Preconditions;
 import java.util.ArrayList;
@@ -17,8 +17,6 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
 import org.opendaylight.genius.mdsalutil.NwConstants;
@@ -30,6 +28,10 @@ import org.opendaylight.genius.utils.batching.SubTransaction;
 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.util.TransactionAdapter;
 import org.opendaylight.mdsal.common.api.ReadFailedException;
 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
 import org.opendaylight.serviceutils.upgrade.UpgradeState;
@@ -182,9 +184,9 @@ public class EvpnVrfEntryHandler extends BaseVrfEntryHandler {
             new InstructionApplyActions(
                 Collections.singletonList(new ActionGroup(groupId))));
         jobCoordinator.enqueueJob(jobKey,
-            () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                tx -> makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, instructions, NwConstants.ADD_FLOW, tx,
-                        null))));
+            () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+                tx -> makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, instructions, NwConstants.ADD_FLOW,
+                        TransactionAdapter.toWriteTransaction(tx), null))));
         return dpnId;
     }
 
@@ -197,16 +199,18 @@ public class EvpnVrfEntryHandler extends BaseVrfEntryHandler {
         Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.nonnullVpnToDpnList();
         if (keyVpnToDpnListMap != null) {
             jobCoordinator.enqueueJob("FIB" + rd + vrfEntry.getDestPrefix(),
-                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
-                    for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
-                        if (!localDpnId.contains(vpnDpn.getDpnId())) {
-                            if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
-                                createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(),
-                                        vrfTableKey, vrfEntry, isNatPrefix, tx);
+                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                        Datastore.CONFIGURATION, tx -> {
+                        for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
+                            if (!localDpnId.contains(vpnDpn.getDpnId())) {
+                                if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
+                                    createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(),
+                                            vrfTableKey, vrfEntry, isNatPrefix,
+                                            TransactionAdapter.toWriteTransaction(tx));
+                                }
                             }
                         }
-                    }
-                })));
+                    })));
         }
     }
 
@@ -288,44 +292,47 @@ public class EvpnVrfEntryHandler extends BaseVrfEntryHandler {
         List<SubTransaction> subTxns =  new ArrayList<>();
         if (keyVpnToDpnListMap != null) {
             jobCoordinator.enqueueJob("FIB" + rd + vrfEntry.getDestPrefix(),
-                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
-                    final Optional<Routes> extraRouteOptional = Optional.empty();
-                    if (localDpnIdList.size() <= 0) {
-                        for (VpnToDpnList curDpn1 : keyVpnToDpnListMap.values()) {
-                            if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
-                                if (curDpn1.getDpnState() == VpnToDpnList.DpnState.Active) {
-                                    bgpRouteVrfEntryHandler.deleteRemoteRoute(Uint64.ZERO,
-                                            curDpn1.getDpnId(),
+                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                        Datastore.CONFIGURATION, tx -> {
+                        final Optional<Routes> extraRouteOptional = Optional.empty();
+                        if (localDpnIdList.size() <= 0) {
+                            for (VpnToDpnList curDpn1 : keyVpnToDpnListMap.values()) {
+                                if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
+                                    if (curDpn1.getDpnState() == VpnToDpnList.DpnState.Active) {
+                                        bgpRouteVrfEntryHandler.deleteRemoteRoute(Uint64.ZERO,
+                                                curDpn1.getDpnId(),
+                                                vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
+                                                extraRouteOptional, TransactionAdapter.toWriteTransaction(tx),
+                                                subTxns);
+                                    }
+                                } else {
+                                    deleteRemoteRoute(Uint64.ZERO, curDpn1.getDpnId(),
                                             vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
-                                            extraRouteOptional, tx, subTxns);
+                                            extraRouteOptional, TransactionAdapter.toWriteTransaction(tx));
                                 }
-                            } else {
-                                deleteRemoteRoute(Uint64.ZERO, curDpn1.getDpnId(),
-                                        vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
-                                        extraRouteOptional, tx);
                             }
-                        }
-                    } else {
-                        for (Uint64 localDpnId : localDpnIdList) {
-                            for (VpnToDpnList curDpn2 : keyVpnToDpnListMap.values()) {
-                                if (!Objects.equals(curDpn2.getDpnId(), localDpnId)) {
-                                    if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
-                                        if (curDpn2.getDpnState() == VpnToDpnList.DpnState.Active) {
-                                            bgpRouteVrfEntryHandler.deleteRemoteRoute(localDpnId,
-                                                    curDpn2.getDpnId(),
+                        } else {
+                            for (Uint64 localDpnId : localDpnIdList) {
+                                for (VpnToDpnList curDpn2 : keyVpnToDpnListMap.values()) {
+                                    if (!Objects.equals(curDpn2.getDpnId(), localDpnId)) {
+                                        if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.BGP) {
+                                            if (curDpn2.getDpnState() == VpnToDpnList.DpnState.Active) {
+                                                bgpRouteVrfEntryHandler.deleteRemoteRoute(localDpnId,
+                                                        curDpn2.getDpnId(),
+                                                        vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
+                                                        extraRouteOptional,
+                                                        TransactionAdapter.toWriteTransaction(tx), subTxns);
+                                            }
+                                        } else {
+                                            deleteRemoteRoute(localDpnId, curDpn2.getDpnId(),
                                                     vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
-                                                    extraRouteOptional, tx, subTxns);
+                                                    extraRouteOptional, TransactionAdapter.toWriteTransaction(tx));
                                         }
-                                    } else {
-                                        deleteRemoteRoute(localDpnId, curDpn2.getDpnId(),
-                                                vpnInstance.getVpnId(), vrfTableKey, vrfEntry,
-                                                extraRouteOptional, tx);
                                     }
                                 }
                             }
                         }
-                    }
-                })));
+                    })));
         }
     }
 
@@ -339,9 +346,9 @@ public class EvpnVrfEntryHandler extends BaseVrfEntryHandler {
         } else {
             final Uint64 dpnId = localNextHopInfo.getDpnId();
             jobCoordinator.enqueueJob("FIB-" + rd + "-" + vrfEntry.getDestPrefix(),
-                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
-                    tx -> makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW, tx,
-                            null))));
+                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
+                    tx -> makeConnectedRoute(dpnId, vpnId, vrfEntry, rd, null, NwConstants.DEL_FLOW,
+                            TransactionAdapter.toWriteTransaction(tx), null))));
             //TODO: verify below adjacency call need to be optimized (?)
             deleteLocalAdjacency(dpnId, vpnId, vrfEntry.getDestPrefix(), vrfEntry.getDestPrefix());
             returnLocalDpnId.add(dpnId);

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibManagerImpl.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibManagerImpl.java
index 6a139bd54d56358881146a485dfbb6405c147ad5..196e10713430a57a04036f91c0dd067a4fa39ab2 100755 (executable)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibManagerImpl.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibManagerImpl.java
@@ -15,10 +15,10 @@ import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import javax.inject.Inject;
 import javax.inject.Singleton;
-import org.opendaylight.genius.infra.Datastore.Configuration;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore.Configuration;
+import org.opendaylight.mdsal.binding.util.TypedWriteTransaction;
 import org.opendaylight.netvirt.fibmanager.api.IFibManager;
 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
 import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
@@ -74,7 +74,7 @@ public class FibManagerImpl implements IFibManager {
 
     @Override
     public void populateFibOnNewDpn(Uint64 dpnId, Uint32 vpnId, String rd,
-                                    FutureCallback<List<Void>> callback) {
+                                    FutureCallback<List<?>> callback) {
         vrfEntryListener.populateFibOnNewDpn(dpnId, vpnId, rd, callback);
     }
 
@@ -96,7 +96,7 @@ public class FibManagerImpl implements IFibManager {
 
     @Override
     public void cleanUpDpnForVpn(Uint64 dpnId, Uint32 vpnId, String rd,
-                                 FutureCallback<List<Void>> callback) {
+                                 FutureCallback<List<?>> callback) {
         vrfEntryListener.cleanUpDpnForVpn(dpnId, vpnId, rd, callback);
     }
 

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibUtil.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibUtil.java
index 8837b90bdd8b14c0b6f33ba12aff77eaaad91ff2..eafc7a110ff5b0fbc522793b222d2cd6260fe080 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibUtil.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibUtil.java
@@ -28,11 +28,6 @@ import javax.inject.Singleton;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.infra.Datastore.Configuration;
-import org.opendaylight.genius.infra.Datastore.Operational;
-import org.opendaylight.genius.infra.TypedReadTransaction;
-import org.opendaylight.genius.infra.TypedReadWriteTransaction;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.genius.itm.api.IITMProvider;
 import org.opendaylight.genius.mdsalutil.BucketInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
@@ -41,6 +36,11 @@ import org.opendaylight.genius.mdsalutil.NwConstants;
 import org.opendaylight.genius.utils.JvmGlobalLocks;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.Datastore.Configuration;
+import org.opendaylight.mdsal.binding.util.Datastore.Operational;
+import org.opendaylight.mdsal.binding.util.TypedReadTransaction;
+import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.util.TypedWriteTransaction;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.ReadFailedException;
 import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/NexthopManager.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/NexthopManager.java
index 690bcbeee5d24fdc2e5f5cac87a185243355dade..6cc279fb16eb6b6dad848b64c818b43f67b33c24 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/NexthopManager.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/NexthopManager.java
@@ -8,9 +8,9 @@
 package org.opendaylight.netvirt.fibmanager;
 
 import static java.util.stream.Collectors.toList;
-import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
 import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
+import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
 
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -33,8 +33,6 @@ import javax.inject.Inject;
 import javax.inject.Singleton;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
 import org.opendaylight.genius.itm.globals.ITMConstants;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
@@ -56,6 +54,8 @@ import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldVlanVid;
 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.ReadFailedException;
 import org.opendaylight.netvirt.elanmanager.api.IElanService;
@@ -1088,7 +1088,7 @@ public class NexthopManager implements AutoCloseable {
     public void createDcGwLoadBalancingGroup(Uint64 dpnId, String destinationIp,
                                              Class<? extends TunnelTypeBase> tunnelType) {
         jobCoordinator.enqueueJob(FibHelper.getJobKeyForDcGwLoadBalancingGroup(dpnId), () -> {
-            List<ListenableFuture<Void>> futures = new ArrayList<>();
+            List<ListenableFuture<?>> futures = new ArrayList<>();
             futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operationalTx -> {
                 synchronized (getDcGateWaySyncKey(destinationIp)) {
                     FibUtil.addL3vpnDcGateWay(destinationIp, operationalTx);
@@ -1205,7 +1205,7 @@ public class NexthopManager implements AutoCloseable {
             if (availableDcGws.contains(destinationIp)) {
                 availableDcGws.remove(destinationIp);
             }
-            List<ListenableFuture<Void>> futures = new ArrayList<>();
+            List<ListenableFuture<?>> futures = new ArrayList<>();
             futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operationalTx -> {
                 futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, configTx -> {
                     availableDcGws.forEach(dcGwIp -> {
@@ -1250,7 +1250,7 @@ public class NexthopManager implements AutoCloseable {
             if (availableDcGws.contains(destinationIp)) {
                 availableDcGws.remove(destinationIp);
             }
-            List<ListenableFuture<Void>> futures = new ArrayList<>();
+            List<ListenableFuture<?>> futures = new ArrayList<>();
             futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, configTx -> {
                 availableDcGws.forEach(dcGwIp -> {
                     List<String> dcGws = Arrays.asList(dcGwIp, destinationIp);

diff --git a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/VrfEntryListener.java b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/VrfEntryListener.java
index 10d646d8fbfc9c8de81780c8ba2d5d63ae9ed698..3c08ede1d4bdc945011bb4b40ff7c0a0ceddf78e 100644 (file)
--- a/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/VrfEntryListener.java
+++ b/fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/VrfEntryListener.java
@@ -7,9 +7,9 @@
  */
 package org.opendaylight.netvirt.fibmanager;
 
-import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
 import static org.opendaylight.genius.mdsalutil.NWUtil.isIpv4Address;
+import static org.opendaylight.mdsal.binding.util.Datastore.CONFIGURATION;
+import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
@@ -39,14 +39,6 @@ import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 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.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.infra.RetryingManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.TransactionAdapter;
-import org.opendaylight.genius.infra.TypedReadWriteTransaction;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
@@ -74,6 +66,15 @@ import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 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.util.Datastore;
+import org.opendaylight.mdsal.binding.util.Datastore.Configuration;
+import org.opendaylight.mdsal.binding.util.Datastore.Operational;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.binding.util.RetryingManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.TransactionAdapter;
+import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.binding.util.TypedWriteTransaction;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.netvirt.elanmanager.api.IElanService;
 import org.opendaylight.netvirt.fibmanager.NexthopManager.AdjacencyResult;
@@ -333,8 +334,8 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
             //Update the used rds and vpntoextraroute containers only for the deleted nextHops.
             List<String> nextHopsRemoved = FibHelper.getNextHopListFromRoutePaths(original);
             nextHopsRemoved.removeAll(FibHelper.getNextHopListFromRoutePaths(update));
-            List<ListenableFuture<Void>> futures = new ArrayList<>();
-            ListenableFuture<Void> configFuture =
+            List<ListenableFuture<?>> futures = new ArrayList<>();
+            ListenableFuture<?> configFuture =
                 txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, configTx ->
                     futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operTx ->
                         nextHopsRemoved.parallelStream()
@@ -347,9 +348,9 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
                                 }
                             }))));
             futures.add(configFuture);
-            Futures.addCallback(configFuture, new FutureCallback<Void>() {
+            Futures.addCallback(configFuture, new FutureCallback<Object>() {
                 @Override
-                public void onSuccess(Void result) {
+                public void onSuccess(Object result) {
                     createFibEntries(identifier, update);
                     LOG.info("UPDATE: Updated static Fib Entry with rd {} prefix {} route-paths {}",
                             rd, update.getDestPrefix(), update.getRoutePaths());
@@ -1270,10 +1271,11 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
         List<InstructionInfo> instructions = Lists.newArrayList(new InstructionApplyActions(actionInfos));
         String jobKey = FibUtil.getCreateRemoteNextHopJobKey(vpnId, remoteDpnId, vrfEntry.getDestPrefix());
         jobCoordinator.enqueueJob(jobKey,
-            () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(txn -> {
-                baseVrfEntryHandler.makeConnectedRoute(remoteDpnId, vpnId, vrfEntry, rd, instructions,
-                        NwConstants.ADD_FLOW, txn, null);
-            })));
+            () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+                txn -> {
+                    baseVrfEntryHandler.makeConnectedRoute(remoteDpnId, vpnId, vrfEntry, rd, instructions,
+                            NwConstants.ADD_FLOW, TransactionAdapter.toWriteTransaction(txn), null);
+                })));
 
         LOG.debug("Successfully added FIB entry for prefix {} in vpnId {}", vrfEntry.getDestPrefix(), vpnId);
     }
@@ -1382,7 +1384,7 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
         }
 
         @Override
-        public List<ListenableFuture<Void>> call() {
+        public List<? extends ListenableFuture<?>> call() {
             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
             // to call the respective helpers.
             return Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, tx -> {
@@ -1710,7 +1712,7 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
     }
 
     public void populateFibOnNewDpn(final Uint64 dpnId, final Uint32 vpnId, final String rd,
-                                    final FutureCallback<List<Void>> callback) {
+                                    final FutureCallback<List<?>> callback) {
         LOG.trace("New dpn {} for vpn {} : populateFibOnNewDpn", dpnId, rd);
         jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId),
             () -> {
@@ -1718,11 +1720,11 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
                 final VpnInstanceOpDataEntry vpnInstance = fibUtil.getVpnInstance(rd);
                 final Optional<VrfTables> vrfTable = MDSALUtil.read(dataBroker,
                         LogicalDatastoreType.CONFIGURATION, id);
-                List<ListenableFuture<Void>> futures = new ArrayList<>();
+                List<ListenableFuture<?>> futures = new ArrayList<>();
                 if (!vrfTable.isPresent()) {
                     LOG.info("populateFibOnNewDpn: dpn: {}: VRF Table not yet available for RD {}", dpnId, rd);
                     if (callback != null) {
-                        ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
+                        ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
                         Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
                     }
                     return futures;
@@ -1788,7 +1790,7 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
                         }
                     }));
                     if (callback != null) {
-                        ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
+                        ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
                         Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
                     }
                 } finally {
@@ -1895,7 +1897,7 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
     }
 
     public void cleanUpDpnForVpn(final Uint64 dpnId, final Uint32 vpnId, final String rd,
-                                 final FutureCallback<List<Void>> callback) {
+                                 final FutureCallback<List<?>> callback) {
         LOG.trace("cleanUpDpnForVpn: Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
         jobCoordinator.enqueueJob(FibUtil.getJobKeyForVpnIdDpnId(vpnId, dpnId),
             () -> {
@@ -1904,11 +1906,11 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
                 List<SubTransaction> txnObjects = new ArrayList<>();
                 final Optional<VrfTables> vrfTable = MDSALUtil.read(dataBroker,
                         LogicalDatastoreType.CONFIGURATION, id);
-                List<ListenableFuture<Void>> futures = new ArrayList<>();
+                List<ListenableFuture<?>> futures = new ArrayList<>();
                 if (!vrfTable.isPresent()) {
                     LOG.error("cleanUpDpnForVpn: VRF Table not available for RD {}", rd);
                     if (callback != null) {
-                        ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
+                        ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
                         Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
                     }
                     return futures;
@@ -2008,7 +2010,7 @@ public class VrfEntryListener extends AbstractAsyncDataTreeChangeListener<VrfEnt
                     lock.unlock();
                 }
                 if (callback != null) {
-                    ListenableFuture<List<Void>> listenableFuture = Futures.allAsList(futures);
+                    ListenableFuture<List<Object>> listenableFuture = Futures.allAsList(futures);
                     Futures.addCallback(listenableFuture, callback, MoreExecutors.directExecutor());
                 }
                 return futures;

diff --git a/vpnmanager/api/src/main/java/org/opendaylight/netvirt/vpnmanager/api/VpnExtraRouteHelper.java b/vpnmanager/api/src/main/java/org/opendaylight/netvirt/vpnmanager/api/VpnExtraRouteHelper.java
index 4ce8c81465c2ed51a5bfab193fa1d95a03ac67ed..40598f774521fcca3e3c8847e8f5c51a423058b5 100644 (file)
--- a/vpnmanager/api/src/main/java/org/opendaylight/netvirt/vpnmanager/api/VpnExtraRouteHelper.java
+++ b/vpnmanager/api/src/main/java/org/opendaylight/netvirt/vpnmanager/api/VpnExtraRouteHelper.java
@@ -20,9 +20,10 @@ import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.infra.Datastore.Configuration;
 import org.opendaylight.genius.infra.Datastore.Operational;
-import org.opendaylight.genius.infra.TypedReadTransaction;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.util.Datastore;
+import org.opendaylight.mdsal.binding.util.TypedReadTransaction;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeInputBuilder;
@@ -69,8 +70,9 @@ public final class VpnExtraRouteHelper {
         return extraRouteOptional;
     }
 
-    public static Optional<Routes> getVpnExtraroutes(TypedReadTransaction<Operational> operTx, String vpnName,
-            String vpnRd, String destPrefix) throws ExecutionException, InterruptedException {
+    public static Optional<Routes> getVpnExtraroutes(TypedReadTransaction<Datastore.Operational> operTx,
+                                                     String vpnName, String vpnRd, String destPrefix)
+            throws ExecutionException, InterruptedException {
         return operTx.read(getVpnToExtrarouteVrfIdIdentifier(vpnName, vpnRd, destPrefix)).get();
     }
 
@@ -116,7 +118,9 @@ public final class VpnExtraRouteHelper {
                 .map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
     }
 
-    public static  List<String> getUsedRds(TypedReadTransaction<Configuration> confTx, Uint32 vpnId, String destPrefix)
+    public static  List<String> getUsedRds(org.opendaylight.mdsal.binding.util
+                                                   .TypedReadTransaction<Datastore.Configuration> confTx,
+                                           Uint32 vpnId, String destPrefix)
             throws ExecutionException, InterruptedException {
         Optional<DestPrefixes> usedRds = confTx.read(getUsedRdsIdentifier(vpnId, destPrefix)).get();
         return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null