Cleanup Optional uses

[genius.git] / alivenessmonitor / alivenessmonitor-impl / src / main / java / org / opendaylight / genius / alivenessmonitor / internal / AbstractAlivenessProtocolHandler.java

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 c069b9a178cfbce5e716e0d7887694eacd7c49d7..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
@@ -9,12 +9,20 @@ package org.opendaylight.genius.alivenessmonitor.internal;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Strings;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
 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.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.EtherTypes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@@ -22,32 +30,31 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.No
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
 abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHandler {
 
-    protected ServiceProvider serviceProvider;
+    private final DataBroker dataBroker;
+    private final OdlInterfaceRpcService interfaceManager;
     private InventoryReader inventoryReader;
 
-    public AbstractAlivenessProtocolHandler(ServiceProvider serviceProvider) {
-        this.serviceProvider = serviceProvider;
-        inventoryReader = new InventoryReader(serviceProvider.getDataBroker());
+    public AbstractAlivenessProtocolHandler(final DataBroker dataBroker,
+                                            final OdlInterfaceRpcService interfaceManager,
+                                            final AlivenessMonitor alivenessMonitor,
+                                            final EtherTypes etherType) {
+        this.dataBroker = dataBroker;
+        this.interfaceManager = interfaceManager;
+        alivenessMonitor.registerHandler(etherType, this);
+        inventoryReader = new InventoryReader(dataBroker);
     }
 
     private InstanceIdentifier<NodeConnector> getNodeConnectorId(String interfaceName) {
         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);
 
@@ -62,7 +69,8 @@ abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHand
 
     private NodeConnectorId getNodeConnectorIdFromInterface(String interfaceName) {
         GetNodeconnectorIdFromInterfaceInput input = new GetNodeconnectorIdFromInterfaceInputBuilder().setIntfName(interfaceName).build();
-        Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> output =  serviceProvider.getInterfaceManager().getNodeconnectorIdFromInterface(input);
+        Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> output =
+                interfaceManager.getNodeconnectorIdFromInterface(input);
         RpcResult<GetNodeconnectorIdFromInterfaceOutput> result = null;
         try {
             result = output.get();
@@ -86,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) {
@@ -110,30 +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 = serviceProvider.getDataBroker().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;
     }
-
 }