fix unclosed ReadTransaction

JIRA : NETVIRT-1295

Change-Id: I5264c49226c8e964a6bcfe2b57b9b3765e5db1fd
Signed-off-by: xcheara <chetan.arakere@altencalsoftlabs.com>
Signed-off-by: Shaik <shaik.b@altencalsoftlabs.com>
Signed-off-by: shaik <shaik.b@altencalsoftlabs.com>

diff --git a/natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalRoutersListener.java b/natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalRoutersListener.java
index 27f1f48bf95a6c3b835bf9470de77ef0d1578d31..77a61ed333bf6e8de516ef2e94414b0437412039 100644 (file)
--- a/natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalRoutersListener.java
+++ b/natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalRoutersListener.java
@@ -38,9 +38,10 @@ import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
 import org.opendaylight.genius.infra.Datastore.Configuration;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
@@ -148,12 +149,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.R
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.RemoveVpnLabelOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.rpc.rev160201.VpnRpcService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
-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;
 import org.slf4j.LoggerFactory;
 
+
 @Singleton
 public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Routers, ExternalRoutersListener> {
     private static final Logger LOG = LoggerFactory.getLogger(ExternalRoutersListener.class);
@@ -421,7 +422,14 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
                 .builder(Subnetmaps.class)
                 .child(Subnetmap.class, new SubnetmapKey(subnet))
                 .build();
-            Optional<Subnetmap> sn = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetmapId);
+            Optional<Subnetmap> sn;
+            try {
+                sn = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                                LogicalDatastoreType.CONFIGURATION, subnetmapId);
+            } catch (ReadFailedException e) {
+                LOG.error("Failed to read SubnetMap for  subnetmap Id {}", subnetmapId, e);
+                sn = Optional.absent();
+            }
             if (sn.isPresent()) {
                 // subnets
                 Subnetmap subnetmapEntry = sn.get();
@@ -582,19 +590,6 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
         }
     }
 
-    // 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);
-        }
-    }
-
     protected void installOutboundMissEntry(String routerName, long routerId, BigInteger primarySwitchId,
         TypedWriteTransaction<Configuration> confTx) {
         LOG.debug("installOutboundMissEntry : Router ID from getVpnId {}", routerId);
@@ -1408,7 +1403,6 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
                                 allocateExternalIp(dpnId, update, routerId, routerName, networkId,
                                         removedInternalIp, writeFlowInvTx);
                             }
-
                             LOG.debug("update : Remove the NAPT translation entries from "
                                     + "Inbound and Outbound NAPT tables for the removed external IPs.");
                             //Get the internalIP and internal Port which were associated to the removed external IP.
@@ -1417,8 +1411,16 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
                             InstanceIdentifier<IpPortMapping> ipPortMappingId = InstanceIdentifier
                                     .builder(IntextIpPortMap.class)
                                     .child(IpPortMapping.class, new IpPortMappingKey(routerId)).build();
-                            Optional<IpPortMapping> ipPortMapping =
-                                    MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, ipPortMappingId);
+                            Optional<IpPortMapping> ipPortMapping;
+                            try {
+                                ipPortMapping = SingleTransactionDataBroker
+                                            .syncReadOptional(dataBroker,
+                                                    LogicalDatastoreType.CONFIGURATION, ipPortMappingId);
+                            } catch (ReadFailedException e) {
+                                LOG.error("Failed to read ipPortMapping for router id {}", routerId, e);
+                                ipPortMapping = Optional.absent();
+                            }
+
                             if (ipPortMapping.isPresent()) {
                                 for (IntextIpProtocolType intextIpProtocolType : requireNonNullElse(
                                         ipPortMapping.get().getIntextIpProtocolType(),
@@ -1601,8 +1603,14 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
 
     private boolean isExternalIpAllocated(String externalIp) {
         InstanceIdentifier<ExternalIpsCounter> id = InstanceIdentifier.builder(ExternalIpsCounter.class).build();
-        Optional<ExternalIpsCounter> externalCountersData =
-            MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+        Optional<ExternalIpsCounter> externalCountersData;
+        try {
+            externalCountersData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                        LogicalDatastoreType.OPERATIONAL, id);
+        } catch (ReadFailedException e) {
+            LOG.error("Failed to read external counters data for ExternalIp {}", externalIp, e);
+            externalCountersData = Optional.absent();
+        }
         if (externalCountersData.isPresent()) {
             ExternalIpsCounter externalIpsCounters = externalCountersData.get();
             for (ExternalCounters ext : requireNonNullElse(externalIpsCounters.getExternalCounters(),
@@ -1831,8 +1839,14 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
             BigInteger naptSwitchDpnId = null;
             InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitch =
                 NatUtil.buildNaptSwitchRouterIdentifier(routerName);
-            Optional<RouterToNaptSwitch> rtrToNapt =
-                read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
+            Optional<RouterToNaptSwitch> rtrToNapt;
+            try {
+                rtrToNapt = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+                                LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
+            } catch (ReadFailedException e) {
+                LOG.error("Failed to read NAPT switch for router {}", routerName, e);
+                rtrToNapt = Optional.absent();
+            }
             if (rtrToNapt.isPresent()) {
                 naptSwitchDpnId = rtrToNapt.get().getPrimarySwitchId();
             }
@@ -2594,8 +2608,15 @@ public class ExternalRoutersListener extends AsyncDataTreeChangeListenerBase<Rou
         InstanceIdentifier<Routers> routerInstanceIndentifier =
             InstanceIdentifier.builder(ExtRouters.class)
                 .child(Routers.class, new RoutersKey(routerUuid.getValue())).build();
-        Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerInstanceIndentifier);
-        return routerData.isPresent() && routerData.get().isEnableSnat();
+        try {
+            Optional<Routers> routerData = SingleTransactionDataBroker
+                    .syncReadOptional(dataBroker,
+                            LogicalDatastoreType.CONFIGURATION, routerInstanceIndentifier);
+            return routerData.isPresent() && routerData.get().isEnableSnat();
+        } catch (ReadFailedException e) {
+            LOG.error("Failed to read data for router id {}", routerUuid, e);
+            return false;
+        }
     }
 
     public void installFlowsWithUpdatedVpnId(BigInteger primarySwitchId, String routerName, long bgpVpnId,