Cleanup Optional uses

* Use functional transforms where possible.
* Remove uses of Optional which are only null-checks (Optional.of()
  immediately followed by .isPresent()).
* Use try-with-resources for transactions where appropriate (and
  spotted during Optional cleanup).

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

diff --git a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AbstractAlivenessProtocolHandler.java b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AbstractAlivenessProtocolHandler.java
index 125b6b3cec06607c82570dc68b54f90f52ae37de..1b345c077ce01947e3446a76df2e542ba16ed18f 100644 (file)
--- a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AbstractAlivenessProtocolHandler.java
+++ b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AbstractAlivenessProtocolHandler.java
@@ -54,8 +54,7 @@ abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHand
         InstanceIdentifier<Interface> id =  InstanceIdentifier.builder(Interfaces.class)
                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
 
-        Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
-        if(port.isPresent()) {
+        if (read(LogicalDatastoreType.CONFIGURATION, id).isPresent()) {
             NodeConnectorId ncId = getNodeConnectorIdFromInterface(interfaceName);
             NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
 
@@ -95,11 +94,7 @@ abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHand
                 InstanceIdentifier.builder(InterfacesState.class).child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
                         new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id = idBuilder.build();
-        Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateOptional = read(LogicalDatastoreType.OPERATIONAL, id);
-        if(interfaceStateOptional.isPresent()) {
-            return interfaceStateOptional.get();
-        }
-        return null;
+        return read(LogicalDatastoreType.OPERATIONAL, id).orNull();
     }
 
     protected byte[] getMacAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState, String interfaceName) {
@@ -119,28 +114,16 @@ abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHand
     protected Interface getInterfaceFromConfigDS(String interfaceName) {
         InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
         InstanceIdentifier<Interface> interfaceId = getInterfaceIdentifier(interfaceKey);
-        Optional<Interface> interfaceOptional = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
-        if (!interfaceOptional.isPresent()) {
-            return null;
-        }
-
-        return interfaceOptional.get();
+        return read(LogicalDatastoreType.CONFIGURATION, interfaceId).orNull();
     }
 
     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
                                                     InstanceIdentifier<T> path) {
 
-        ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
-        } finally {
-            tx.close();
         }
-
-        return result;
     }
 }

diff --git a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AlivenessMonitor.java b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AlivenessMonitor.java
index 30ea39005c016dbd38adb92d14e94c1d3cc0692f..5f507d2a94d54a86776fb5414c1c774fd14db3b4 100644 (file)
--- a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AlivenessMonitor.java
+++ b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/AlivenessMonitor.java
@@ -231,13 +231,8 @@ public class AlivenessMonitor implements AlivenessMonitorService, PacketProcessi
                 .build(new CacheLoader<Long, String>() {
                     @Override
                     public String load(Long monitorId) throws Exception {
-                        String monitorKey = null;
-                        Optional<MonitoridKeyEntry> optKey =
-                                read(LogicalDatastoreType.OPERATIONAL, getMonitorMapId(monitorId));
-                        if (optKey.isPresent()) {
-                            monitorKey = optKey.get().getMonitorKey();
-                        }
-                        return monitorKey;
+                        return read(LogicalDatastoreType.OPERATIONAL, getMonitorMapId(monitorId)).transform(
+                                MonitoridKeyEntry::getMonitorKey).orNull();
                     }
                 });
     }
@@ -758,11 +753,11 @@ public class AlivenessMonitor implements AlivenessMonitorService, PacketProcessi
 
     private boolean stopMonitoringTask(Long monitorId, boolean interruptTask) {
         Optional<MonitoringInfo> optInfo = read(LogicalDatastoreType.OPERATIONAL, getMonitoringInfoId(monitorId));
-        MonitoringInfo monitoringInfo = optInfo.get();
-        if (monitoringInfo == null) {
+        if (!optInfo.isPresent()) {
             LOG.warn("There is no monitoring info present for monitor id {}", monitorId);
             return false;
         }
+        MonitoringInfo monitoringInfo = optInfo.get();
         Optional<MonitorProfile> optProfile = read(LogicalDatastoreType.OPERATIONAL,
                 getMonitorProfileId(monitoringInfo.getProfileId()));
         EtherTypes protocolType = optProfile.get().getProtocolType();
@@ -1308,18 +1303,13 @@ public class AlivenessMonitor implements AlivenessMonitorService, PacketProcessi
 
     //DATA STORE OPERATIONS
     <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
-        ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (InterruptedException | ExecutionException e) {
             LOG.warn("Error reading data from path {} in datastore {}", path, datastoreType, e);
-        } finally {
-            tx.close();
         }
 
-        return result;
+        return Optional.absent();
     }
 
     @Override
@@ -1349,13 +1339,8 @@ public class AlivenessMonitor implements AlivenessMonitorService, PacketProcessi
     }
 
     private List<Long> getMonitorIds(String interfaceName) {
-        Optional<InterfaceMonitorEntry> optEntry = read(LogicalDatastoreType.OPERATIONAL,
-                                                           getInterfaceMonitorMapId(interfaceName));
-        if (optEntry.isPresent()) {
-            InterfaceMonitorEntry entry = optEntry.get();
-            return entry.getMonitorIds();
-        }
-        return Collections.emptyList();
+        return read(LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName)).transform(
+                InterfaceMonitorEntry::getMonitorIds).or(Collections.emptyList());
     }
 
 }

diff --git a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/InventoryReader.java b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/InventoryReader.java
index e2ea62cf98d74f41b209af3ea233726d84374dc9..78ea32690335c4db08392dac5713a9de02722659 100644 (file)
--- a/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/InventoryReader.java
+++ b/alivenessmonitor/alivenessmonitor-impl/src/main/java/org/opendaylight/genius/alivenessmonitor/internal/InventoryReader.java
@@ -41,17 +41,10 @@ class InventoryReader {
 
     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
                                                     InstanceIdentifier<T> path) {
-
-        ReadOnlyTransaction tx = dataService.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = dataService.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
-        tx.close();
-
-        return result;
     }
 }

diff --git a/alivenessmonitor/alivenessmonitor-impl/src/test/java/org/opendaylight/controller/alivenessmonitor/test/AlivenessMonitorTest.java b/alivenessmonitor/alivenessmonitor-impl/src/test/java/org/opendaylight/controller/alivenessmonitor/test/AlivenessMonitorTest.java
index 43136267bc6a8b4209ff501c9d963da5a72ce81a..043977f898324301cda94f84d5c21dd0edb0eb73 100644 (file)
--- a/alivenessmonitor/alivenessmonitor-impl/src/test/java/org/opendaylight/controller/alivenessmonitor/test/AlivenessMonitorTest.java
+++ b/alivenessmonitor/alivenessmonitor-impl/src/test/java/org/opendaylight/controller/alivenessmonitor/test/AlivenessMonitorTest.java
@@ -212,11 +212,9 @@ public class AlivenessMonitorTest {
                                                                 .setMode(MonitoringMode.OneOne)
                                                                 .setProfileId(profileId).build()).build();
         @SuppressWarnings("unchecked")
-        Optional<MonitorProfile> optionalProfile = (Optional<MonitorProfile>)mock(Optional.class);
+        Optional<MonitorProfile> optionalProfile = Optional.of(getTestMonitorProfile());
         CheckedFuture<Optional<MonitorProfile>, ReadFailedException> proFuture = Futures.immediateCheckedFuture(optionalProfile);
         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL), argThat(isType(MonitorProfile.class)))).thenReturn(proFuture);
-        doReturn(true).when(optionalProfile).isPresent();
-        doReturn(getTestMonitorProfile()).when(optionalProfile).get();
         CheckedFuture<Optional<MonitoringInfo>, ReadFailedException> outFuture = Futures.immediateCheckedFuture(Optional.<MonitoringInfo>absent());
         when(readTx.read(eq(LogicalDatastoreType.OPERATIONAL), argThat(isType(MonitoringInfo.class)))).thenReturn(outFuture);
         RpcResult<MonitorStartOutput> output = alivenessMonitor.monitorStart(input).get();

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
index ba549c81acb63d70062e059c1acd7abeff98ad00..60b59cd4a577188717be0f10f22d30279054389e 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.fcapsapp;
 
-import com.google.common.base.Optional;
 import java.net.InetAddress;
 import java.util.Collection;
 import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
@@ -120,11 +119,7 @@ public class NodeEventListener<D extends DataObject> implements ClusteredDataTre
      */
     public boolean isNodeOwner(String nodeId) {
         Entity entity = new Entity("openflow", nodeId);
-        Optional<EntityOwnershipState> entityState = this.entityOwnershipService.getOwnershipState(entity);
-        if (entityState.isPresent()) {
-            return entityState.get().isOwner();
-        }
-        return false;
+        return this.entityOwnershipService.getOwnershipState(entity).transform(EntityOwnershipState::isOwner).or(false);
     }
 
     @Override

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
index 49f7743a5344ce7099a97714a02eec1f80875a3b..ec5b3c522a8dfa0b146774ef8e7c20d7ad3475a5 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.fcapsapp.performancecounter;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Iterables;
@@ -165,11 +164,7 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
      */
     public boolean isNodeOwner(String nodeId) {
         Entity entity = new Entity("openflow", nodeId);
-        Optional<EntityOwnershipState> eState = this.entityOwnershipService.getOwnershipState(entity);
-        if(eState.isPresent()) {
-            return eState.get().isOwner();
-        }
-        return false;
+        return this.entityOwnershipService.getOwnershipState(entity).transform(EntityOwnershipState::isOwner).or(false);
     }
 
     private boolean compareInstanceIdentifierTail(InstanceIdentifier<?> identifier1,

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
index 5f9b1bd57195792352840c7d7d5aa356c84bfd20..7793f3fa2f71f5c4070b77a0b047653020fbe8d5 100755 (executable)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
@@ -203,17 +203,11 @@ public class IfmUtil {
 
     public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
                                                           InstanceIdentifier<T> path, DataBroker broker) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
-
-        return result;
     }
 
     public static List<Action> getEgressActionsForInterface(String interfaceName, Long tunnelKey, Integer actionKey,
@@ -415,13 +409,8 @@ public class IfmUtil {
                 InstanceIdentifier.builder(Nodes.class)
                         .child(Node.class, new NodeKey(getNodeIdFromNodeConnectorId(ncId)))
                         .child(NodeConnector.class, new NodeConnectorKey(ncId)).build();
-        Optional<NodeConnector> optNc = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier, dataBroker);
-        if(optNc.isPresent()) {
-            NodeConnector nc = optNc.get();
-            FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class);
-            return fcnc.getName();
-        }
-        return null;
+        return read(LogicalDatastoreType.OPERATIONAL, ncIdentifier, dataBroker).transform(
+                nc -> nc.getAugmentation(FlowCapableNodeConnector.class).getName()).orNull();
     }
 
     public static NodeConnectorId getNodeConnectorIdFromInterface(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState){

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/AlivenessMonitorUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/AlivenessMonitorUtils.java
index c4706e53d89afdae53414182ce350e1e9bf23fce..857f50678555f29e8d5d67e5f59bd59929c05c67 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/AlivenessMonitorUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/AlivenessMonitorUtils.java
@@ -112,17 +112,14 @@ public class AlivenessMonitorUtils {
 
     public static String getInterfaceFromMonitorId(DataBroker broker, Long monitorId) {
         InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class).child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
-        Optional<MonitorIdInterface> interfaceMonitorIdMap = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker);
-        if(interfaceMonitorIdMap.isPresent()) {
-            return interfaceMonitorIdMap.get().getInterfaceName();
-        }
-        return null;
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker).transform(
+                MonitorIdInterface::getInterfaceName).orNull();
     }
 
     private static void removeMonitorIdInterfaceMap(DataBroker broker, long monitorId) {
         InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class).child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
         Optional<MonitorIdInterface> monitorIdInterfaceMap = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker);
-        if(monitorIdInterfaceMap.isPresent()) {
+        if (monitorIdInterfaceMap.isPresent()) {
             MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
         }
     }
@@ -130,7 +127,7 @@ public class AlivenessMonitorUtils {
     private static void removeMonitorIdFromInterfaceMonitorIdMap(DataBroker broker, String infName, long monitorId) {
         InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class).child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
         Optional<InterfaceMonitorId> interfaceMonitorIdMap = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker);
-        if(interfaceMonitorIdMap.isPresent()) {
+        if (interfaceMonitorIdMap.isPresent()) {
             InterfaceMonitorId interfaceMonitorIdInstance = interfaceMonitorIdMap.get();
             List<Long> existingMonitorIds = interfaceMonitorIdInstance.getMonitorId();
             if (existingMonitorIds != null && existingMonitorIds.contains(monitorId)) {
@@ -218,11 +215,8 @@ public class AlivenessMonitorUtils {
 
     public static List<Long> getMonitorIdForInterface(DataBroker broker, String infName) {
         InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class).child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
-        Optional<InterfaceMonitorId> interfaceMonitorIdMap = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker);
-        if(interfaceMonitorIdMap.isPresent()) {
-            return interfaceMonitorIdMap.get().getMonitorId();
-        }
-        return null;
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker).transform(
+                InterfaceMonitorId::getMonitorId).orNull();
     }
 
     public static long createMonitorProfile(AlivenessMonitorService alivenessMonitor, MonitorProfileCreateInput monitorProfileCreateInput) {

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
index 1ca38eef7aba6d6302cb66bb675e50d6003faac5..9c66d3c5f819d6716b1054b955aab29e8a32c542 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
@@ -12,9 +12,7 @@ import com.google.common.base.Optional;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.math.BigInteger;
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Matcher;
@@ -50,7 +48,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.met
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterfaceBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterfaceKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntry;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntryBuilder;
@@ -86,12 +83,7 @@ public class InterfaceManagerCommonUtils {
                 .child(Node.class, new NodeKey(nodeId))
                 .child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)).build();
 
-        Optional<NodeConnector> nodeConnectorOptional = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ncIdentifier,
-                dataBroker);
-        if (!nodeConnectorOptional.isPresent()) {
-            return null;
-        }
-        return nodeConnectorOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ncIdentifier, dataBroker).orNull();
     }
 
     public static boolean isNodePresent(DataBroker dataBroker, NodeConnectorId nodeConnectorId) {
@@ -175,13 +167,7 @@ public class InterfaceManagerCommonUtils {
     public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateFromOperDS(
             InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId,
             DataBroker dataBroker) {
-        Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = IfmUtil
-                .read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker);
-        if (!ifStateOptional.isPresent()) {
-            return null;
-        }
-
-        return ifStateOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orNull();
     }
 
     public static void makeTunnelIngressFlow(List<ListenableFuture<Void>> futures, IMdsalApiManager mdsalApiManager,

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceMetaUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceMetaUtils.java
index 8c7e5b8532ae733f509a05d30aaa49abfe29a3ad..17c479f195c0a8f56511ccfd80e9c5d6b9e6d2b7 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceMetaUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceMetaUtils.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.interfacemanager.commons;
 
-import com.google.common.base.Optional;
 import java.math.BigInteger;
 import java.util.List;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -63,12 +62,7 @@ public class InterfaceMetaUtils {
 
     public static BridgeRefEntry getBridgeRefEntryFromOperDS(InstanceIdentifier<BridgeRefEntry> dpnBridgeEntryIid,
                                                              DataBroker dataBroker) {
-        Optional<BridgeRefEntry> bridgeRefEntryOptional =
-                IfmUtil.read(LogicalDatastoreType.OPERATIONAL, dpnBridgeEntryIid, dataBroker);
-        if (!bridgeRefEntryOptional.isPresent()) {
-            return null;
-        }
-        return bridgeRefEntryOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, dpnBridgeEntryIid, dataBroker).orNull();
     }
 
     public static OvsdbBridgeRef getBridgeRefEntryFromOperDS(BigInteger dpId,
@@ -104,11 +98,7 @@ public class InterfaceMetaUtils {
         if (bridgeRefEntry != null && bridgeRefEntry.getBridgeReference() != null) {
             InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
                     (InstanceIdentifier<OvsdbBridgeAugmentation>) bridgeRefEntry.getBridgeReference().getValue();
-            Optional<OvsdbBridgeAugmentation> bridgeNodeOptional =
-                    IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeIid, dataBroker);
-            if (bridgeNodeOptional.isPresent()) {
-                return true;
-            }
+            return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeIid, dataBroker).isPresent();
         }
         return false;
     }
@@ -130,12 +120,7 @@ public class InterfaceMetaUtils {
 
     public static BridgeEntry getBridgeEntryFromConfigDS(InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier,
                                                          DataBroker dataBroker) {
-        Optional<BridgeEntry> bridgeEntryOptional =
-                IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker);
-        if (!bridgeEntryOptional.isPresent()) {
-            return null;
-        }
-        return bridgeEntryOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, bridgeEntryInstanceIdentifier, dataBroker).orNull();
     }
 
     public static InstanceIdentifier<BridgeInterfaceEntry> getBridgeInterfaceEntryIdentifier(BridgeEntryKey bridgeEntryKey,
@@ -192,12 +177,7 @@ public class InterfaceMetaUtils {
 
     public static InterfaceParentEntry getInterfaceParentEntryFromConfigDS(
             InstanceIdentifier<InterfaceParentEntry> intfId, DataBroker dataBroker) {
-        Optional<InterfaceParentEntry> interfaceParentEntryOptional =
-                IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker);
-        if (!interfaceParentEntryOptional.isPresent()) {
-            return null;
-        }
-        return interfaceParentEntryOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfId, dataBroker).orNull();
     }
 
     public static InterfaceChildEntry getInterfaceChildEntryFromConfigDS(InterfaceParentEntryKey interfaceParentEntryKey,
@@ -211,12 +191,7 @@ public class InterfaceMetaUtils {
 
     public static InterfaceChildEntry getInterfaceChildEntryFromConfigDS(
             InstanceIdentifier<InterfaceChildEntry> intfChildIid, DataBroker dataBroker) {
-        Optional<InterfaceChildEntry> interfaceChildEntryOptional =
-                IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker);
-        if (!interfaceChildEntryOptional.isPresent()) {
-            return null;
-        }
-        return interfaceChildEntryOptional.get();
+        return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, intfChildIid, dataBroker).orNull();
     }
 
     public static void createLportTagInterfaceMap(WriteTransaction t, String infName, Integer ifIndex) {
@@ -299,11 +274,8 @@ public class InterfaceMetaUtils {
                                                                  DataBroker dataBroker) {
         InstanceIdentifier<TunnelInstanceInterface> id = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class).
                 child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelInstanceId)).build();
-        Optional<TunnelInstanceInterface> tunnelInstanceInterfaceOptional = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker);
-        if(tunnelInstanceInterfaceOptional.isPresent()){
-            return tunnelInstanceInterfaceOptional.get().getInterfaceName();
-        }
-        return null;
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker).transform(
+                TunnelInstanceInterface::getInterfaceName).orNull();
     }
 
     public static void deleteBridgeInterfaceEntry(BridgeEntryKey bridgeEntryKey, List<BridgeInterfaceEntry> bridgeInterfaceEntries,

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
index 5a5c82c665bcce0968677d40a4970bbe9dce7066..4378ed0aa08144efafb907d8a2ad9af5b300d83c 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities;
 
-import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableBiMap;
 import java.math.BigInteger;
 import java.util.ArrayList;
@@ -88,14 +87,8 @@ public class FlowBasedServicesUtils {
         ServicesInfoKey servicesInfoKey = new ServicesInfoKey(interfaceName,serviceMode);
         InstanceIdentifier.InstanceIdentifierBuilder<ServicesInfo> servicesInfoIdentifierBuilder =
                 InstanceIdentifier.builder(ServiceBindings.class).child(ServicesInfo.class, servicesInfoKey);
-        Optional<ServicesInfo> servicesInfoOptional = IfmUtil.read(LogicalDatastoreType.CONFIGURATION,
-                servicesInfoIdentifierBuilder.build(), dataBroker);
-
-        if (servicesInfoOptional.isPresent()) {
-            return servicesInfoOptional.get();
-        }
-
-        return null;
+        return IfmUtil.read(LogicalDatastoreType.CONFIGURATION, servicesInfoIdentifierBuilder.build(),
+                dataBroker).orNull();
     }
 
     public static NodeConnectorId getNodeConnectorIdFromInterface(String interfaceName, DataBroker dataBroker) {

diff --git a/itm/itm-impl/pom.xml b/itm/itm-impl/pom.xml
index d8de7ab852f14b13307b321474d611eedb139867..1c164dca6f6f1dc763f72f2c491baad0c4cf4f28 100644 (file)
--- a/itm/itm-impl/pom.xml
+++ b/itm/itm-impl/pom.xml
@@ -80,21 +80,4 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
       <version>${genius.version}</version>
     </dependency>
   </dependencies>
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.felix</groupId>
-        <artifactId>maven-bundle-plugin</artifactId>
-        <version>2.3.7</version>
-        <configuration>
-          <instructions>
-            <Import-Package>
-              org.apache.karaf.shell.console,
-              *
-            </Import-Package>
-          </instructions>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
 </project>

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java
index 478dda2229d19bd5e991181be174804931ef8812..21dbb6cc680cbc4c9f0eaa4f84d3a63cfd3ee5e3 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cli/TepCommandHelper.java
@@ -14,7 +14,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.net.util.SubnetUtils;
 import org.apache.felix.service.command.CommandSession;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -26,11 +25,6 @@ import org.opendaylight.genius.itm.impl.ItmUtils;
 import org.opendaylight.genius.mdsalutil.MDSALDataStoreUtils;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeLldp;
@@ -44,8 +38,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
@@ -63,9 +55,6 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-//import org.opendaylight.genius.interfacemgr.util.OperationalIfmUtil;
-
-
 public class TepCommandHelper {
 
     private static final Logger LOG = LoggerFactory.getLogger(TepCommandHelper.class);
@@ -278,12 +267,7 @@ public class TepCommandHelper {
     public TransportZone getTransportZone(String tzone) {
         InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
                 .child(TransportZone.class, new TransportZoneKey(tzone)).build();
-        Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath,
-                dataBroker);
-        if (tZoneOptional.isPresent()) {
-            return tZoneOptional.get();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker).orNull();
     }
 
     /**
@@ -296,12 +280,7 @@ public class TepCommandHelper {
     public TransportZone getTransportZoneFromConfigDS(String tzone) {
         InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
                 .child(TransportZone.class, new TransportZoneKey(tzone)).build();
-        Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath,
-                dataBroker);
-        if (tZoneOptional.isPresent()) {
-            return tZoneOptional.get();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker).orNull();
     }
 
     /**
@@ -311,11 +290,7 @@ public class TepCommandHelper {
      */
     public TransportZones getAllTransportZones() {
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
-        Optional<TransportZones> tZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
-        if (tZonesOptional.isPresent()) {
-            return tZonesOptional.get();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker).orNull();
     }
 
     public boolean checkExistingSubnet(Map<SubnetObject, List<Vteps>> subVtepMapTemp, SubnetObject subObCli) {

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java
index f5b765fb34d0193e9480968330a9451711f9a7c2..836be432e0a00dfcf34f9e1ff8ada4f569a9ab0f 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmExternalTunnelDeleteWorker.java
@@ -259,14 +259,9 @@ public class ItmExternalTunnelDeleteWorker {
 
     private static boolean trunkExists( String srcDpnOrNode,  String dstDpnOrNode,
                                         Class<? extends TunnelTypeBase> tunType,DataBroker dataBroker) {
-        boolean existsFlag = false ;
         InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(
                 ExternalTunnelList.class)
                 .child(ExternalTunnel.class, ItmUtils.getExternalTunnelKey(dstDpnOrNode, srcDpnOrNode, tunType));
-        Optional<ExternalTunnel> exTunnels = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,path, dataBroker) ;
-        if( exTunnels.isPresent()) {
-            existsFlag = true;
-        }
-        return existsFlag ;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION,path, dataBroker).isPresent();
     }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java
index 4ca235df9e4f6ceee93cba3f8c2d759d50d4eef0..92c521ae338171b914cf3900b8266caf17715a12 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmInternalTunnelDeleteWorker.java
@@ -179,13 +179,9 @@ public class ItmInternalTunnelDeleteWorker {
                 .getValue(),dstTep.getTunnelType().getName());
     }
     private static boolean checkIfTrunkExists(BigInteger srcDpnId, BigInteger dstDpnId, Class<? extends TunnelTypeBase> tunType, DataBroker dataBroker) {
-        boolean existsFlag = false ;
         InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(
                 TunnelList.class)
                 .child(InternalTunnel.class, new InternalTunnelKey( dstDpnId, srcDpnId, tunType));
-        Optional<InternalTunnel> internalTunnels = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,path, dataBroker) ;
-        if( internalTunnels.isPresent())
-            existsFlag = true ;
-        return existsFlag ;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION,path, dataBroker).isPresent();
     }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java
index 05babe0306e4b25aacdc404801e9fcb204dd8946..9f153f9c64826d8aa6ea1b4b0c814e8ae992b9fd 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ITMManager.java
@@ -85,13 +85,9 @@ public class ITMManager implements AutoCloseable {
     }
 
     protected boolean getTunnelMonitorEnabledFromConfigDS() {
-        boolean tunnelMonitorEnabled = true;
         InstanceIdentifier<TunnelMonitorParams> path = InstanceIdentifier.builder(TunnelMonitorParams.class).build();
-        Optional<TunnelMonitorParams> storedTunnelMonitor = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker);
-        if (storedTunnelMonitor.isPresent()) {
-            tunnelMonitorEnabled = storedTunnelMonitor.get().isEnabled();
-        }
-        return tunnelMonitorEnabled;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker).transform(
+                TunnelMonitorParams::isEnabled).or(true);
     }
 
     protected Class<? extends TunnelMonitoringTypeBase> getTunnelMonitorTypeFromConfigDS() {
@@ -99,18 +95,15 @@ public class ITMManager implements AutoCloseable {
         Class<? extends TunnelMonitoringTypeBase> tunnelMonitorType = TunnelMonitoringTypeBfd.class;
         InstanceIdentifier<TunnelMonitorParams> path = InstanceIdentifier.builder(TunnelMonitorParams.class).build();
         Optional<TunnelMonitorParams> storedTunnelMonitor = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker);
-        if(storedTunnelMonitor.isPresent() && storedTunnelMonitor.get().getMonitorProtocol()!=null )
+        if (storedTunnelMonitor.isPresent() && storedTunnelMonitor.get().getMonitorProtocol() != null) {
             tunnelMonitorType = storedTunnelMonitor.get().getMonitorProtocol();
+        }
         return tunnelMonitorType;
     }
 
     protected int getTunnelMonitorIntervalFromConfigDS() {
-        int tunnelMonitorInterval = ITMConstants.DEFAULT_MONITOR_INTERVAL;
         InstanceIdentifier<TunnelMonitorInterval> path = InstanceIdentifier.builder(TunnelMonitorInterval.class).build();
-        Optional<TunnelMonitorInterval> storedTunnelMonitor = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker);
-        if (storedTunnelMonitor.isPresent()) {
-            tunnelMonitorInterval = storedTunnelMonitor.get().getInterval();
-        }
-        return tunnelMonitorInterval;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, broker).transform(
+                TunnelMonitorInterval::getInterval).or(ITMConstants.DEFAULT_MONITOR_INTERVAL);
     }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java
index 844be673140bcd853fba51d8a9701ac9a1c23aba..4501ef02af1b0409aeb1f3c420c164ef4155f27a 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmProvider.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.itm.impl;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import java.math.BigInteger;
 import java.util.List;
@@ -17,14 +16,11 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.apache.felix.service.command.CommandSession;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
@@ -53,24 +49,15 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.VtepConfigSchemas;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchema;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.vtep.config.schemas.VtepConfigSchemaBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.*;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -311,22 +298,14 @@ public class ItmProvider implements BindingAwareProvider, AutoCloseable, IITMPro
 
     @Override
     public VtepConfigSchema getVtepConfigSchema(String schemaName) {
-        Optional<VtepConfigSchema> schema = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                ItmUtils.getVtepConfigSchemaIdentifier(schemaName), this.dataBroker);
-        if (schema.isPresent()) {
-            return schema.get();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemaIdentifier(schemaName),
+                this.dataBroker).orNull();
     }
 
     @Override
     public List<VtepConfigSchema> getAllVtepConfigSchemas() {
-        Optional<VtepConfigSchemas> schemas = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                ItmUtils.getVtepConfigSchemasIdentifier(), this.dataBroker);
-        if (schemas.isPresent()) {
-            return schemas.get().getVtepConfigSchema();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemasIdentifier(),
+                this.dataBroker).transform(VtepConfigSchemas::getVtepConfigSchema).orNull();
     }
 
     @Override

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
index 1ca7132afb1baccca1b6fb3c6dc99340d9ae8f3e..e2e32f9447026e5decfbfe2bbd80c00a44a7c335 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
@@ -142,17 +142,11 @@ public class ItmUtils {
 
     public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
                                                           InstanceIdentifier<T> path, DataBroker broker) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
-
-        return result;
     }
 
     public static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
@@ -810,10 +804,11 @@ public class ItmUtils {
         InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class).
                 child(TransportZone.class, new TransportZoneKey(tzone)).build();
         Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
-        Class<? extends TunnelTypeBase> tunType = tZoneOptional.get().getTunnelType();
         if (tZoneOptional.isPresent()) {
-            if (tZoneOptional.get().getSubnets() != null && !tZoneOptional.get().getSubnets().isEmpty()) {
-                for (Subnets sub : tZoneOptional.get().getSubnets()) {
+            TransportZone transportZone = tZoneOptional.get();
+            Class<? extends TunnelTypeBase> tunType = transportZone.getTunnelType();
+            if (transportZone.getSubnets() != null && !transportZone.getSubnets().isEmpty()) {
+                for (Subnets sub : transportZone.getSubnets()) {
                     if (sub.getVteps() != null && !sub.getVteps().isEmpty()) {
                         for (Vteps vtepLocal : sub.getVteps()) {
                             for (Vteps vtepRemote : sub.getVteps()) {
@@ -825,8 +820,9 @@ public class ItmUtils {
                                     Optional<InternalTunnel> TunnelsOptional =
                                             ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
                                     if (TunnelsOptional.isPresent()) {
-                                        LOG.trace("Internal Tunnel added {}",TunnelsOptional.get().getTunnelInterfaceName());
-                                        tunnels.add(TunnelsOptional.get().getTunnelInterfaceName());
+                                        String tunnelInterfaceName = TunnelsOptional.get().getTunnelInterfaceName();
+                                        LOG.trace("Internal Tunnel added {}", tunnelInterfaceName);
+                                        tunnels.add(tunnelInterfaceName);
                                     }
                                 }
                             }
@@ -842,13 +838,13 @@ public class ItmUtils {
                     }
                 }
             }
-        }
-        if (hwVtepsExist) {
-            for (HwVtep hwVtep : hwVteps) {
-                for (HwVtep hwVtepOther : hwVteps) {
-                    if (!hwVtep.getHwIp().equals(hwVtepOther.getHwIp())) {
-                        tunnels.add(getExtTunnel(hwVtep.getNode_id(), hwVtepOther.getNode_id(), tunType, dataBroker));
-                        tunnels.add(getExtTunnel(hwVtepOther.getNode_id(), hwVtep.getNode_id(), tunType, dataBroker));
+            if (hwVtepsExist) {
+                for (HwVtep hwVtep : hwVteps) {
+                    for (HwVtep hwVtepOther : hwVteps) {
+                        if (!hwVtep.getHwIp().equals(hwVtepOther.getHwIp())) {
+                            tunnels.add(getExtTunnel(hwVtep.getNode_id(), hwVtepOther.getNode_id(), tunType, dataBroker));
+                            tunnels.add(getExtTunnel(hwVtepOther.getNode_id(), hwVtep.getNode_id(), tunType, dataBroker));
+                        }
                     }
                 }
             }
@@ -863,22 +859,25 @@ public class ItmUtils {
                 child(TransportZone.class, new TransportZoneKey(tzone)).build();
         Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
         if (tZoneOptional.isPresent()) {
-            if (tZoneOptional.get().getSubnets() != null && !tZoneOptional.get().getSubnets().isEmpty()) {
-                for (Subnets sub : tZoneOptional.get().getSubnets()) {
+            TransportZone transportZone = tZoneOptional.get();
+            if (transportZone.getSubnets() != null && !transportZone.getSubnets().isEmpty()) {
+                for (Subnets sub : transportZone.getSubnets()) {
                     if (sub.getVteps() != null && !sub.getVteps().isEmpty()) {
                         for (Vteps vtepLocal : sub.getVteps()) {
                             for (Vteps vtepRemote : sub.getVteps()) {
                                 if (!vtepLocal.equals(vtepRemote)) {
-                                    InternalTunnelKey key = new InternalTunnelKey(vtepRemote.getDpnId(), vtepLocal.getDpnId(), tZoneOptional.get().getTunnelType());
+                                    InternalTunnelKey key =
+                                            new InternalTunnelKey(vtepRemote.getDpnId(), vtepLocal.getDpnId(),
+                                                    transportZone.getTunnelType());
                                     InstanceIdentifier<InternalTunnel> intIID =
                                             InstanceIdentifier.builder(TunnelList.class).
                                                     child(InternalTunnel.class, key).build();
-                                    Optional<InternalTunnel> TunnelsOptional =
+                                    Optional<InternalTunnel> tunnelsOptional =
                                             ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
-                                    if (TunnelsOptional.isPresent()) {
-                                        LOG.trace("Internal Tunnel added {}",
-                                                TunnelsOptional.get().getTunnelInterfaceName());
-                                        tunnels.add(TunnelsOptional.get().getTunnelInterfaceName());
+                                    if (tunnelsOptional.isPresent()) {
+                                        String tunnelInterfaceName = tunnelsOptional.get().getTunnelInterfaceName();
+                                        LOG.trace("Internal Tunnel added {}", tunnelInterfaceName);
+                                        tunnels.add(tunnelInterfaceName);
                                     }
                                 }
                             }
@@ -895,11 +894,12 @@ public class ItmUtils {
         ExternalTunnelKey key = getExternalTunnelKey(dpId, node_id, tunType);
         InstanceIdentifier<ExternalTunnel> intIID = InstanceIdentifier.builder(ExternalTunnelList.class).
                 child(ExternalTunnel.class, key).build();
-        Optional<ExternalTunnel> TunnelsOptional =
+        Optional<ExternalTunnel> tunnelsOptional =
                 ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
-        if (TunnelsOptional.isPresent()) {
-            LOG.trace("ext tunnel returned {} ",TunnelsOptional.get().getTunnelInterfaceName());
-            return TunnelsOptional.get().getTunnelInterfaceName();
+        if (tunnelsOptional.isPresent()) {
+            String tunnelInterfaceName = tunnelsOptional.get().getTunnelInterfaceName();
+            LOG.trace("ext tunnel returned {} ", tunnelInterfaceName);
+            return tunnelInterfaceName;
         }
         return null;
     }
@@ -923,11 +923,7 @@ public class ItmUtils {
     }
     public static TunnelList getAllInternalTunnels(DataBroker broker) {
         InstanceIdentifier<TunnelList> tunnelListInstanceIdentifier = InstanceIdentifier.builder(TunnelList.class).build();
-        Optional<TunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, tunnelListInstanceIdentifier, broker);
-        if (tunnelList.isPresent()) {
-            return tunnelList.get();
-        }
-        return null;
+        return read(LogicalDatastoreType.CONFIGURATION, tunnelListInstanceIdentifier, broker).orNull();
     }
     public static InternalTunnel getInternalTunnel(String interfaceName, DataBroker broker) {
         InternalTunnel internalTunnel = null;

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/VtepConfigSchemaListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/VtepConfigSchemaListener.java
index 361ea29000687cda7d1eb53e23279bd76ad4b0f8..2ad434bf3bebd2fcde6db435b047c47820aaf328 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/VtepConfigSchemaListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/VtepConfigSchemaListener.java
@@ -305,12 +305,8 @@ public class VtepConfigSchemaListener extends AbstractDataChangeListener<VtepCon
      * @return the all vtep config schemas
      */
     private List<VtepConfigSchema> getAllVtepConfigSchemas() {
-        Optional<VtepConfigSchemas> schemas = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                ItmUtils.getVtepConfigSchemasIdentifier(), this.dataBroker);
-        if (schemas.isPresent()) {
-            return schemas.get().getVtepConfigSchema();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepConfigSchemasIdentifier(),
+                this.dataBroker).transform(VtepConfigSchemas::getVtepConfigSchema).orNull();
     }
 
     /**
@@ -468,12 +464,8 @@ public class VtepConfigSchemaListener extends AbstractDataChangeListener<VtepCon
      * @return the vtep ip pool
      */
     private VtepIpPool getVtepIpPool(final String subnetCidr) {
-        Optional<VtepIpPool> vtepIpPool = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                ItmUtils.getVtepIpPoolIdentifier(subnetCidr), this.dataBroker);
-        if (vtepIpPool.isPresent()) {
-            return vtepIpPool.get();
-        }
-        return null;
+        return ItmUtils.read(LogicalDatastoreType.CONFIGURATION, ItmUtils.getVtepIpPoolIdentifier(subnetCidr),
+                this.dataBroker).orNull();
     }
 
     /**

diff --git a/lockmanager/lockmanager-impl/src/main/java/org/opendaylight/lockmanager/LockManager.java b/lockmanager/lockmanager-impl/src/main/java/org/opendaylight/lockmanager/LockManager.java
index 156fef890f645cf457c8b2536363709af0ca4175..09f1077c753737ecf6aa695a66f9f7581428fc95 100644 (file)
--- a/lockmanager/lockmanager-impl/src/main/java/org/opendaylight/lockmanager/LockManager.java
+++ b/lockmanager/lockmanager-impl/src/main/java/org/opendaylight/lockmanager/LockManager.java
@@ -149,8 +149,7 @@ public class LockManager implements LockManagerService {
     private boolean readWriteLock(final InstanceIdentifier<Lock> lockInstanceIdentifier, final Lock lockData)
             throws InterruptedException, ExecutionException {
         ReadWriteTransaction tx = broker.newReadWriteTransaction();
-        Optional<Lock> result = Optional.absent();
-        result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get();
+        Optional<Lock> result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get();
         if (!result.isPresent()) {
             tx.put(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier, lockData, true);
             CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
@@ -162,9 +161,8 @@ public class LockManager implements LockManagerService {
 
     private void unlock(final String lockName, final InstanceIdentifier<Lock> lockInstanceIdentifier) {
         ReadWriteTransaction tx = broker.newReadWriteTransaction();
-        Optional<Lock> result = Optional.absent();
         try {
-            result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get();
+            Optional<Lock> result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get();
             if (!result.isPresent()) {
                 LOG.info("{} is already unlocked", lockName);
                 return;

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncClusteredDataChangeListenerBase.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncClusteredDataChangeListenerBase.java
index ddfcc083a93edc665e683b9e870e1deaacbc91ff..f0130ad4e1f9d8eeda37a78411db65b5fa3386e6 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncClusteredDataChangeListenerBase.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncClusteredDataChangeListenerBase.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.datastoreutils;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import java.util.Collections;
 import java.util.Map;
@@ -86,9 +85,9 @@ public abstract class AsyncClusteredDataChangeListenerBase<T extends DataObject,
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> createKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(createdData.get(key));
-                if (value.isPresent()) {
-                    this.add(createKeyIdent, (T)value.get());
+                DataObject value = createdData.get(key);
+                if (value != null) {
+                    this.add(createKeyIdent, (T) value);
                 }
             }
         }
@@ -103,10 +102,10 @@ public abstract class AsyncClusteredDataChangeListenerBase<T extends DataObject,
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> updateKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(updateData.get(key));
-                final Optional<DataObject> original = Optional.of(originalData.get(key));
-                if (value.isPresent() && original.isPresent()) {
-                    this.update(updateKeyIdent, (T) original.get(), (T) value.get());
+                final DataObject value = updateData.get(key);
+                final DataObject original = originalData.get(key);
+                if (value != null && original != null) {
+                    this.update(updateKeyIdent, (T) original, (T) value);
                 }
             }
         }

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncDataChangeListenerBase.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncDataChangeListenerBase.java
index 1e853e0877fc313674605c33c89f05c498a9699c..33dcd2d5629252f317b36bc89c319b90591292ca 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncDataChangeListenerBase.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/datastoreutils/AsyncDataChangeListenerBase.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.datastoreutils;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import java.util.Collections;
 import java.util.Map;
@@ -86,9 +85,9 @@ public abstract class AsyncDataChangeListenerBase<T extends DataObject, K extend
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> createKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(createdData.get(key));
-                if (value.isPresent()) {
-                    this.add(createKeyIdent, (T)value.get());
+                final DataObject value = createdData.get(key);
+                if (value != null) {
+                    this.add(createKeyIdent, (T) value);
                 }
             }
         }
@@ -103,10 +102,10 @@ public abstract class AsyncDataChangeListenerBase<T extends DataObject, K extend
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> updateKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(updateData.get(key));
-                final Optional<DataObject> original = Optional.of(originalData.get(key));
-                if (value.isPresent() && original.isPresent()) {
-                    this.update(updateKeyIdent, (T) original.get(), (T) value.get());
+                final DataObject value = updateData.get(key);
+                final DataObject original = originalData.get(key);
+                if (value != null && original != null) {
+                    this.update(updateKeyIdent, (T) original, (T) value);
                 }
             }
         }

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/AbstractDataChangeListener.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/AbstractDataChangeListener.java
index 1858f5f0ef4bbaa5e29a576efae422eae7c34429..d2cc8e86256ff76239fb1cc52c19be0c5c8bbb14 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/AbstractDataChangeListener.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/AbstractDataChangeListener.java
@@ -7,7 +7,6 @@
  */
 package org.opendaylight.genius.mdsalutil;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 
 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
@@ -63,9 +62,9 @@ public abstract class AbstractDataChangeListener<T extends DataObject> implement
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> createKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(createdData.get(key));
-                if (value.isPresent()) {
-                    this.add(createKeyIdent, (T)value.get());
+                DataObject value = createdData.get(key);
+                if (value != null) {
+                    this.add(createKeyIdent, (T)value);
                 }
             }
         }
@@ -80,10 +79,10 @@ public abstract class AbstractDataChangeListener<T extends DataObject> implement
         for (InstanceIdentifier<?> key : keys) {
             if (clazz.equals(key.getTargetType())) {
                 InstanceIdentifier<T> updateKeyIdent = key.firstIdentifierOf(clazz);
-                final Optional<DataObject> value = Optional.of(updateData.get(key));
-                final Optional<DataObject> original = Optional.of(originalData.get(key));
-                if (value.isPresent() && original.isPresent()) {
-                    this.update(updateKeyIdent, (T)original.get(), (T)value.get());
+                DataObject value = updateData.get(key);
+                DataObject original = originalData.get(key);
+                if (value != null && original != null) {
+                    this.update(updateKeyIdent, (T)original, (T)value);
                 }
             }
         }

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALDataStoreUtils.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALDataStoreUtils.java
index 058579a344f572cb8a86666cf03a3ca085113e45..56ac44483e8df79ee89ed7c04a6db9ad55072301 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALDataStoreUtils.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALDataStoreUtils.java
@@ -22,17 +22,11 @@ public class MDSALDataStoreUtils {
 
     public static <T extends DataObject> Optional<T> read(final DataBroker broker,final LogicalDatastoreType datastoreType,
             InstanceIdentifier<T> path) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
-
-        return result;
     }
 
    public static <T extends DataObject> void asyncWrite(final DataBroker broker, final LogicalDatastoreType datastoreType,

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALUtil.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALUtil.java
index b079b7f55b70572a3259232644b14856a5362a59..b91e94d098ed9c420184fe3bcb37f7ab8e8a438c 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALUtil.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/MDSALUtil.java
@@ -488,30 +488,21 @@ public class MDSALUtil {
 
     public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
                                                           InstanceIdentifier<T> path, DataBroker broker) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             logger.error("An error occured while reading data from the path {} with the exception {}", path, e);
+            return Optional.absent();
         }
-        return result;
     }
 
     public static <T extends DataObject> Optional<T> read(DataBroker broker,
                                                           LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
-
-        ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
-
-        Optional<T> result = Optional.absent();
-        try {
-            result = tx.read(datastoreType, path).get();
+        try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
+            return tx.read(datastoreType, path).get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
-        return result;
     }
 
     public static <T extends DataObject> void syncWrite(DataBroker broker,
@@ -581,28 +572,14 @@ public class MDSALUtil {
                 .child(Node.class, new NodeKey(nodeId))
                 .child(NodeConnector.class,
                         new NodeConnectorKey(nodeConnectorId)).build();
-
-        Optional<NodeConnector> nodeConnectorOptional = read(
-                dataBroker,
-                LogicalDatastoreType.OPERATIONAL, ncIdentifier);
-        if (!nodeConnectorOptional.isPresent()) {
-            return null;
-        }
-        NodeConnector nc = nodeConnectorOptional.get();
-        FlowCapableNodeConnector fc = nc
-                .getAugmentation(FlowCapableNodeConnector.class);
-        return fc.getName();
+        return read(dataBroker, LogicalDatastoreType.OPERATIONAL, ncIdentifier).transform(
+                nc -> nc.getAugmentation(FlowCapableNodeConnector.class).getName()).orNull();
     }
 
     public static NodeConnectorId getNodeConnectorId(DataBroker dataBroker,
             NodeConnectorRef ref) {
-        Optional<NodeConnector> nc = (Optional<NodeConnector>) read(
-                dataBroker,
-                LogicalDatastoreType.OPERATIONAL, ref.getValue());
-        if(nc.isPresent()){
-            return nc.get().getId();
-        }
-        return null;
+        return ((Optional<NodeConnector>) read(dataBroker, LogicalDatastoreType.OPERATIONAL, ref.getValue())).transform(
+                NodeConnector::getId).orNull();
     }
 
     public static TransmitPacketInput getPacketOut(List<Action> actions, byte[] payload, BigInteger dpnId) {

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/cache/DataStoreCache.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/cache/DataStoreCache.java
index af32b53402e5a47f55d7c8b81664f22e52d76f28..4ea72bc1e0350bebce33cab060ddfa947a94b274 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/cache/DataStoreCache.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/cache/DataStoreCache.java
@@ -11,7 +11,6 @@ import com.google.common.base.Optional;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.mdsalutil.MDSALDataStoreUtils;
-import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
@@ -40,15 +39,11 @@ public class DataStoreCache {
 
     public static <T extends DataObject> Object get(String cacheName, InstanceIdentifier<T> identifier, String key, DataBroker broker, boolean isConfig) {
         Object dataObject = getCache(cacheName).get(key);
-        Optional<T> optionalObject = Optional.absent();
         if (dataObject == null) {
-            if (isConfig) {
-                optionalObject = MDSALDataStoreUtils.read(broker, LogicalDatastoreType.CONFIGURATION, identifier);
-            } else {
-                optionalObject = MDSALDataStoreUtils.read(broker, LogicalDatastoreType.OPERATIONAL, identifier);
-            }
-            if (optionalObject.isPresent()) {
-                dataObject = optionalObject.get();
+            Optional<T> datastoreObject = MDSALDataStoreUtils.read(broker,
+                    isConfig ? LogicalDatastoreType.CONFIGURATION : LogicalDatastoreType.OPERATIONAL, identifier);
+            if (datastoreObject.isPresent()) {
+                dataObject = datastoreObject.get();
                 add(cacheName, key, dataObject);
             }
         }

diff --git a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/hwvtep/HwvtepUtils.java b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/hwvtep/HwvtepUtils.java
index 390e7edbbcbd8669529f5b19c68d9f512c2df98b..5afcd6a3a1edd10952553c3cfe359a68057c3b24 100644 (file)
--- a/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/hwvtep/HwvtepUtils.java
+++ b/mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/utils/hwvtep/HwvtepUtils.java
@@ -40,7 +40,6 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
-import com.google.common.base.Optional;
 import com.google.common.util.concurrent.ListenableFuture;
 
 /**
@@ -162,11 +161,7 @@ public final class HwvtepUtils {
                                                    String logicalSwitchName) {
         final InstanceIdentifier<LogicalSwitches> iid = HwvtepSouthboundUtils
                 .createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
-        Optional<LogicalSwitches> optLogicalSwitch = MDSALUtil.read(broker, datastoreType, iid);
-        if (optLogicalSwitch.isPresent()) {
-            return optLogicalSwitch.get();
-        }
-        return null;
+        return MDSALUtil.read(broker, datastoreType, iid).orNull();
     }
 
     /**
@@ -186,11 +181,7 @@ public final class HwvtepUtils {
             LogicalDatastoreType datastoreType, NodeId nodeId, String portName) {
         TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
         InstanceIdentifier<TerminationPoint> iid = HwvtepSouthboundUtils.createTerminationPointId(nodeId, tpKey);
-        Optional<TerminationPoint> physicalPortTerminationPoint = MDSALUtil.read(broker, datastoreType, iid);
-        if (physicalPortTerminationPoint.isPresent()) {
-            return physicalPortTerminationPoint.get();
-        }
-        return null;
+        return MDSALUtil.read(broker, datastoreType, iid).orNull();
     }
 
     /**
@@ -209,13 +200,7 @@ public final class HwvtepUtils {
         InstanceIdentifier<LogicalSwitches> logicalSwitchesIdentifier = HwvtepSouthboundUtils
                 .createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(vni));
 
-        Optional<LogicalSwitches> logicalSwitches = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
-                logicalSwitchesIdentifier);
-        if (!logicalSwitches.isPresent()) {
-            return null;
-        }
-
-        return logicalSwitches.get();
+        return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, logicalSwitchesIdentifier).orNull();
     }
 
     /**
@@ -278,11 +263,7 @@ public final class HwvtepUtils {
         InstanceIdentifier<HwvtepPhysicalLocatorAugmentation> iid = HwvtepSouthboundUtils
                 .createPhysicalLocatorInstanceIdentifier(nodeId, phyLocatorAug)
                 .augmentation(HwvtepPhysicalLocatorAugmentation.class);
-        Optional<HwvtepPhysicalLocatorAugmentation> optPhyLocator = MDSALUtil.read(broker, datastoreType, iid);
-        if (optPhyLocator.isPresent()) {
-            return optPhyLocator.get();
-        }
-        return null;
+        return MDSALUtil.read(broker, datastoreType, iid).orNull();
     }
 
     /**
@@ -489,11 +470,7 @@ public final class HwvtepUtils {
                                                     NodeId nodeId, RemoteMcastMacsKey remoteMcastMacsKey) {
         final InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils
                 .createRemoteMcastMacsInstanceIdentifier(nodeId, remoteMcastMacsKey);
-        Optional<RemoteMcastMacs> optRemoteMcastMac = MDSALUtil.read(broker, datastoreType, iid);
-        if (optRemoteMcastMac.isPresent()) {
-            return optRemoteMcastMac.get();
-        }
-        return null;
+        return MDSALUtil.read(broker, datastoreType, iid).orNull();
     }
 
     /**
@@ -640,12 +617,8 @@ public final class HwvtepUtils {
      * @return the hw vtep node
      */
     public static Node getHwVtepNode(DataBroker dataBroker, LogicalDatastoreType datastoreType, NodeId nodeId) {
-        Optional<Node> optNode = MDSALUtil.read(dataBroker, datastoreType,
-                HwvtepSouthboundUtils.createInstanceIdentifier(nodeId));
-        if (optNode.isPresent()) {
-            return optNode.get();
-        }
-        return null;
+        return MDSALUtil.read(dataBroker, datastoreType,
+                HwvtepSouthboundUtils.createInstanceIdentifier(nodeId)).orNull();
     }
 
     /**