Remove NatUtil::read()

As a step in the MD-SAL utilities clean-up, remove NatUtil::read(),
simply replacing it with
SingleTransactionDataBroker::syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional()
(which is itself deprecated, but I didn’t want to redo the
error-handling in this patch).

Change-Id: I6798e460d7fb61653a5e3f754d5c083fe1084c80
Signed-off-by: Stephen Kitt <skitt@redhat.com>

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java
index a3245f0cbd17e1960dddc90aa53778ef0ac2b16b..bc4fdb5cfe8f903bf1dd51dbc298b0c6adaf9c55 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java
@@ -18,7 +18,6 @@ import org.apache.karaf.shell.console.OsgiCommandSupport;
 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.netvirt.natservice.internal.NatUtil;
 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.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
@@ -65,31 +64,22 @@ public class DisplayNaptSwithcesCli extends OsgiCommandSupport {
         InstanceIdentifier<BridgeRefEntry> bridgeRefInfoPath = InstanceIdentifier.create(BridgeRefInfo.class)
                 .child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId));
 
-        Optional<BridgeRefEntry> bridgeRefEntry = NatUtil.read(dataBroker,LogicalDatastoreType.OPERATIONAL,
-                bridgeRefInfoPath);
+        Optional<BridgeRefEntry> bridgeRefEntry =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
         if (!bridgeRefEntry.isPresent()) {
             return Optional.absent();
         }
 
         InstanceIdentifier<Node> nodeId =
-                ((InstanceIdentifier<OvsdbBridgeAugmentation>) bridgeRefEntry.get().getBridgeReference().getValue())
-                        .firstIdentifierOf(Node.class);
+                bridgeRefEntry.get().getBridgeReference().getValue().firstIdentifierOf(Node.class);
 
-        Optional<Node> node = NatUtil.read(dataBroker,LogicalDatastoreType.OPERATIONAL, nodeId);
-        return node;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.OPERATIONAL, nodeId);
     }
 
     private String getDpnLocalIp(BigInteger dpId) {
-        Optional<Node> node = getPortsNode(dpId);
-
-        if (node.isPresent()) {
-            String localIp = getOpenvswitchOtherConfig(node.get(), LOCAL_IP);
-            if (localIp != null) {
-                return localIp;
-            }
-        }
-
-        return null;
+        return getPortsNode(dpId).transform(node -> getOpenvswitchOtherConfig(node, LOCAL_IP)).orNull();
     }
 
     private String getOpenvswitchOtherConfig(Node node, String key) {
@@ -118,7 +108,8 @@ public class DisplayNaptSwithcesCli extends OsgiCommandSupport {
         if (bridgeAugmentation != null) {
             InstanceIdentifier<Node> ovsdbNodeIid =
                     (InstanceIdentifier<Node>) bridgeAugmentation.getManagedBy().getValue();
-            return NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
+            return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                    LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
         }
         return Optional.absent();
 

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java
index f85fd920c7463ab45f0f1aec9d59091caa86d239..57abe10e45d1ab490d18f6e123e07c543ff9cc86 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java
@@ -63,8 +63,9 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche
             String vpnName = router.getRouterName();
             long vpnId = NatUtil.getVpnId(dataBroker, routerName);
             for (Uuid subnetUuid :router.getSubnetIds()) {
-                Optional<Subnetmap> subnetMapEntry = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
-                        getSubnetMapIdentifier(subnetUuid));
+                Optional<Subnetmap> subnetMapEntry =
+                        SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+                                dataBroker, LogicalDatastoreType.CONFIGURATION, getSubnetMapIdentifier(subnetUuid));
                 if (subnetMapEntry.isPresent()) {
                     Uuid routerPortUuid = subnetMapEntry.get().getRouterInterfacePortId();
                     NatUtil.createOrUpdateVpnToDpnList(dataBroker, vpnId, nextSwitchId, routerPortUuid.getValue(),
@@ -98,8 +99,9 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche
             String vpnName = router.getRouterName();
             long vpnId = NatUtil.getVpnId(dataBroker, vpnName);
             for (Uuid subnetUuid :router.getSubnetIds()) {
-                Optional<Subnetmap> subnetMapEntry = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
-                        getSubnetMapIdentifier(subnetUuid));
+                Optional<Subnetmap> subnetMapEntry =
+                        SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+                                dataBroker, LogicalDatastoreType.CONFIGURATION, getSubnetMapIdentifier(subnetUuid));
                 if (subnetMapEntry.isPresent()) {
                     Uuid routerPortUuid = subnetMapEntry.get().getRouterInterfacePortId();
                     NatUtil.removeOrUpdateVpnToDpnList(dataBroker, vpnId, primarySwitchId, routerPortUuid.getValue(),
@@ -147,8 +149,8 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche
 
     public static NaptSwitches getNaptSwitches(DataBroker dataBroker) {
         InstanceIdentifier<NaptSwitches> id = InstanceIdentifier.builder(NaptSwitches.class).build();
-        Optional<NaptSwitches> naptSwitches = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
-        return naptSwitches.isPresent() ? naptSwitches.get() : null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.CONFIGURATION, id).orNull();
     }
 
     private BigInteger getSwitchWithLowestWeight() {

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java
index a624a9f8f5b03e3c9f1378b9f8fa11bb64382f10..9b2e092bb4d052283a33b050f8eb7bcb8babb828 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java
@@ -24,6 +24,7 @@ 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.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.genius.mdsalutil.MatchInfo;
@@ -195,8 +196,9 @@ public class EvpnDnatFlowProgrammer {
 
         //Read the FIP vpn-interface details from Configuration l3vpn:vpn-interfaces model and write into Operational DS
         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NatUtil.getVpnInterfaceIdentifier(floatingIpInterface);
-        Optional<VpnInterface> optionalVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
-                vpnIfIdentifier);
+        Optional<VpnInterface> optionalVpnInterface =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
         if (optionalVpnInterface.isPresent()) {
             VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
             Adjacencies adjs = vpnIfBuilder.getAugmentation(Adjacencies.class);
@@ -295,15 +297,14 @@ public class EvpnDnatFlowProgrammer {
         });
         //Read the FIP vpn-interface details from Operational l3vpn:vpn-interfaces model and delete from Operational DS
         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NatUtil.getVpnInterfaceIdentifier(floatingIpInterface);
-        Optional<VpnInterface> optionalVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
-                vpnIfIdentifier);
+        Optional<VpnInterface> optionalVpnInterface =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, vpnIfIdentifier);
         if (optionalVpnInterface.isPresent()) {
             WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction();
             LOG.debug("NAT Service : Remove vpnInterface {} to Operational l3vpn:vpn-interfaces ", floatingIpInterface);
             writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, vpnIfIdentifier);
-            if (writeOperTxn != null) {
-                writeOperTxn.submit();
-            }
+            writeOperTxn.submit();
         } else {
             LOG.debug("NAT Service : No vpnInterface {} found in Operational l3vpn:vpn-interfaces ",
                     floatingIpInterface);

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java
index 97a0cf3dbedfa2a92128f8db5016f82ad3d20ff3..d50ee1b1ce6deb977d5ab2944a2ca055a7b26f77 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java
@@ -20,6 +20,7 @@ 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.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
@@ -159,7 +160,9 @@ public class ExternalNetworkListener extends AsyncDataTreeChangeListenerBase<Net
     private void addOrDelDefFibRouteToSNAT(String routerId, boolean create) {
         //Router ID is used as the internal VPN's name, hence the vrf-id in VpnInstance Op DataStore
         InstanceIdentifier<VpnInstanceOpDataEntry> id = NatUtil.getVpnInstanceOpDataIdentifier(routerId);
-        Optional<VpnInstanceOpDataEntry> vpnInstOp = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+        Optional<VpnInstanceOpDataEntry> vpnInstOp =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, id);
         if (vpnInstOp.isPresent()) {
             List<VpnToDpnList> dpnListInVpn = vpnInstOp.get().getVpnToDpnList();
             if (dpnListInVpn != null) {

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java
index 748db4cdd7e7c54dbf552396a6fb5413a4c93eaf..618926380b3e9fea58f518c18a47c394e2af2120 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java
@@ -19,6 +19,7 @@ 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.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
@@ -309,7 +310,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase<Internal
 
     private Uuid getExtNetworkId(final InstanceIdentifier<RouterPorts> portIid,
                                  LogicalDatastoreType dataStoreType) {
-        Optional<RouterPorts> rtrPort = NatUtil.read(dataBroker, dataStoreType, portIid);
+        Optional<RouterPorts> rtrPort =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        dataStoreType, portIid);
         if (!rtrPort.isPresent()) {
             LOG.error("NAT Service : Unable to read router port entry for {}", portIid);
             return null;
@@ -331,7 +334,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase<Internal
 
         InstanceIdentifier<Networks> nwId = InstanceIdentifier.builder(ExternalNetworks.class).child(Networks.class,
                 new NetworksKey(extNwId)).build();
-        Optional<Networks> nw = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, nwId);
+        Optional<Networks> nw =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, nwId);
         if (!nw.isPresent()) {
             LOG.error("NAT Service : Unable to read external network for {}", extNwId);
             return NatConstants.INVALID_ID;
@@ -598,12 +603,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase<Internal
     protected long getOperationalIpMapping(String routerId, String interfaceName, String internalIp) {
         InstanceIdentifier<InternalToExternalPortMap> intExtPortMapIdentifier =
             NatUtil.getIntExtPortMapIdentifier(routerId, interfaceName, internalIp);
-        Optional<InternalToExternalPortMap> intExtPortMap = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
-                intExtPortMapIdentifier);
-        if (intExtPortMap.isPresent()) {
-            return intExtPortMap.get().getLabel();
-        }
-        return NatConstants.INVALID_ID;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.OPERATIONAL, intExtPortMapIdentifier).transform(
+                InternalToExternalPortMap::getLabel).or(NatConstants.INVALID_ID);
     }
 
     static void updateOperationalDS(DataBroker dataBroker, String routerId, String interfaceName, long label,
@@ -611,7 +613,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase<Internal
 
         LOG.info("NAT Service : Updating operational DS for floating ip config : {} with label {}", internalIp, label);
         InstanceIdentifier<Ports> portsId = NatUtil.getPortsIdentifier(routerId, interfaceName);
-        Optional<Ports> optPorts = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, portsId);
+        Optional<Ports> optPorts =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, portsId);
         InternalToExternalPortMap intExtPortMap = new InternalToExternalPortMapBuilder().setKey(new
                 InternalToExternalPortMapKey(internalIp)).setInternalIp(internalIp).setExternalIp(externalIp)
                 .setLabel(label).build();

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java
index eb9fa336ce7fd12d19bdd2e851bbcc48f4ad21f9..f7df4eb922fa2aa73aba18d0d66af66a652b1427 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java
@@ -24,6 +24,7 @@ import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.NwConstants;
 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
@@ -283,7 +284,8 @@ public class InterfaceStateEventListener
         InstanceIdentifier<RouterToNaptSwitch> rtrNaptSw = InstanceIdentifier.builder(NaptSwitches.class)
             .child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build();
         Optional<RouterToNaptSwitch> routerToNaptSwitchData =
-            NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, rtrNaptSw);
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, rtrNaptSw);
         if (routerToNaptSwitchData.isPresent()) {
             RouterToNaptSwitch routerToNaptSwitchInstance = routerToNaptSwitchData.get();
             return routerToNaptSwitchInstance.getPrimarySwitchId();
@@ -330,14 +332,15 @@ public class InterfaceStateEventListener
 
     private List<InternalToExternalPortMap> getIntExtPortMapListForPortName(String portName, String routerId) {
         InstanceIdentifier<Ports> portToIpMapIdentifier = NatUtil.buildPortToIpMapIdentifier(routerId, portName);
-        Optional<Ports> port = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, portToIpMapIdentifier);
+        Optional<Ports> port =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, portToIpMapIdentifier);
         if (!port.isPresent()) {
             LOG.error("NAT Service : Unable to read router port entry for router ID {} and port name {}",
                 routerId, portName);
             return null;
         }
-        List<InternalToExternalPortMap> intExtPortMapList = port.get().getInternalToExternalPortMap();
-        return intExtPortMapList;
+        return port.get().getInternalToExternalPortMap();
     }
 
     private List<String> getFixedIpsForPort(String interfname) {
@@ -414,8 +417,9 @@ public class InterfaceStateEventListener
                                         + " Interface {}. Fetching from VPN Interface op data store. ",
                                 interfaceName, e);
                         InstanceIdentifier<VpnInterface> id = NatUtil.getVpnInterfaceIdentifier(interfaceName);
-                        Optional<VpnInterface> optVpnInterface = NatUtil.read(dataBroker,
-                                LogicalDatastoreType.OPERATIONAL, id);
+                        Optional<VpnInterface> optVpnInterface =
+                                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+                                        dataBroker, LogicalDatastoreType.OPERATIONAL, id);
                         if (!optVpnInterface.isPresent()) {
                             LOG.debug("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName);
                             return futures;

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java
index 30f0eee5d1a3d7e40ea6f7bf5b7f021d967a0506..23801c022f0c6c1e0fadc07deb32301c3087edfc 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java
@@ -24,6 +24,7 @@ import org.apache.commons.net.util.SubnetUtils;
 import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
 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.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
@@ -475,43 +476,35 @@ public class NaptManager {
     }
 
     protected InstanceIdentifier<IpMap> getIpMapIdentifier(long segid, String internal) {
-        InstanceIdentifier<IpMap> id = InstanceIdentifier.builder(IntextIpMap.class)
+        return InstanceIdentifier.builder(IntextIpMap.class)
             .child(IpMapping.class, new IpMappingKey(segid))
             .child(IpMap.class, new IpMapKey(internal)).build();
-        return id;
     }
 
     protected InstanceIdentifier<ExternalIpCounter> getExternalIpsIdentifier(long segmentId, String external) {
-        InstanceIdentifier<ExternalIpCounter> id = InstanceIdentifier.builder(ExternalIpsCounter.class)
+        return InstanceIdentifier.builder(ExternalIpsCounter.class)
             .child(ExternalCounters.class, new ExternalCountersKey(segmentId))
             .child(ExternalIpCounter.class, new ExternalIpCounterKey(external)).build();
-        return id;
     }
 
     public static List<IpMap> getIpMapList(DataBroker broker, Long routerId) {
         InstanceIdentifier<IpMapping> id = getIpMapList(routerId);
-        Optional<IpMapping> ipMappingListData = NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
-        if (ipMappingListData.isPresent()) {
-            IpMapping ipMapping = ipMappingListData.get();
-            return ipMapping.getIpMap();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.OPERATIONAL, id).transform(IpMapping::getIpMap).orNull();
     }
 
     protected static InstanceIdentifier<IpMapping> getIpMapList(long routerId) {
-        InstanceIdentifier<IpMapping> id = InstanceIdentifier.builder(
+        return InstanceIdentifier.builder(
             IntextIpMap.class).child(IpMapping.class, new IpMappingKey(routerId)).build();
-        return id;
     }
 
     protected InstanceIdentifier<IpPortMap> getIpPortMapIdentifier(long segid, String internal,
                                                                    NAPTEntryEvent.Protocol protocol) {
         ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
-        InstanceIdentifier<IpPortMap> id = InstanceIdentifier.builder(IntextIpPortMap.class)
+        return InstanceIdentifier.builder(IntextIpPortMap.class)
             .child(IpPortMapping.class, new IpPortMappingKey(segid))
             .child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
             .child(IpPortMap.class, new IpPortMapKey(internal)).build();
-        return id;
     }
 
     private SessionAddress checkIpPortMap(long segmentId, String internalIpPort,

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java
index 356a6fdcbddbfc4683a3f4179496b074b1aa6a71..00d6bd879a57c827fd315b7fe52b99fd9662582e 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java
@@ -21,6 +21,7 @@ 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.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.BucketInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
@@ -357,7 +358,9 @@ public class NaptSwitchHA {
         List<String> routerUuidsAsString = new ArrayList<>();
         InstanceIdentifier<Networks> extNetwork = InstanceIdentifier.builder(ExternalNetworks.class)
             .child(Networks.class, new NetworksKey(extNetworkId)).build();
-        Optional<Networks> extNetworkData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, extNetwork);
+        Optional<Networks> extNetworkData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, extNetwork);
         if (extNetworkData.isPresent()) {
             List<Uuid> routerUuids = extNetworkData.get().getRouterIds();
             if (routerUuids != null) {
@@ -663,7 +666,9 @@ public class NaptSwitchHA {
         LOG.debug("Querying switch with dpnId {} is up/down", nodeId);
         InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
             .child(Node.class, new NodeKey(nodeId)).build();
-        Optional<Node> nodeOptional = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, nodeInstanceId);
+        Optional<Node> nodeOptional =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, nodeInstanceId);
         if (nodeOptional.isPresent()) {
             LOG.debug("Switch {} is up", nodeId);
             return true;

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java
index 54d10cfd2aa3410851a7eae718b88a907d544a2d..a793c9c05472abeaa86ecceab40cdeae48ee8329 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java
@@ -8,7 +8,6 @@
 
 package org.opendaylight.netvirt.natservice.internal;
 
-import com.google.common.base.Optional;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -19,6 +18,7 @@ import java.util.concurrent.Future;
 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.interfacemanager.globals.IfmConstants;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.genius.mdsalutil.MatchInfo;
@@ -128,11 +128,8 @@ public class NatEvpnUtil {
 
     private static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
         InstanceIdentifier<VpnInstanceOpDataEntry> id = NatUtil.getVpnInstanceOpDataIdentifier(rd);
-        Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
-        if (vpnInstanceOpData.isPresent()) {
-            return vpnInstanceOpData.get();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.OPERATIONAL, id).orNull();
     }
 
     private static boolean isL3VpnOverVxLan(Long l3Vni) {
@@ -231,12 +228,10 @@ public class NatEvpnUtil {
     }
 
     public static Uuid getFloatingIpInterfaceIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
-        InstanceIdentifier id = NatUtil.buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
-        Optional<FloatingIpIdToPortMapping> optFloatingIpIdToPortMapping = NatUtil.read(broker, LogicalDatastoreType
-                .CONFIGURATION, id);
-        if (optFloatingIpIdToPortMapping.isPresent()) {
-            return optFloatingIpIdToPortMapping.get().getFloatingIpPortId();
-        }
-        return null;
+        InstanceIdentifier<FloatingIpIdToPortMapping> id =
+                NatUtil.buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(
+                FloatingIpIdToPortMapping::getFloatingIpPortId).orNull();
     }
 }

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java
index 7d26a570705c7c46c1bd8753db3c09be09b771f1..0b504efaad67f815bd8d2fe36ec5ae5c9f82f56c 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java
@@ -21,6 +21,7 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
@@ -178,8 +179,9 @@ public class NatInterfaceStateChangeListener
                     LOG.warn("NAT Service : Unable to retrieve DPNID from Interface operational data store for "
                             + "Interface {}. Exception {} ", interfaceName, e);
                     InstanceIdentifier<VpnInterface> id = NatUtil.getVpnInterfaceIdentifier(interfaceName);
-                    Optional<VpnInterface> optVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
-                            id);
+                    Optional<VpnInterface> optVpnInterface =
+                            SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+                                    dataBroker, LogicalDatastoreType.OPERATIONAL, id);
                     if (!optVpnInterface.isPresent()) {
                         LOG.warn("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName);
                         return futures;
@@ -229,8 +231,9 @@ public class NatInterfaceStateChangeListener
                             "NAT Service : Unable to retrieve DPN ID from Interface operational data "
                                     + "store for Interface {}. Exception {} ",  update.getName(), e);
                     InstanceIdentifier<VpnInterface> id = NatUtil.getVpnInterfaceIdentifier(interfaceName);
-                    Optional<VpnInterface> optVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
-                            id);
+                    Optional<VpnInterface> optVpnInterface =
+                            SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(
+                                    dataBroker, LogicalDatastoreType.OPERATIONAL, id);
                     if (!optVpnInterface.isPresent()) {
                         LOG.warn("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName);
                         return futures;

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java
index 29fafc40efd30f7e50308987219b52b34e2464e1..209061be560da93a0c01326a5d0a4880f8941b60 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java
@@ -15,6 +15,7 @@ import java.util.concurrent.Future;
 
 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.netvirt.neutronvpn.interfaces.INeutronVpnManager;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
@@ -106,8 +107,9 @@ public class NatOverVxlanUtil {
             lowLimit = Long.parseLong(configureVniRangeSplit[0]);
             highLimit = Long.parseLong(configureVniRangeSplit[1]);
         }
-        Optional<IdPool> existingIdPool = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
-                getIdPoolInstance(poolName));
+        Optional<IdPool> existingIdPool =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, getIdPoolInstance(poolName));
         if (existingIdPool.isPresent()) {
             IdPool odlVniIdPool = existingIdPool.get();
             long currentStartLimit = odlVniIdPool.getAvailableIdsHolder().getStart();

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java
index 8feb30ef800991a52bd61e62b4387b32933b8a20..dff189aab79ee2c3964b5fc798dece26a10b9eb5 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java
@@ -96,10 +96,10 @@ public class NatRouterInterfaceListener
         final String interfaceName = interfaceInfo.getInterfaceId();
 
         //Delete the RouterInterfaces maintained in the ODL:L3VPN configuration model
-        NatUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName));
+        WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
+        writeTxn.delete(LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName));
 
         //Delete the NeutronRouterDpnMap from the ODL:L3VPN operational model
-        WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
         NatUtil.removeFromNeutronRouterDpnsMap(dataBroker, routerId, interfaceName, interfaceManager, writeTxn);
 
         //Delete the DpnRouterMap from the ODL:L3VPN operational model

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java
index 8002f41da81c6bbc425beb35806a2e3c8dac710d..7befb426c80ddf71f73e5ad1dc2469c591712322 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java
@@ -27,6 +27,7 @@ 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.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
 import org.opendaylight.genius.mdsalutil.BucketInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
@@ -363,8 +364,9 @@ public class NatTunnelInterfaceStateListener
             + " : {} and DEST IP: {}", fibManager.getTransportTypeStr(tunnelType), srcTepIp, destTepIp);
 
         InstanceIdentifier<DpnRoutersList> dpnRoutersListId = NatUtil.getDpnRoutersId(srcDpnId);
-        Optional<DpnRoutersList> optionalRouterDpnList = NatUtil.read(dataBroker, LogicalDatastoreType
-            .OPERATIONAL, dpnRoutersListId);
+        Optional<DpnRoutersList> optionalRouterDpnList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, dpnRoutersListId);
         if (!optionalRouterDpnList.isPresent()) {
             LOG.warn("NAT Service : RouterDpnList model is empty for DPN {}. Hence ignoring TEP add event for the ITM "
                     + "TUNNEL TYPE {} b/w SRC IP {} and DST IP {} and TUNNEL NAME {} ",
@@ -422,8 +424,9 @@ public class NatTunnelInterfaceStateListener
 
         List<RoutersList> routersList = null;
         InstanceIdentifier<DpnRoutersList> dpnRoutersListId = NatUtil.getDpnRoutersId(srcDpnId);
-        Optional<DpnRoutersList> optionalRouterDpnList = NatUtil.read(dataBroker, LogicalDatastoreType
-            .OPERATIONAL, dpnRoutersListId);
+        Optional<DpnRoutersList> optionalRouterDpnList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, dpnRoutersListId);
         if (optionalRouterDpnList.isPresent()) {
             routersList = optionalRouterDpnList.get().getRoutersList();
         } else {
@@ -459,8 +462,9 @@ public class NatTunnelInterfaceStateListener
 
         // Check if this is externalRouter else ignore
         InstanceIdentifier<Routers> extRoutersId = NatUtil.buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType
-                .CONFIGURATION, extRoutersId);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, extRoutersId);
         if (!routerData.isPresent()) {
             LOG.debug("NAT Service : SNAT -> Ignoring TEP add for router {} since its not External Router",
                     routerName);
@@ -887,8 +891,9 @@ public class NatTunnelInterfaceStateListener
 
         // Check if this is externalRouter else ignore
         InstanceIdentifier<Routers> extRoutersId = NatUtil.buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType
-                .CONFIGURATION, extRoutersId);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, extRoutersId);
         if (!routerData.isPresent()) {
             LOG.debug("NAT Service : SNAT -> Ignoring TEP del for router {} since its not External Router",
                     routerName);

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java
index e6e8abf6f82db9f808d8f338af740e1dc2cb9e8c..8a035e777a5f5d46fbe6b3c81a6ffda6be56db15 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java
@@ -9,8 +9,6 @@
 package org.opendaylight.netvirt.natservice.internal;
 
 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.math.BigInteger;
 import java.net.InetAddress;
@@ -28,7 +26,6 @@ import java.util.stream.Collectors;
 
 import javax.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;
@@ -206,7 +203,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev14
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.add.group.input.buckets.bucket.action.action.NxActionResubmitRpcAddGroupCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
-import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
@@ -246,7 +242,9 @@ public class NatUtil {
         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
             .instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
-            .instance.to.vpn.id.VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
+                .instance.to.vpn.id.VpnInstance> vpnInstance =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, id);
 
         long vpnId = NatConstants.INVALID_ID;
         if (vpnInstance.isPresent()) {
@@ -310,8 +308,8 @@ public class NatUtil {
     static String getVpnInstanceFromVpnIdentifier(DataBroker broker, long vpnId) {
         InstanceIdentifier<VpnIds> id = InstanceIdentifier.builder(VpnIdToVpnInstance.class)
             .child(VpnIds.class, new VpnIdsKey(vpnId)).build();
-        Optional<VpnIds> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        return vpnInstance.isPresent() ? vpnInstance.get().getVpnInstanceName() : null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(VpnIds::getVpnInstanceName).orNull();
     }
 
     /*
@@ -343,12 +341,9 @@ public class NatUtil {
             LOG.error("getNetworkIdFromRouterName - empty routerName received");
             return null;
         }
-        InstanceIdentifier id = buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (routerData.isPresent()) {
-            return routerData.get().getNetworkId();
-        }
-        return null;
+        InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Routers::getNetworkId).orNull();
     }
 
     static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
@@ -371,41 +366,34 @@ public class NatUtil {
      * @return boolean true if enabled, otherwise false
      */
     static boolean isSnatEnabledForRouterId(DataBroker broker, String routerId) {
-        InstanceIdentifier id = buildRouterIdentifier(routerId);
-        Optional<Routers> routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (routerData.isPresent()) {
-            return routerData.get().isEnableSnat();
-        }
-        return false;
+        InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Routers::isEnableSnat).or(false);
     }
 
     public static Uuid getVpnIdfromNetworkId(DataBroker broker, Uuid networkId) {
         InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
-        Optional<Networks> networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (networkData.isPresent()) {
-            return networkData.get().getVpnid();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getVpnid).orNull();
     }
 
     public static ProviderTypes getProviderTypefromNetworkId(DataBroker broker, Uuid networkId) {
         InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
-        Optional<Networks> networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (networkData.isPresent() && networkData.get() != null) {
-            return networkData.get().getProviderNetworkType();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getProviderNetworkType).orNull();
     }
 
     public static List<Uuid> getRouterIdsfromNetworkId(DataBroker broker, Uuid networkId) {
         InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
-        Optional<Networks> networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        return networkData.isPresent() ? networkData.get().getRouterIds() : Collections.emptyList();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getRouterIds).or(Collections.emptyList());
     }
 
     static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) {
         InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerId);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, id);
         if (routerData.isPresent()) {
             Uuid networkId = routerData.get().getNetworkId();
             if (networkId != null) {
@@ -416,9 +404,8 @@ public class NatUtil {
     }
 
     private static InstanceIdentifier<Networks> buildNetworkIdentifier(Uuid networkId) {
-        InstanceIdentifier<Networks> network = InstanceIdentifier.builder(ExternalNetworks.class)
+        return InstanceIdentifier.builder(ExternalNetworks.class)
             .child(Networks.class, new NetworksKey(networkId)).build();
-        return network;
     }
 
     public static BigInteger getPrimaryNaptfromRouterId(DataBroker broker, Long routerId) {
@@ -432,13 +419,9 @@ public class NatUtil {
             LOG.error("getPrimaryNaptfromRouterName - empty routerName received");
             return null;
         }
-        InstanceIdentifier id = buildNaptSwitchIdentifier(routerName);
-        Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (routerToNaptSwitchData.isPresent()) {
-            RouterToNaptSwitch routerToNaptSwitchInstance = routerToNaptSwitchData.get();
-            return routerToNaptSwitchInstance.getPrimarySwitchId();
-        }
-        return null;
+        InstanceIdentifier<RouterToNaptSwitch> id = buildNaptSwitchIdentifier(routerName);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(RouterToNaptSwitch::getPrimarySwitchId).orNull();
     }
 
     private static InstanceIdentifier<RouterToNaptSwitch> buildNaptSwitchIdentifier(String routerId) {
@@ -448,27 +431,9 @@ public class NatUtil {
     }
 
     public static String getRouterName(DataBroker broker, Long routerId) {
-        InstanceIdentifier id = buildRouterIdentifier(routerId);
-        Optional<RouterIds> routerIdsData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (routerIdsData.isPresent()) {
-            RouterIds routerIdsInstance = routerIdsData.get();
-            return routerIdsInstance.getRouterName();
-        }
-        return null;
-    }
-
-    // TODO Clean up the exception handling
-    @SuppressWarnings("checkstyle:IllegalCatch")
-    public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
-                                                          InstanceIdentifier<T> path) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        try {
-            return tx.read(datastoreType, path).get();
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
+        InstanceIdentifier<RouterIds> id = buildRouterIdentifier(routerId);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(RouterIds::getRouterName).orNull();
     }
 
     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String vrfId) {
@@ -479,15 +444,11 @@ public class NatUtil {
     public static long readVpnId(DataBroker broker, String vpnName) {
         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
             .instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
-        Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
-            .instance.to.vpn.id.VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
-        long vpnId = NatConstants.INVALID_ID;
-        if (vpnInstance.isPresent()) {
-            vpnId = vpnInstance.get().getVpnId();
-        }
-
-        return vpnId;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(
+                org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
+                        .VpnInstance::getVpnId).or(
+                NatConstants.INVALID_ID);
     }
 
     public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, BigInteger cookie, String flowId) {
@@ -517,7 +478,9 @@ public class NatUtil {
         InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
             InstanceIdentifier.builder(DpnEndpoints.class)
                 .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpnId)).build();
-        Optional<DPNTEPsInfo> tunnelInfo = read(broker, LogicalDatastoreType.CONFIGURATION, tunnelInfoId);
+        Optional<DPNTEPsInfo> tunnelInfo =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, tunnelInfoId);
         if (tunnelInfo.isPresent()) {
             List<TunnelEndPoints> nexthopIpList = tunnelInfo.get().getTunnelEndPoints();
             if (nexthopIpList != null && !nexthopIpList.isEmpty()) {
@@ -531,42 +494,34 @@ public class NatUtil {
 
         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
             .instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
-        Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
-            .instance.to.vpn.id.VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
-        String rd = null;
-        if (vpnInstance.isPresent()) {
-            rd = vpnInstance.get().getVrfId();
-        }
-        return rd;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(
+                org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
+                        .VpnInstance::getVrfId).orNull();
     }
 
     public static IpPortExternal getExternalIpPortMap(DataBroker broker, Long routerId, String internalIpAddress,
                                                       String internalPort, NAPTEntryEvent.Protocol protocol) {
         ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
-        InstanceIdentifier ipPortMapId =
+        InstanceIdentifier<IpPortMap> ipPortMapId =
             buildIpToPortMapIdentifier(routerId, internalIpAddress, internalPort, protocolType);
-        Optional<IpPortMap> ipPortMapData = read(broker, LogicalDatastoreType.CONFIGURATION, ipPortMapId);
-        if (ipPortMapData.isPresent()) {
-            IpPortMap ipPortMapInstance = ipPortMapData.get();
-            return ipPortMapInstance.getIpPortExternal();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, ipPortMapId).transform(IpPortMap::getIpPortExternal).orNull();
     }
 
     private static InstanceIdentifier<IpPortMap> buildIpToPortMapIdentifier(Long routerId, String internalIpAddress,
                                                                             String internalPort,
                                                                             ProtocolTypes protocolType) {
-        InstanceIdentifier<IpPortMap> ipPortMapId = InstanceIdentifier.builder(IntextIpPortMap.class)
+        return InstanceIdentifier.builder(IntextIpPortMap.class)
             .child(IpPortMapping.class, new IpPortMappingKey(routerId))
             .child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
             .child(IpPortMap.class, new IpPortMapKey(internalIpAddress + ":" + internalPort)).build();
-        return ipPortMapId;
     }
 
     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName) {
         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
-        return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
     }
 
     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
@@ -576,7 +531,8 @@ public class NatUtil {
 
     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
-        return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).orNull();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, interfaceId).orNull();
     }
 
     public static String getDpnFromNodeConnectorId(NodeConnectorId portId) {
@@ -584,7 +540,7 @@ public class NatUtil {
          * NodeConnectorId is of form 'openflow:dpnid:portnum'
          */
         String[] split = portId.getValue().split(OF_URI_SEPARATOR);
-        if (split == null || split.length != 3) {
+        if (split.length != 3) {
             return null;
         }
         return split[1];
@@ -601,8 +557,9 @@ public class NatUtil {
     public static String getRouterIdfromVpnInstance(DataBroker broker, String vpnName) {
         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
             .child(VpnMap.class, new VpnMapKey(new Uuid(vpnName))).build();
-        Optional<VpnMap> optionalVpnMap = read(broker, LogicalDatastoreType.CONFIGURATION,
-            vpnMapIdentifier);
+        Optional<VpnMap> optionalVpnMap =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
         if (optionalVpnMap.isPresent()) {
             Uuid routerId = optionalVpnMap.get().getRouterId();
             if (routerId != null) {
@@ -614,8 +571,9 @@ public class NatUtil {
 
     static Uuid getVpnForRouter(DataBroker broker, String routerId) {
         InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
-        Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
-            vpnMapsIdentifier);
+        Optional<VpnMaps> optionalVpnMaps =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
         if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
             List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
             if (routerId != null) {
@@ -633,13 +591,9 @@ public class NatUtil {
 
     static long getAssociatedVpn(DataBroker broker, String routerName) {
         InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
-        Optional<Routermapping> optRouterMapping =
-            NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, routerMappingId);
-        if (optRouterMapping.isPresent()) {
-            Routermapping routerMapping = optRouterMapping.get();
-            return routerMapping.getVpnId();
-        }
-        return NatConstants.INVALID_ID;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.OPERATIONAL, routerMappingId).transform(Routermapping::getVpnId).or(
+                NatConstants.INVALID_ID);
     }
 
     public static String getAssociatedVPN(DataBroker dataBroker, Uuid networkId, Logger log) {
@@ -721,14 +675,13 @@ public class NatUtil {
         return routerInstanceIndentifier;
     }
 
+    // TODO non-null
     public static List<Integer> getInternalIpPortListInfo(DataBroker dataBroker, Long routerId,
                                                           String internalIpAddress, ProtocolTypes protocolType) {
-        Optional<IntIpProtoType> optionalIpProtoType = read(dataBroker, LogicalDatastoreType.CONFIGURATION,
-            buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType));
-        if (optionalIpProtoType.isPresent()) {
-            return optionalIpProtoType.get().getPorts();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.CONFIGURATION,
+                buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).transform(
+                IntIpProtoType::getPorts).orNull();
     }
 
     public static InstanceIdentifier<IntIpProtoType> buildSnatIntIpPortIdentifier(Long routerId,
@@ -792,7 +745,8 @@ public class NatUtil {
     }
 
     public static IpPortMapping getIportMapping(DataBroker broker, long routerId) {
-        return read(broker, LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull();
     }
 
     public static InstanceIdentifier<IpPortMapping> getIportMappingIdentifier(long routerId) {
@@ -810,10 +764,12 @@ public class NatUtil {
         return idBuilder;
     }
 
+    // TODO Rework to return non-null Collection
     public static List<String> getExternalIpsForRouter(DataBroker dataBroker, Long routerId) {
         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext
             .ip.map.IpMapping> ipMappingOptional =
-            read(dataBroker, LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
         List<String> externalIps = new ArrayList<>();
         if (ipMappingOptional.isPresent()) {
             List<IpMap> ipMaps = ipMappingOptional.get().getIpMap();
@@ -835,10 +791,12 @@ public class NatUtil {
         return Collections.emptyList();
     }
 
+    // TODO Rework to return non-null Map
     public static HashMap<String, Long> getExternalIpsLabelForRouter(DataBroker dataBroker, Long routerId) {
         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext
             .ip.map.IpMapping> ipMappingOptional =
-            read(dataBroker, LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
         HashMap<String, Long> externalIpsLabel = new HashMap<>();
         if (ipMappingOptional.isPresent()) {
             List<IpMap> ipMaps = ipMappingOptional.get().getIpMap();
@@ -896,12 +854,8 @@ public class NatUtil {
             .builder(Subnetmaps.class)
             .child(Subnetmap.class, new SubnetmapKey(subnetId))
             .build();
-        Optional<Subnetmap> removedSubnet = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetmapId);
-        if (removedSubnet.isPresent()) {
-            Subnetmap subnetMapEntry = removedSubnet.get();
-            return subnetMapEntry.getSubnetIp();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.CONFIGURATION, subnetmapId).transform(Subnetmap::getSubnetIp).orNull();
 
     }
 
@@ -918,7 +872,9 @@ public class NatUtil {
     public static List<BigInteger> getDpnsForRouter(DataBroker dataBroker, String routerUuid) {
         InstanceIdentifier id = InstanceIdentifier.builder(NeutronRouterDpns.class)
             .child(RouterDpnList.class, new RouterDpnListKey(routerUuid)).build();
-        Optional<RouterDpnList> routerDpnListData = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+        Optional<RouterDpnList> routerDpnListData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, id);
         List<BigInteger> dpns = new ArrayList<>();
         if (routerDpnListData.isPresent()) {
             List<DpnVpninterfacesList> dpnVpninterfacesList = routerDpnListData.get().getDpnVpninterfacesList();
@@ -941,13 +897,8 @@ public class NatUtil {
 
     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces
         .RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
-        Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router
-            .interfaces.RouterInterface> optRouterInterface =
-            read(broker, LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName));
-        if (optRouterInterface.isPresent()) {
-            return optRouterInterface.get();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orNull();
     }
 
     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
@@ -980,8 +931,9 @@ public class NatUtil {
                 routerName, dpId, interfaceName);
         InstanceIdentifier<DpnVpninterfacesList> dpnVpnInterfacesListIdentifier = getRouterDpnId(routerName, dpId);
 
-        Optional<DpnVpninterfacesList> optionalDpnVpninterfacesList = read(broker, LogicalDatastoreType
-                .OPERATIONAL, dpnVpnInterfacesListIdentifier);
+        Optional<DpnVpninterfacesList> optionalDpnVpninterfacesList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, dpnVpnInterfacesListIdentifier);
         org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns
             .router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces routerInterface =
             new RouterInterfacesBuilder().setKey(new RouterInterfacesKey(interfaceName))
@@ -1030,8 +982,9 @@ public class NatUtil {
                 dpId, routerName, interfaceName);
         InstanceIdentifier<DpnRoutersList> dpnRoutersListIdentifier = getDpnRoutersId(dpId);
 
-        Optional<DpnRoutersList> optionalDpnRoutersList = read(broker, LogicalDatastoreType.OPERATIONAL,
-                dpnRoutersListIdentifier);
+        Optional<DpnRoutersList> optionalDpnRoutersList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier);
 
         if (optionalDpnRoutersList.isPresent()) {
             RoutersList routersList = new RoutersListBuilder().setKey(new RoutersListKey(routerName))
@@ -1070,8 +1023,9 @@ public class NatUtil {
             return;
         }
         InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
-        Optional<DpnVpninterfacesList> optionalRouterDpnList = NatUtil.read(broker, LogicalDatastoreType
-            .OPERATIONAL, routerDpnListIdentifier);
+        Optional<DpnVpninterfacesList> optionalRouterDpnList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
         if (optionalRouterDpnList.isPresent()) {
             List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router
                 .dpns.router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces> routerInterfaces =
@@ -1101,8 +1055,9 @@ public class NatUtil {
         }
 
         InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
-        Optional<DpnVpninterfacesList> optionalRouterDpnList = NatUtil.read(broker, LogicalDatastoreType
-            .OPERATIONAL, routerDpnListIdentifier);
+        Optional<DpnVpninterfacesList> optionalRouterDpnList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
         if (optionalRouterDpnList.isPresent()) {
             LOG.debug("NAT Service : Removing the dpn-vpninterfaces-list from the odl-l3vpn:neutron-router-dpns model "
                 + "for the router {}", routerName);
@@ -1123,8 +1078,9 @@ public class NatUtil {
             return;
         }
         InstanceIdentifier<DpnVpninterfacesList> routerDpnListIdentifier = getRouterDpnId(routerName, dpId);
-        Optional<DpnVpninterfacesList> optionalRouterDpnList = read(broker, LogicalDatastoreType
-            .OPERATIONAL, routerDpnListIdentifier);
+        Optional<DpnVpninterfacesList> optionalRouterDpnList =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier);
         if (optionalRouterDpnList.isPresent()) {
             List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns
                 .router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces> routerInterfaces =
@@ -1186,8 +1142,9 @@ public class NatUtil {
 
         //Get the dpn-routers-list instance for the current DPN.
         InstanceIdentifier<DpnRoutersList> dpnRoutersListIdentifier = getDpnRoutersId(curDpnId);
-        Optional<DpnRoutersList> dpnRoutersListData = read(broker, LogicalDatastoreType.OPERATIONAL,
-            dpnRoutersListIdentifier);
+        Optional<DpnRoutersList> dpnRoutersListData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier);
 
         if (dpnRoutersListData == null || !dpnRoutersListData.isPresent()) {
             LOG.debug("NAT Service : dpn-routers-list is not present for DPN {} in the ODL-L3VPN:dpn-routers model",
@@ -1197,7 +1154,9 @@ public class NatUtil {
 
         //Get the routers-list instance for the router on the current DPN only
         InstanceIdentifier<RoutersList> routersListIdentifier = getRoutersList(curDpnId, routerName);
-        Optional<RoutersList> routersListData = read(broker, LogicalDatastoreType.OPERATIONAL, routersListIdentifier);
+        Optional<RoutersList> routersListData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, routersListIdentifier);
 
         if (routersListData == null || !routersListData.isPresent()) {
             LOG.debug("NAT Service : routers-list is not present for the DPN {} in the ODL-L3VPN:dpn-routers model",
@@ -1210,8 +1169,9 @@ public class NatUtil {
         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router
             .interfaces.map.RouterInterfaces> routerInterfacesId = getRoutersInterfacesIdentifier(routerName);
         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
-            .RouterInterfaces> routerInterfacesData = read(broker, LogicalDatastoreType.CONFIGURATION,
-            routerInterfacesId);
+                .RouterInterfaces> routerInterfacesData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
 
         if (routerInterfacesData == null || !routerInterfacesData.isPresent()) {
             LOG.debug("NAT Service : Unable to get the routers list for the DPN {}. Possibly all subnets removed"
@@ -1355,11 +1315,13 @@ public class NatUtil {
             portsIdentifier = InstanceIdentifier.create(Neutron.class)
             .child(org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports.class);
         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports>
-            portsOptional = read(broker, LogicalDatastoreType.CONFIGURATION, portsIdentifier);
+                portsOptional =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, portsIdentifier);
 
         if (!portsOptional.isPresent() || portsOptional.get().getPort() == null) {
             LOG.trace("No neutron ports found");
-            return Collections.EMPTY_LIST;
+            return Collections.emptyList();
         }
 
         return portsOptional.get().getPort();
@@ -1399,14 +1361,15 @@ public class NatUtil {
     public static Subnetmap getSubnetMap(DataBroker broker, Uuid subnetId) {
         InstanceIdentifier<Subnetmap> subnetmapId = InstanceIdentifier.builder(Subnetmaps.class)
             .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
-        return read(broker, LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull();
     }
 
     public static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
         InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class)
             .child(NetworkMap.class, new NetworkMapKey(networkId)).build();
-        Optional<NetworkMap> optionalNetworkMap = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        return optionalNetworkMap.isPresent() ? optionalNetworkMap.get().getSubnetIdList() : null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(NetworkMap::getSubnetIdList).orNull();
     }
 
     public static String getSubnetGwMac(DataBroker broker, Uuid subnetId, String vpnName) {
@@ -1416,7 +1379,9 @@ public class NatUtil {
 
         InstanceIdentifier<Subnet> subnetInst = InstanceIdentifier.create(Neutron.class).child(Subnets.class)
             .child(Subnet.class, new SubnetKey(subnetId));
-        Optional<Subnet> subnetOpt = read(broker, LogicalDatastoreType.CONFIGURATION, subnetInst);
+        Optional<Subnet> subnetOpt =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, subnetInst);
         if (!subnetOpt.isPresent()) {
             return null;
         }
@@ -1430,7 +1395,9 @@ public class NatUtil {
         InstanceIdentifier<VpnPortipToPort> portIpInst = InstanceIdentifier.builder(NeutronVpnPortipPortData.class)
             .child(VpnPortipToPort.class, new VpnPortipToPortKey(gatewayIp.getIpv4Address().getValue(), vpnName))
             .build();
-        Optional<VpnPortipToPort> portIpToPortOpt = read(broker, LogicalDatastoreType.CONFIGURATION, portIpInst);
+        Optional<VpnPortipToPort> portIpToPortOpt =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, portIpInst);
         if (portIpToPortOpt.isPresent()) {
             return portIpToPortOpt.get().getMacAddress();
         }
@@ -1438,7 +1405,9 @@ public class NatUtil {
         InstanceIdentifier<LearntVpnVipToPort> learntIpInst = InstanceIdentifier.builder(LearntVpnVipToPortData.class)
             .child(LearntVpnVipToPort.class, new LearntVpnVipToPortKey(gatewayIp.getIpv4Address().getValue(), vpnName))
             .build();
-        Optional<LearntVpnVipToPort> learntIpToPortOpt = read(broker, LogicalDatastoreType.OPERATIONAL, learntIpInst);
+        Optional<LearntVpnVipToPort> learntIpToPortOpt =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.OPERATIONAL, learntIpInst);
         if (learntIpToPortOpt.isPresent()) {
             return learntIpToPortOpt.get().getMacAddress();
         }
@@ -1468,23 +1437,17 @@ public class NatUtil {
     }
 
     protected static String getFloatingIpPortMacFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
-        InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
-        Optional<FloatingIpIdToPortMapping> optFloatingIpIdToPortMapping = read(broker, LogicalDatastoreType
-            .CONFIGURATION, id);
-        if (optFloatingIpIdToPortMapping.isPresent()) {
-            return optFloatingIpIdToPortMapping.get().getFloatingIpPortMacAddress();
-        }
-        return null;
+        InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(
+                FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orNull();
     }
 
     protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
-        InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
-        Optional<FloatingIpIdToPortMapping> optFloatingIpIdToPortMapping = read(broker, LogicalDatastoreType
-            .CONFIGURATION, id);
-        if (optFloatingIpIdToPortMapping.isPresent()) {
-            return optFloatingIpIdToPortMapping.get().getFloatingIpPortSubnetId();
-        }
-        return null;
+        InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(
+                FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orNull();
     }
 
     static InstanceIdentifier<FloatingIpIdToPortMapping> buildfloatingIpIdToPortMappingIdentifier(Uuid floatingIpId) {
@@ -1492,42 +1455,11 @@ public class NatUtil {
             FloatingIpIdToPortMappingKey(floatingIpId)).build();
     }
 
-    static final FutureCallback<Void> DEFAULT_CALLBACK =
-        new FutureCallback<Void>() {
-            @Override
-            public void onSuccess(Void result) {
-                LOG.debug("NAT Service : Success in Datastore operation");
-            }
-
-            @Override
-            public void onFailure(Throwable error) {
-                LOG.error("NAT Service : Error in Datastore operation", error);
-            }
-
-            ;
-        };
-
-    static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
-                                              InstanceIdentifier<T> path) {
-        delete(broker, datastoreType, path, DEFAULT_CALLBACK);
-    }
-
-    static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
-                                              InstanceIdentifier<T> path, FutureCallback<Void> callback) {
-        WriteTransaction tx = broker.newWriteOnlyTransaction();
-        tx.delete(datastoreType, path);
-        Futures.addCallback(tx.submit(), callback);
-    }
-
     static Interface getInterfaceStateFromOperDS(DataBroker dataBroker, String interfaceName) {
         InstanceIdentifier<Interface> ifStateId =
             buildStateInterfaceId(interfaceName);
-        Optional<Interface> ifStateOptional = read(dataBroker, LogicalDatastoreType.OPERATIONAL, ifStateId);
-        if (ifStateOptional.isPresent()) {
-            return ifStateOptional.get();
-        }
-
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.OPERATIONAL, ifStateId).orNull();
     }
 
     static InstanceIdentifier<Interface> buildStateInterfaceId(String interfaceName) {
@@ -1543,11 +1475,8 @@ public class NatUtil {
 
     public static Routers getRoutersFromConfigDS(DataBroker dataBroker, String routerName) {
         InstanceIdentifier<Routers> routerIdentifier = NatUtil.buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerIdentifier);
-        if (routerData.isPresent()) {
-            return routerData.get();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.CONFIGURATION, routerIdentifier).orNull();
     }
 
     static void createRouterIdsConfigDS(DataBroker dataBroker, String routerName) {
@@ -1592,11 +1521,8 @@ public class NatUtil {
     static String getExtGwMacAddFromRouterId(DataBroker broker, long routerId) {
         String routerName = getRouterName(broker, routerId);
         InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-        if (routerData.isPresent()) {
-            return routerData.get().getExtGwMacAddress();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, id).transform(Routers::getExtGwMacAddress).orNull();
     }
 
     static InstanceIdentifier<Router> buildNeutronRouterIdentifier(Uuid routerUuid) {
@@ -1608,29 +1534,23 @@ public class NatUtil {
 
     public static String getNeutronRouterNamebyUuid(DataBroker broker, Uuid routerUuid) {
         InstanceIdentifier<Router> neutronRouterIdentifier = NatUtil.buildNeutronRouterIdentifier(routerUuid);
-        Optional<Router> neutronRouterData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
-                neutronRouterIdentifier);
-        if (neutronRouterData.isPresent()) {
-            return neutronRouterData.get().getName();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).transform(Router::getName).orNull();
     }
 
+    // TODO Rework to return non-null
     public static List<Ports> getFloatingIpPortsForRouter(DataBroker broker, Uuid routerUuid) {
-
         InstanceIdentifier<RouterPorts> routerPortsIdentifier = getRouterPortsId(routerUuid.getValue());
-        Optional<RouterPorts> routerPortsData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
-                routerPortsIdentifier);
-        if (routerPortsData.isPresent()) {
-            return routerPortsData.get().getPorts();
-        }
-        return null;
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION,
+                routerPortsIdentifier).transform(RouterPorts::getPorts).orNull();
     }
 
     public static List<Uuid> getRouterUuIdsForVpn(DataBroker broker, Uuid vpnUuid) {
         InstanceIdentifier<ExternalNetworks> externalNwIdentifier = InstanceIdentifier.create(ExternalNetworks.class);
-        Optional<ExternalNetworks> externalNwData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
-                externalNwIdentifier);
+        Optional<ExternalNetworks> externalNwData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                        LogicalDatastoreType.CONFIGURATION, externalNwIdentifier);
         if (externalNwData.isPresent()) {
             for (Networks externalNw : externalNwData.get().getNetworks()) {
                 if (externalNw.getVpnid() != null && externalNw.getVpnid().equals(vpnUuid)) {
@@ -1659,8 +1579,7 @@ public class NatUtil {
             return Collections.emptyList();
         }
 
-        Set<Uuid> subnetsSet = externalIps.stream().map(externalIp -> externalIp.getSubnetId())
-                .collect(Collectors.toSet());
+        Set<Uuid> subnetsSet = externalIps.stream().map(ExternalIps::getSubnetId).collect(Collectors.toSet());
         return new ArrayList<>(subnetsSet);
     }
 
@@ -1671,7 +1590,9 @@ public class NatUtil {
         }
 
         InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
-        Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, id);
         if (routerData.isPresent()) {
             return NatUtil.getExternalSubnetIdsFromExternalIps(routerData.get().getExternalIps());
         } else {
@@ -1693,7 +1614,8 @@ public class NatUtil {
                 InstanceIdentifier.builder(ExternalSubnets.class)
                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
                         .rev160111.external.subnets.Subnets.class, new SubnetsKey(subnetId)).build();
-        return read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
     }
 
     protected static long getExternalSubnetVpnId(DataBroker dataBroker, Uuid subnetId) {
@@ -1746,19 +1668,19 @@ public class NatUtil {
             return Collections.emptyList();
         }
 
-        return externalIps.stream().map(externalIp -> externalIp.getIpAddress()).collect(Collectors.toList());
+        return externalIps.stream().map(ExternalIps::getIpAddress).collect(Collectors.toList());
     }
 
     // elan-instances config container
     public static ElanInstance getElanInstanceByName(String elanInstanceName, DataBroker broker) {
         InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
-        return read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+        return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+                LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
     }
 
     public static InstanceIdentifier<ElanInstance> getElanInstanceConfigurationDataPath(String elanInstanceName) {
         return InstanceIdentifier.builder(ElanInstances.class)
                 .child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
-
     }
 
     public static long getTunnelIdForNonNaptToNaptFlow(DataBroker dataBroker, IElanService elanManager,
@@ -1852,7 +1774,9 @@ public class NatUtil {
 
         synchronized (vpnName.intern()) {
             InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(primaryRd, dpnId);
-            Optional<VpnToDpnList> dpnInVpn = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+            Optional<VpnToDpnList> dpnInVpn =
+                    SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                            LogicalDatastoreType.OPERATIONAL, id);
             org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance
                 .op.data.entry.vpn.to.dpn.list.VpnInterfaces vpnInterface = new VpnInterfacesBuilder()
                 .setInterfaceName(intfName).build();
@@ -1898,7 +1822,9 @@ public class NatUtil {
         String rd = getVpnRd(dataBroker, vpnName);
         synchronized (vpnName.intern()) {
             InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(rd, dpnId);
-            VpnToDpnList dpnInVpn = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id).orNull();
+            VpnToDpnList dpnInVpn =
+                    SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                            LogicalDatastoreType.OPERATIONAL, id).orNull();
             if (dpnInVpn == null) {
                 LOG.error("removeOrUpdateVpnToDpnList: Could not find DpnToVpn map for VPN=[name={} rd={} id={}]"
                     + " and dpnId={}", vpnName, rd, id, dpnId);
@@ -1946,7 +1872,9 @@ public class NatUtil {
 
     public static String getPrimaryRd(DataBroker dataBroker, String vpnName) {
         InstanceIdentifier<VpnInstance> id  = getVpnInstanceIdentifier(vpnName);
-        Optional<VpnInstance> vpnInstance = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+        Optional<VpnInstance> vpnInstance =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, id);
         if (vpnInstance.isPresent()) {
             return getPrimaryRd(vpnInstance.get());
         }

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java
index 62c188a00ce6ef43d32fb6e55cb17b2d4f85eba9..95741ac993cc675bc920ace5487561919b975d3b 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java
@@ -19,6 +19,7 @@ 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.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.BucketInfo;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.GroupEntity;
@@ -108,7 +109,9 @@ public class RouterDpnChangeListener
         BigInteger dpnId = dpnInfo.getDpnId();
         //check router is associated to external network
         InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerId);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, id);
         if (routerData.isPresent()) {
             Routers router = routerData.get();
             Uuid networkId = router.getNetworkId();
@@ -181,7 +184,9 @@ public class RouterDpnChangeListener
         BigInteger dpnId = dpnInfo.getDpnId();
         //check router is associated to external network
         InstanceIdentifier<Routers> id = NatUtil.buildRouterIdentifier(routerId);
-        Optional<Routers> routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+        Optional<Routers> routerData =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.CONFIGURATION, id);
         if (routerData.isPresent()) {
             Routers router = routerData.get();
             Uuid networkId = router.getNetworkId();

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java
index 0b3dd2cc2ca0404e2597b74d66382fb499693418..a69d542ffa5541fd3690444344c3092c2fb232d3 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java
@@ -14,6 +14,7 @@ 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.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpInfo;
@@ -61,7 +62,9 @@ public class RouterPortsListener
     @Override
     protected void add(final InstanceIdentifier<RouterPorts> identifier, final RouterPorts routerPorts) {
         LOG.trace("Add router ports method - key: " + identifier + ", value=" + routerPorts);
-        Optional<RouterPorts> optRouterPorts = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier);
+        Optional<RouterPorts> optRouterPorts =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, identifier);
         if (optRouterPorts.isPresent()) {
             RouterPorts ports = optRouterPorts.get();
             String routerName = ports.getRouterId();
@@ -80,7 +83,8 @@ public class RouterPortsListener
         if (vpnName != null) {
             InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
             Optional<Routermapping> optRouterMapping =
-                NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, routerMappingId);
+                    SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                            LogicalDatastoreType.OPERATIONAL, routerMappingId);
             if (!optRouterMapping.isPresent()) {
                 Long vpnId = NatUtil.getVpnId(dataBroker, vpnName.getValue());
                 LOG.debug("Updating router {} to VPN {} association with Id {}", routerName, vpnName, vpnId);

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java
index 683f0c377fa9f30ff29860673c30dd2bd0bb6638..b795a406fc8ac6e64db021c013aaf0607717e513 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java
@@ -19,6 +19,7 @@ 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.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.FlowEntity;
 import org.opendaylight.genius.mdsalutil.InstructionInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
@@ -174,8 +175,9 @@ public class SNATDefaultRouteProgrammer {
         String subnetId = subnet.getId().getValue();
         InstanceIdentifier<VpnInstanceOpDataEntry> networkVpnInstanceIdentifier =
             NatUtil.getVpnInstanceOpDataIdentifier(networkId);
-        Optional<VpnInstanceOpDataEntry> networkVpnInstanceOp = NatUtil.read(dataBroker,
-                LogicalDatastoreType.OPERATIONAL, networkVpnInstanceIdentifier);
+        Optional<VpnInstanceOpDataEntry> networkVpnInstanceOp =
+                SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, networkVpnInstanceIdentifier);
         if (networkVpnInstanceOp.isPresent()) {
             List<VpnToDpnList> dpnListInVpn = networkVpnInstanceOp.get().getVpnToDpnList();
             if (dpnListInVpn != null) {

diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java
index 3248ec2ac16109145faf219de386a7041819d9bc..962665d234d20dd7890da2a364041b65bae1d949 100644 (file)
--- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java
+++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java
@@ -25,6 +25,7 @@ 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.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.mdsalutil.ActionInfo;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.genius.mdsalutil.MatchInfo;
@@ -478,7 +479,8 @@ public class VpnFloatingIpHandler implements FloatingIPHandler {
         InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
         try {
             Optional<FloatingIpIdToPortMapping> optFloatingIpIdToPortMapping =
-                NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+                    SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
+                            LogicalDatastoreType.CONFIGURATION, id);
             if (optFloatingIpIdToPortMapping.isPresent() && optFloatingIpIdToPortMapping.get().isFloatingIpDeleted()) {
                 LOG.debug("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating "
                     + "IP Port Info Config DS", floatingIpId.getValue());