vpnmanager typed tx: VpnUtil

But w/out the VpnInterfaceManager parts

JIRA: NETVIRT-1346

Change-Id: Ic1d9c7d434a58128c130c9772d3941ed57ac0081
Signed-off-by: Josh <jhershbe@redhat.com>

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 93570177cd9ccc02b85ca10eb3fa2ec8f9b103d2..7d83f0fded330197cc01446ebf9c878a70c57019 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
@@ -14,6 +14,8 @@ import java.math.BigInteger;
 import java.util.List;
 
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.genius.infra.Datastore;
+import org.opendaylight.genius.infra.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;
@@ -68,7 +70,7 @@ public interface IFibManager {
 
     void addVrfTable(String rd, WriteTransaction writeConfigTxn);
 
-    void removeVrfTable(String rd, WriteTransaction writeConfigTxn);
+    void removeVrfTable(String rd, TypedWriteTransaction<Datastore.Configuration> writeConfigTxn);
 
     void removeInterVPNLinkRouteFlows(String interVpnLinkName,
                                       boolean isVpnFirstEndPoint,

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 ab855d0482c496ac21df5a26011d9bcf9ccbf89c..f5ae62effbc2b71bb8b74c702ef3e79adfb19e08 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
@@ -17,6 +17,8 @@ import java.util.concurrent.TimeUnit;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.genius.infra.Datastore;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.netvirt.fibmanager.api.IFibManager;
 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
 import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
@@ -166,7 +168,7 @@ public class FibManagerImpl implements IFibManager {
     }
 
     @Override
-    public void removeVrfTable(String rd, WriteTransaction writeConfigTxn) {
+    public void removeVrfTable(String rd, TypedWriteTransaction<Datastore.Configuration> writeConfigTxn) {
         fibUtil.removeVrfTable(rd, writeConfigTxn);
     }
 

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 4e63fa8f9e0d375dc025a640e5ee643ce5809b6f..61fee1049dc37c5c0e4204c5fe84a06e1f29d412 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
@@ -23,11 +23,14 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 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.ReadFailedException;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.Datastore;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.genius.mdsalutil.BucketInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.genius.mdsalutil.NwConstants;
@@ -503,14 +506,14 @@ public class FibUtil {
         }
     }
 
-    public void removeVrfTable(String rd, WriteTransaction writeConfigTxn) {
+    public void removeVrfTable(String rd, TypedWriteTransaction<Datastore.Configuration> writeConfigTxn) {
         LOG.debug("Removing vrf table for rd {}", rd);
         InstanceIdentifier.InstanceIdentifierBuilder<VrfTables> idBuilder =
             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
         InstanceIdentifier<VrfTables> vrfTableId = idBuilder.build();
 
         if (writeConfigTxn != null) {
-            writeConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vrfTableId);
+            writeConfigTxn.delete(vrfTableId);
         } else {
             Optional<VrfTables> ifStateOptional = MDSALUtil.read(dataBroker,
                     LogicalDatastoreType.CONFIGURATION, vrfTableId);

diff --git a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/LearntVpnVipToPortEventProcessor.java b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/LearntVpnVipToPortEventProcessor.java
index 2e51655616a1bcedeb360432cef953903bc30681..7afe70249c3b493bfd89e9e41336a5f7b5dcfccb 100644 (file)
--- a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/LearntVpnVipToPortEventProcessor.java
+++ b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/LearntVpnVipToPortEventProcessor.java
@@ -27,6 +27,7 @@ import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFaile
 import org.opendaylight.genius.arputil.api.ArpConstants;
 import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.Datastore;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
@@ -183,11 +184,11 @@ public class LearntVpnVipToPortEventProcessor
 
         @Override
         public List<ListenableFuture<Void>> call() {
-            return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(operTx -> {
-                addMipAdjacency(vpnName, interfaceName,
-                        srcIpAddress, macAddress, destIpAddress);
-                vpnUtil.createLearntVpnVipToPort(vpnName, srcIpAddress, interfaceName, macAddress, operTx);
-            }));
+            return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                                                                        Datastore.OPERATIONAL, operTx -> {
+                    addMipAdjacency(vpnName, interfaceName, srcIpAddress, macAddress, destIpAddress);
+                    vpnUtil.createLearntVpnVipToPort(vpnName, srcIpAddress, interfaceName, macAddress, operTx);
+                }));
         }
 
         private void addMipAdjacency(String vpnInstName, String vpnInterface, String srcPrefix, String mipMacAddress,

diff --git a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnOpStatusListener.java b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnOpStatusListener.java
index dede4873280c6bb01ed47f7f7a4e177d7936af71..6bb8829f00e206378ab4d3c1b8fdb9a5938deeea 100644 (file)
--- a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnOpStatusListener.java
+++ b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnOpStatusListener.java
@@ -23,6 +23,7 @@ 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.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.Datastore;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
@@ -111,80 +112,85 @@ public class VpnOpStatusListener extends AsyncDataTreeChangeListenerBase<VpnInst
             jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
                 // Two transactions are used, one for operational, one for config; we only submit the config
                 // transaction if the operational transaction succeeds
-                ListenableFuture<Void> operationalFuture = txRunner.callWithNewWriteOnlyTransactionAndSubmit(operTx -> {
-                    // Clean up VPNExtraRoutes Operational DS
-                    if (VpnUtil.isBgpVpn(vpnName, primaryRd)) {
-                        if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
-                            rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.L2VPN));
+                ListenableFuture<Void> operationalFuture = txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                                                                                Datastore.OPERATIONAL, operTx -> {
+                        // Clean up VPNExtraRoutes Operational DS
+                        if (VpnUtil.isBgpVpn(vpnName, primaryRd)) {
+                            if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
+                                rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
+                                        rd, false, AddressFamily.L2VPN));
+                            }
+                            if (update.isIpv4Configured()) {
+                                rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
+                                        rd, false, AddressFamily.IPV4));
+                            }
+                            if (update.isIpv6Configured()) {
+                                rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
+                                        rd, false, AddressFamily.IPV6));
+                            }
                         }
-                        if (update.isIpv4Configured()) {
-                            rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV4));
+                        InstanceIdentifier<Vpn> vpnToExtraroute =
+                                VpnExtraRouteHelper.getVpnToExtrarouteVpnIdentifier(vpnName);
+                        Optional<Vpn> optVpnToExtraroute = Optional.absent();
+                        try {
+                            optVpnToExtraroute = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                                    LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
+                        } catch (ReadFailedException e) {
+                            LOG.error("update: Failed to read VpnToExtraRoute for vpn {}", vpnName);
                         }
-                        if (update.isIpv6Configured()) {
-                            rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV6));
+                        if (optVpnToExtraroute.isPresent()) {
+                            VpnUtil.removeVpnExtraRouteForVpn(vpnName, operTx);
+                        }
+                        if (VpnUtil.isL3VpnOverVxLan(update.getL3vni())) {
+                            vpnUtil.removeExternalTunnelDemuxFlows(vpnName);
+                        }
+                        // Clean up PrefixToInterface Operational DS
+                        Optional<VpnIds> optPrefixToIntf = Optional.absent();
+                        try {
+                            optPrefixToIntf = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                                    LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId));
+                        } catch (ReadFailedException e) {
+                            LOG.error("update: Failed to read PrefixToInterface for vpn {}", vpnName);
+                        }
+                        if (optPrefixToIntf.isPresent()) {
+                            VpnUtil.removePrefixToInterfaceForVpnId(vpnId, operTx);
+                        }
+                        // Clean up L3NextHop Operational DS
+                        InstanceIdentifier<VpnNexthops> vpnNextHops = InstanceIdentifier.builder(L3nexthop.class).child(
+                                VpnNexthops.class, new VpnNexthopsKey(vpnId)).build();
+                        Optional<VpnNexthops> optL3nexthopForVpnId = Optional.absent();
+                        try {
+                            optL3nexthopForVpnId = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                                    LogicalDatastoreType.OPERATIONAL, vpnNextHops);
+                        } catch (ReadFailedException e) {
+                            LOG.error("update: Failed to read VpnNextHops for vpn {}", vpnName);
+                        }
+                        if (optL3nexthopForVpnId.isPresent()) {
+                            VpnUtil.removeL3nexthopForVpnId(vpnId, operTx);
                         }
-                    }
-                    InstanceIdentifier<Vpn> vpnToExtraroute =
-                            VpnExtraRouteHelper.getVpnToExtrarouteVpnIdentifier(vpnName);
-                    Optional<Vpn> optVpnToExtraroute = Optional.absent();
-                    try {
-                        optVpnToExtraroute = SingleTransactionDataBroker.syncReadOptional(dataBroker,
-                                LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
-                    } catch (ReadFailedException e) {
-                        LOG.error("update: Failed to read VpnToExtraRoute for vpn {}", vpnName);
-                    }
-                    if (optVpnToExtraroute.isPresent()) {
-                        VpnUtil.removeVpnExtraRouteForVpn(vpnName, operTx);
-                    }
-                    if (VpnUtil.isL3VpnOverVxLan(update.getL3vni())) {
-                        vpnUtil.removeExternalTunnelDemuxFlows(vpnName);
-                    }
-                    // Clean up PrefixToInterface Operational DS
-                    Optional<VpnIds> optPrefixToIntf = Optional.absent();
-                    try {
-                        optPrefixToIntf = SingleTransactionDataBroker.syncReadOptional(dataBroker,
-                                LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId));
-                    } catch (ReadFailedException e) {
-                        LOG.error("update: Failed to read PrefixToInterface for vpn {}", vpnName);
-                    }
-                    if (optPrefixToIntf.isPresent()) {
-                        VpnUtil.removePrefixToInterfaceForVpnId(vpnId, operTx);
-                    }
-                    // Clean up L3NextHop Operational DS
-                    InstanceIdentifier<VpnNexthops> vpnNextHops = InstanceIdentifier.builder(L3nexthop.class).child(
-                            VpnNexthops.class, new VpnNexthopsKey(vpnId)).build();
-                    Optional<VpnNexthops> optL3nexthopForVpnId = Optional.absent();
-                    try {
-                        optL3nexthopForVpnId = SingleTransactionDataBroker.syncReadOptional(dataBroker,
-                                LogicalDatastoreType.OPERATIONAL, vpnNextHops);
-                    } catch (ReadFailedException e) {
-                        LOG.error("update: Failed to read VpnNextHops for vpn {}", vpnName);
-                    }
-                    if (optL3nexthopForVpnId.isPresent()) {
-                        VpnUtil.removeL3nexthopForVpnId(vpnId, operTx);
-                    }
 
-                    // Clean up VPNInstanceOpDataEntry
-                    VpnUtil.removeVpnOpInstance(primaryRd, operTx);
-                });
+                        // Clean up VPNInstanceOpDataEntry
+                        VpnUtil.removeVpnOpInstance(primaryRd, operTx);
+                    });
 
                 Futures.addCallback(operationalFuture, new FutureCallback<Void>() {
                     @Override
                     public void onSuccess(Void result) {
-                        Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(confTx -> {
-                            // Clean up VpnInstanceToVpnId from Config DS
-                            VpnUtil.removeVpnIdToVpnInstance(vpnId, confTx);
-                            VpnUtil.removeVpnInstanceToVpnId(vpnName, confTx);
-                            LOG.trace("Removed vpnIdentifier for  rd{} vpnname {}", primaryRd, vpnName);
+                        Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                                                            Datastore.CONFIGURATION, confTx -> {
+                                // Clean up VpnInstanceToVpnId from Config DS
+                                VpnUtil.removeVpnIdToVpnInstance(vpnId, confTx);
+                                VpnUtil.removeVpnInstanceToVpnId(vpnName, confTx);
+                                LOG.trace("Removed vpnIdentifier for  rd{} vpnname {}", primaryRd, vpnName);
 
-                            // Clean up FIB Entries Config DS
-                            synchronized (vpnName.intern()) {
-                                fibManager.removeVrfTable(primaryRd, confTx);
-                            }
-                        }), new VpnOpStatusListener.PostDeleteVpnInstanceWorker(vpnName),
+                                // Clean up FIB Entries Config DS
+                                synchronized (vpnName.intern()) {
+                                    fibManager.removeVrfTable(primaryRd, confTx);
+                                }
+                            }), new VpnOpStatusListener.PostDeleteVpnInstanceWorker(vpnName),
                                 MoreExecutors.directExecutor());
-                        // Note: Release the of VpnId will happen in PostDeleteVpnInstancWorker only if
-                        // operationalTxn/Config succeeds.
+                            // Note: Release the of VpnId will happen in PostDeleteVpnInstancWorker only if
+                            // operationalTxn/Config succeeds.
                     }
 
                     @Override

diff --git a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java
index 6053a56f82befc231ce370ab0492a1bc2a0b16e4..0284a94e3109095aa6f64b6a28d59ece1aea69f8 100644 (file)
--- a/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java
+++ b/vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java
@@ -44,8 +44,10 @@ 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.Datastore;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
@@ -578,14 +580,14 @@ public final class VpnUtil {
         if (vrfTablesOpc.isPresent()) {
             VrfTables vrfTables = vrfTablesOpc.get();
             ListenableFutures.addErrorLogging(
-                    new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(tx -> {
-                        for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
-                            if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
-                                tx.delete(LogicalDatastoreType.CONFIGURATION,
-                                        vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
+                    new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
+                                                                            Datastore.CONFIGURATION, tx -> {
+                            for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
+                                if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
+                                    tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
+                                }
                             }
-                        }
-                    }), LOG, "Error removing VRF entries by origin");
+                        }), LOG, "Error removing VRF entries by origin");
         }
     }
 
@@ -609,12 +611,12 @@ public final class VpnUtil {
         InstanceIdentifier<VrfTables> vpnVrfTableIid =
             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
         ListenableFutures.addErrorLogging(
-                new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(tx -> {
-                    for (VrfEntry vrfEntry : vrfEntries) {
-                        tx.delete(LogicalDatastoreType.CONFIGURATION,
-                                vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
-                    }
-                }), LOG, "Error removing VRF entries");
+                new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
+                                                                            Datastore.CONFIGURATION, tx -> {
+                        for (VrfEntry vrfEntry : vrfEntries) {
+                            tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
+                        }
+                    }), LOG, "Error removing VRF entries");
     }
 
     // TODO Clean up the exception handling
@@ -801,41 +803,47 @@ public final class VpnUtil {
             new ElanTagNameKey(elanTag)).build();
     }
 
-    static void removePrefixToInterfaceForVpnId(long vpnId, @Nonnull WriteTransaction operTx) {
+    static void removePrefixToInterfaceForVpnId(long vpnId,
+                                                       @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
         // Clean up PrefixToInterface Operational DS
-        operTx.delete(LogicalDatastoreType.OPERATIONAL,
-            InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build());
+        operTx.delete(InstanceIdentifier.builder(
+                    PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build());
     }
 
-    static void removeVpnExtraRouteForVpn(String vpnName, @Nonnull WriteTransaction operTx) {
+    static void removeVpnExtraRouteForVpn(String vpnName,
+                                                    @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
         // Clean up VPNExtraRoutes Operational DS
-        operTx.delete(LogicalDatastoreType.OPERATIONAL,
-                InstanceIdentifier.builder(VpnToExtraroutes.class).child(Vpn.class, new VpnKey(vpnName)).build());
+        operTx.delete(InstanceIdentifier.builder(VpnToExtraroutes.class).child(Vpn.class, new VpnKey(vpnName)).build());
     }
 
     // TODO Clean up the exception handling
     @SuppressWarnings("checkstyle:IllegalCatch")
-    static void removeVpnOpInstance(String vpnName, @Nonnull WriteTransaction operTx) {
+    static void removeVpnOpInstance(String vpnName,
+                                                    @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
         // Clean up VPNInstanceOpDataEntry
-        operTx.delete(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName));
+        operTx.delete(getVpnInstanceOpDataIdentifier(vpnName));
     }
 
-    static void removeVpnInstanceToVpnId(String vpnName, @Nonnull WriteTransaction confTx) {
-        confTx.delete(LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
+    static void removeVpnInstanceToVpnId(String vpnName,
+                                                @Nonnull TypedWriteTransaction<Datastore.Configuration> confTx) {
+        confTx.delete(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
     }
 
-    static void removeVpnIdToVpnInstance(long vpnId, @Nonnull WriteTransaction confTx) {
-        confTx.delete(LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId));
+    static void removeVpnIdToVpnInstance(long vpnId,
+                                                @Nonnull TypedWriteTransaction<Datastore.Configuration> confTx) {
+        confTx.delete(getVpnIdToVpnInstanceIdentifier(vpnId));
     }
 
-    static void removeL3nexthopForVpnId(long vpnId, @Nonnull WriteTransaction operTx) {
+    static void removeL3nexthopForVpnId(long vpnId,
+                                               @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
         // Clean up L3NextHop Operational DS
-        operTx.delete(LogicalDatastoreType.OPERATIONAL,
-            InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
+        operTx.delete(InstanceIdentifier.builder(L3nexthop.class).child(
+                                    VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
     }
 
-    void scheduleVpnInterfaceForRemoval(String interfaceName, BigInteger dpnId, String vpnInstanceName,
-                                        Boolean isScheduledToRemove, WriteTransaction writeOperTxn) {
+    void scheduleVpnInterfaceForRemoval(String interfaceName, BigInteger dpnId,
+                                                      String vpnInstanceName, Boolean isScheduledToRemove,
+                                                      TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
         InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
                 getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
         VpnInterfaceOpDataEntry interfaceToUpdate =
@@ -843,14 +851,14 @@ public final class VpnUtil {
             vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
             .setScheduledForRemove(isScheduledToRemove).build();
         if (writeOperTxn != null) {
-            writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate, true);
+            writeOperTxn.merge(interfaceId, interfaceToUpdate, true);
         } else {
             syncUpdate(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
         }
     }
 
-    void createLearntVpnVipToPort(String vpnName, String fixedIp, String portName, String macAddress,
-                                  WriteTransaction writeOperTxn) {
+    void createLearntVpnVipToPort(String vpnName, String fixedIp, String
+            portName, String macAddress, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
         synchronized ((vpnName + fixedIp).intern()) {
             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
             LearntVpnVipToPortBuilder builder =
@@ -859,7 +867,7 @@ public final class VpnUtil {
                             .setMacAddress(macAddress.toLowerCase(Locale.getDefault()))
                             .setCreationTime(new SimpleDateFormat("MM/dd/yyyy h:mm:ss a").format(new Date()));
             if (writeOperTxn != null) {
-                writeOperTxn.put(LogicalDatastoreType.OPERATIONAL, id, builder.build(), true);
+                writeOperTxn.put(id, builder.build(), true);
             } else {
                 syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
             }
@@ -874,11 +882,12 @@ public final class VpnUtil {
                 new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
     }
 
-    void removeLearntVpnVipToPort(String vpnName, String fixedIp, WriteTransaction writeOperTxn) {
+    void removeLearntVpnVipToPort(String vpnName, String fixedIp,
+                                                   TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
         synchronized ((vpnName + fixedIp).intern()) {
             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
             if (writeOperTxn != null) {
-                writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, id);
+                writeOperTxn.delete(id);
             } else {
                 MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
             }
@@ -888,11 +897,11 @@ public final class VpnUtil {
     }
 
     protected static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
-                                                     WriteTransaction writeConfigTxn) {
+                                                     TypedWriteTransaction<Datastore.Configuration> writeConfigTxn) {
         synchronized ((vpnName + fixedIp).intern()) {
             InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
             if (writeConfigTxn != null) {
-                writeConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, id);
+                writeConfigTxn.delete(id);
             } else {
                 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
             }
@@ -903,7 +912,7 @@ public final class VpnUtil {
 
     public void createLearntVpnVipToPortEvent(String vpnName, String srcIp, String destIP, String portName,
                                               String macAddress, LearntVpnVipToPortEventAction action,
-                                              WriteTransaction writeOperTxn) {
+                                              TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
         String eventId = MicroTimestamp.INSTANCE.get();
 
         InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
@@ -912,7 +921,7 @@ public final class VpnUtil {
                 .setDestFixedip(destIP).setPortName(portName)
                 .setMacAddress(macAddress.toLowerCase(Locale.getDefault())).setEventAction(action);
         if (writeOperTxn != null) {
-            writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, id);
+            writeOperTxn.delete(id);
         } else {
             syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
         }
@@ -926,10 +935,10 @@ public final class VpnUtil {
         return id;
     }
 
-    void removeLearntVpnVipToPortEvent(String eventId, WriteTransaction writeOperTxn) {
+    void removeLearntVpnVipToPortEvent(String eventId, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
         InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
         if (writeOperTxn != null) {
-            writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, id);
+            writeOperTxn.delete(id);
         } else {
             MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
         }
@@ -1369,16 +1378,16 @@ public final class VpnUtil {
 
     void bindService(final String vpnInstanceName, final String interfaceName, boolean isTunnelInterface) {
         jobCoordinator.enqueueJob(interfaceName,
-            () -> Collections.singletonList(
-                    txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
-                        BoundServices serviceInfo = isTunnelInterface
-                                ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
-                                : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
-                        tx.put(LogicalDatastoreType.CONFIGURATION, InterfaceUtils.buildServiceId(interfaceName,
-                                ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
-                                        NwConstants.L3VPN_SERVICE_INDEX)),
-                                serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
-                    })), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
+            () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(
+                                                                                Datastore.CONFIGURATION, tx -> {
+                    BoundServices serviceInfo = isTunnelInterface
+                            ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
+                            : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
+                    tx.put(InterfaceUtils.buildServiceId(interfaceName,
+                            ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
+                                    NwConstants.L3VPN_SERVICE_INDEX)),
+                            serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
+                })), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
     }
 
     BoundServices getBoundServicesForVpnInterface(String vpnName, String interfaceName) {
@@ -1416,9 +1425,9 @@ public final class VpnUtil {
     void unbindService(final String vpnInterfaceName, boolean isInterfaceStateDown) {
         if (!isInterfaceStateDown) {
             jobCoordinator.enqueueJob(vpnInterfaceName,
-                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
-                        tx.delete(LogicalDatastoreType.CONFIGURATION,
-                                InterfaceUtils.buildServiceId(vpnInterfaceName,
+                () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+                        Datastore.CONFIGURATION, tx ->
+                        tx.delete(InterfaceUtils.buildServiceId(vpnInterfaceName,
                                         ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
                                                 NwConstants.L3VPN_SERVICE_INDEX))))),
                 SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
@@ -1691,7 +1700,7 @@ public final class VpnUtil {
     ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(String interfaceName) {
         VpnInterfaceBuilder builder = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName))
                 .setScheduledForRemove(false);
-        return txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.OPERATIONAL,
+        return txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL, tx -> tx.merge(
                 VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build(),
                 WriteTransaction.CREATE_MISSING_PARENTS));
     }