Enhancing interface-manager junits - phase3
[genius.git] / interfacemanager / interfacemanager-impl / src / main / java / org / opendaylight / genius / interfacemanager / commons / AlivenessMonitorUtils.java
index 94c9ad98b7b30ed7addf84a71da96315796ed090..3b4e9ce46329ff895225cf79c6a8bc0934d97b92 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
@@ -8,17 +8,37 @@
 package org.opendaylight.genius.interfacemanager.commons;
 
 import com.google.common.base.Optional;
+import java.util.ArrayList;
+import java.util.List;
+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.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.mdsalutil.MDSALUtil;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.EtherTypes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileCreateOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileDeleteInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorProfileGetOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStartOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorStopInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitoringMode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.params.SourceBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.Profile;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.ProfileBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.start.input.ConfigBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.InterfaceMonitorIdMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.MonitorIdInterfaceMap;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.monitor.id.map.InterfaceMonitorId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.monitor.id.map.InterfaceMonitorIdBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.monitor.id.map.InterfaceMonitorIdKey;
@@ -27,34 +47,36 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.met
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.monitor.id._interface.map.MonitorIdInterfaceKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeLldp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
-public class AlivenessMonitorUtils {
+public final class AlivenessMonitorUtils {
 
     private static final Logger LOG = LoggerFactory.getLogger(AlivenessMonitorUtils.class);
     private static final long FAILURE_THRESHOLD = 4;
     private static final long MONITORING_INTERVAL = 10000;
     private static final long MONITORING_WINDOW = 4;
 
+    private AlivenessMonitorUtils() {
+    }
+
     public static void startLLDPMonitoring(AlivenessMonitorService alivenessMonitorService, DataBroker dataBroker,
-                                           IfTunnel ifTunnel, String trunkInterfaceName) {
-        //LLDP monitoring for the tunnel interface
-        if(lldpMonitoringEnabled(ifTunnel)) {
-            MonitorStartInput lldpMonitorInput = new MonitorStartInputBuilder().setConfig(new ConfigBuilder()
-                    .setSource(new SourceBuilder().setEndpointType(getInterfaceForMonitoring(trunkInterfaceName,
-                            ifTunnel.getTunnelSource())).build())
-                    .setMode(MonitoringMode.OneOne)
-                    .setProfileId(allocateProfile(alivenessMonitorService, FAILURE_THRESHOLD, ifTunnel.getMonitorInterval(), MONITORING_WINDOW,
-                            EtherTypes.Lldp)).build()).build();
+            IfTunnel ifTunnel, String trunkInterfaceName) {
+        // LLDP monitoring for the tunnel interface
+        if (lldpMonitoringEnabled(ifTunnel)) {
+            MonitorStartInput lldpMonitorInput = new MonitorStartInputBuilder()
+                    .setConfig(new ConfigBuilder()
+                            .setSource(new SourceBuilder()
+                                    .setEndpointType(
+                                            getInterfaceForMonitoring(trunkInterfaceName, ifTunnel.getTunnelSource()))
+                                    .build())
+                            .setMode(MonitoringMode.OneOne)
+                            .setProfileId(allocateProfile(alivenessMonitorService, FAILURE_THRESHOLD,
+                                    ifTunnel.getMonitorInterval(), MONITORING_WINDOW, EtherTypes.Lldp))
+                            .build())
+                    .build();
             try {
                 Future<RpcResult<MonitorStartOutput>> result = alivenessMonitorService.monitorStart(lldpMonitorInput);
                 RpcResult<MonitorStartOutput> rpcResult = result.get();
@@ -74,8 +96,8 @@ public class AlivenessMonitorUtils {
     }
 
     public static void stopLLDPMonitoring(AlivenessMonitorService alivenessMonitorService, DataBroker dataBroker,
-                                          IfTunnel ifTunnel, String trunkInterface) {
-        if(!lldpMonitoringEnabled(ifTunnel)){
+            IfTunnel ifTunnel, String trunkInterface) {
+        if (!lldpMonitoringEnabled(ifTunnel)) {
             return;
         }
         LOG.debug("stop LLDP monitoring for {}", trunkInterface);
@@ -97,72 +119,80 @@ 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;
+        InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class)
+                .child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
+        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();
+        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);
         }
     }
 
     private static void removeMonitorIdFromInterfaceMonitorIdMap(DataBroker broker, String infName, long monitorId) {
-        InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class).child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
+        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)) {
                 existingMonitorIds.remove(monitorId);
                 InterfaceMonitorIdBuilder interfaceMonitorIdBuilder = new InterfaceMonitorIdBuilder();
-                interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setKey(new InterfaceMonitorIdKey(infName)).setMonitorId(existingMonitorIds).build();
+                interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setKey(new InterfaceMonitorIdKey(infName))
+                        .setMonitorId(existingMonitorIds).build();
                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, interfaceMonitorIdInstance);
             }
         }
     }
 
-    private static org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.endpoint.endpoint.type.Interface getInterfaceForMonitoring(String interfaceName, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress ipAddress) {
-        return new org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.endpoint.
-                endpoint.type.InterfaceBuilder().setInterfaceIp(ipAddress).setInterfaceName(interfaceName).build();
+    private static org.opendaylight.yang.gen.v1
+        .urn.opendaylight.genius.alivenessmonitor
+        .rev160411.endpoint.endpoint.type.Interface getInterfaceForMonitoring(
+            String interfaceName,
+            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress ipAddress) {
+        return new org.opendaylight.yang.gen.v1.urn.opendaylight
+                .genius.alivenessmonitor.rev160411.endpoint.endpoint.type.InterfaceBuilder()
+                .setInterfaceIp(ipAddress).setInterfaceName(interfaceName).build();
     }
 
-    public static void handleTunnelMonitorUpdates(AlivenessMonitorService alivenessMonitorService, DataBroker dataBroker,
-                                                  Interface interfaceOld, Interface interfaceNew) {
+    public static void handleTunnelMonitorUpdates(AlivenessMonitorService alivenessMonitorService,
+            DataBroker dataBroker, Interface interfaceOld, Interface interfaceNew) {
         String interfaceName = interfaceNew.getName();
         IfTunnel ifTunnelNew = interfaceNew.getAugmentation(IfTunnel.class);
-        if(!lldpMonitoringEnabled(ifTunnelNew)){
+        if (!lldpMonitoringEnabled(ifTunnelNew)) {
             return;
         }
         LOG.debug("handling tunnel monitoring updates for interface {}", interfaceName);
 
         stopLLDPMonitoring(alivenessMonitorService, dataBroker, ifTunnelNew, interfaceOld.getName());
-        if(ifTunnelNew.isMonitorEnabled()) {
+        if (ifTunnelNew.isMonitorEnabled()) {
             startLLDPMonitoring(alivenessMonitorService, dataBroker, ifTunnelNew, interfaceName);
 
             // Delete old profile from Aliveness Manager
             IfTunnel ifTunnelOld = interfaceOld.getAugmentation(IfTunnel.class);
-            if(ifTunnelNew.getMonitorInterval() != ifTunnelOld.getMonitorInterval()) {
+            if (!ifTunnelNew.getMonitorInterval().equals(ifTunnelOld.getMonitorInterval())) {
                 LOG.debug("deleting older monitor profile for interface {}", interfaceName);
-                long profileId = allocateProfile(alivenessMonitorService, FAILURE_THRESHOLD, ifTunnelOld.getMonitorInterval(), MONITORING_WINDOW, EtherTypes.Lldp);
-                MonitorProfileDeleteInput profileDeleteInput = new MonitorProfileDeleteInputBuilder().setProfileId(profileId).build();
+                long profileId = allocateProfile(alivenessMonitorService, FAILURE_THRESHOLD,
+                        ifTunnelOld.getMonitorInterval(), MONITORING_WINDOW, EtherTypes.Lldp);
+                MonitorProfileDeleteInput profileDeleteInput = new MonitorProfileDeleteInputBuilder()
+                        .setProfileId(profileId).build();
                 alivenessMonitorService.monitorProfileDelete(profileDeleteInput);
             }
         }
     }
 
-
     public static void createOrUpdateInterfaceMonitorIdMap(DataBroker broker, String infName, long monitorId) {
         InterfaceMonitorId interfaceMonitorIdInstance;
         List<Long> existingMonitorIds;
         InterfaceMonitorIdBuilder interfaceMonitorIdBuilder = new InterfaceMonitorIdBuilder();
-        InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class).child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
+        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()) {
             interfaceMonitorIdInstance = interfaceMonitorIdMap.get();
@@ -172,105 +202,103 @@ public class AlivenessMonitorUtils {
             }
             if (!existingMonitorIds.contains(monitorId)) {
                 existingMonitorIds.add(monitorId);
-                interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setKey(new InterfaceMonitorIdKey(infName)).setMonitorId(existingMonitorIds).build();
+                interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setKey(new InterfaceMonitorIdKey(infName))
+                        .setMonitorId(existingMonitorIds).build();
                 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, id, interfaceMonitorIdInstance);
             }
         } else {
             existingMonitorIds = new ArrayList<>();
             existingMonitorIds.add(monitorId);
-            interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setMonitorId(existingMonitorIds).setKey(new InterfaceMonitorIdKey(infName)).setInterfaceName(infName).build();
+            interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setMonitorId(existingMonitorIds)
+                    .setKey(new InterfaceMonitorIdKey(infName)).setInterfaceName(infName).build();
             MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, interfaceMonitorIdInstance);
         }
     }
 
-    public static void createOrUpdateMonitorIdInterfaceMap(DataBroker broker,String infName,  long monitorId) {
+    public static void createOrUpdateMonitorIdInterfaceMap(DataBroker broker, String infName, long monitorId) {
         MonitorIdInterface monitorIdInterfaceInstance;
         String existinginterfaceName;
         MonitorIdInterfaceBuilder monitorIdInterfaceBuilder = new MonitorIdInterfaceBuilder();
-        InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class).child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
+        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()) {
             monitorIdInterfaceInstance = monitorIdInterfaceMap.get();
             existinginterfaceName = monitorIdInterfaceInstance.getInterfaceName();
-            if(!existinginterfaceName.equals(infName)) {
-                monitorIdInterfaceInstance = monitorIdInterfaceBuilder.setKey(new MonitorIdInterfaceKey(monitorId)).setInterfaceName(infName).build();
+            if (!existinginterfaceName.equals(infName)) {
+                monitorIdInterfaceInstance = monitorIdInterfaceBuilder.setKey(new MonitorIdInterfaceKey(monitorId))
+                        .setInterfaceName(infName).build();
                 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, id, monitorIdInterfaceInstance);
             }
         } else {
-            monitorIdInterfaceInstance = monitorIdInterfaceBuilder.setMonitorId(monitorId).setKey(new MonitorIdInterfaceKey(monitorId)).setInterfaceName(infName).build();
+            monitorIdInterfaceInstance = monitorIdInterfaceBuilder.setMonitorId(monitorId)
+                    .setKey(new MonitorIdInterfaceKey(monitorId)).setInterfaceName(infName).build();
             MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, monitorIdInterfaceInstance);
         }
     }
 
     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;
+        InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class)
+                .child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
+        return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, broker).transform(InterfaceMonitorId::getMonitorId)
+                .orNull();
     }
 
-    public static long createMonitorProfile(AlivenessMonitorService alivenessMonitor, MonitorProfileCreateInput monitorProfileCreateInput) {
+    public static long createMonitorProfile(AlivenessMonitorService alivenessMonitor,
+            MonitorProfileCreateInput monitorProfileCreateInput) {
         try {
-            Future<RpcResult<MonitorProfileCreateOutput>> result = alivenessMonitor.monitorProfileCreate(monitorProfileCreateInput);
+            Future<RpcResult<MonitorProfileCreateOutput>> result = alivenessMonitor
+                    .monitorProfileCreate(monitorProfileCreateInput);
             RpcResult<MonitorProfileCreateOutput> rpcResult = result.get();
-            if(rpcResult.isSuccessful()) {
+            if (rpcResult.isSuccessful()) {
                 return rpcResult.getResult().getProfileId();
             } else {
-                LOG.warn("RPC Call to Get Profile Id Id returned with Errors {}.. Trying to fetch existing profile ID", rpcResult.getErrors());
-                try{
-                    Profile createProfile = monitorProfileCreateInput.getProfile();
-                    Future<RpcResult<MonitorProfileGetOutput>> existingProfile = alivenessMonitor.monitorProfileGet(buildMonitorGetProfile(createProfile.getMonitorInterval(), createProfile.getMonitorWindow(), createProfile.getFailureThreshold(), createProfile.getProtocolType()));
-                    RpcResult<MonitorProfileGetOutput> rpcGetResult = existingProfile.get();
-                    if(rpcGetResult.isSuccessful()){
-                        return rpcGetResult.getResult().getProfileId();
-                    }else{
-                        LOG.warn("RPC Call to Get Existing Profile Id returned with Errors {}", rpcGetResult.getErrors());
-                    }
-                }catch(Exception e){
-                    LOG.warn("Exception when getting existing profile",e);
+                LOG.warn("RPC Call to Get Profile Id Id returned with Errors {}.. Trying to fetch existing profile ID",
+                        rpcResult.getErrors());
+                Profile createProfile = monitorProfileCreateInput.getProfile();
+                Future<RpcResult<MonitorProfileGetOutput>> existingProfile = alivenessMonitor.monitorProfileGet(
+                        buildMonitorGetProfile(createProfile.getMonitorInterval(), createProfile.getMonitorWindow(),
+                                createProfile.getFailureThreshold(), createProfile.getProtocolType()));
+                RpcResult<MonitorProfileGetOutput> rpcGetResult = existingProfile.get();
+                if (rpcGetResult.isSuccessful()) {
+                    return rpcGetResult.getResult().getProfileId();
+                } else {
+                    LOG.warn("RPC Call to Get Existing Profile Id returned with Errors {}", rpcGetResult.getErrors());
                 }
             }
         } catch (InterruptedException | ExecutionException e) {
-            LOG.warn("Exception when allocating profile Id",e);
+            LOG.warn("Exception when allocating profile Id", e);
         }
         return 0;
     }
 
-    private static MonitorProfileGetInput buildMonitorGetProfile(long monitorInterval, long monitorWindow, long failureThreshold, EtherTypes protocolType){
-        MonitorProfileGetInputBuilder buildGetProfile = new MonitorProfileGetInputBuilder();
-        org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.get.input.ProfileBuilder profileBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.get.input.ProfileBuilder();
+    private static MonitorProfileGetInput buildMonitorGetProfile(long monitorInterval, long monitorWindow,
+            long failureThreshold, EtherTypes protocolType) {
+        org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor
+            .rev160411.monitor.profile.get.input.ProfileBuilder profileBuilder =
+            new org.opendaylight.yang.gen.v1.urn.opendaylight
+            .genius.alivenessmonitor.rev160411.monitor.profile.get.input.ProfileBuilder();
+
         profileBuilder.setFailureThreshold(failureThreshold);
         profileBuilder.setMonitorInterval(monitorInterval);
         profileBuilder.setMonitorWindow(monitorWindow);
         profileBuilder.setProtocolType(protocolType);
+        MonitorProfileGetInputBuilder buildGetProfile = new MonitorProfileGetInputBuilder();
         buildGetProfile.setProfile(profileBuilder.build());
-        return (buildGetProfile.build());
-    };
-
-    public static long allocateProfile(AlivenessMonitorService alivenessMonitor, long FAILURE_THRESHOLD, long MONITORING_INTERVAL,
-                                       long MONITORING_WINDOW, EtherTypes etherTypes) {
-        MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder().
-                setProfile(new ProfileBuilder().setFailureThreshold(FAILURE_THRESHOLD)
-                        .setMonitorInterval(MONITORING_INTERVAL).setMonitorWindow(MONITORING_WINDOW).
-                                setProtocolType(etherTypes).build()).build();
-        return createMonitorProfile(alivenessMonitor, input);
+        return buildGetProfile.build();
     }
 
-    public static boolean lldpMonitoringEnabled(IfTunnel ifTunnel){
-        if(ifTunnel.isInternal() && ifTunnel.isMonitorEnabled() &&
-                TunnelMonitoringTypeLldp.class.isAssignableFrom(ifTunnel.getMonitorProtocol())){
-            return true;
-        }
-        return false;
+    public static long allocateProfile(AlivenessMonitorService alivenessMonitor, long failureThreshold,
+            long monitoringInterval, long monitoringWindow, EtherTypes etherTypes) {
+        MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder().setProfile(
+                new ProfileBuilder().setFailureThreshold(failureThreshold).setMonitorInterval(monitoringInterval)
+                        .setMonitorWindow(monitoringWindow).setProtocolType(etherTypes).build())
+                .build();
+        return createMonitorProfile(alivenessMonitor, input);
     }
 
-    public static Profile getDefaultMonitorProfile(EtherTypes etherType) {
-        ProfileBuilder profileBuilder = new ProfileBuilder();
-        profileBuilder.setProtocolType(etherType);
-        profileBuilder.setFailureThreshold(FAILURE_THRESHOLD)
-                .setMonitorInterval(MONITORING_INTERVAL).setMonitorWindow(MONITORING_WINDOW).setProtocolType(etherType);
-        return profileBuilder.build();
+    public static boolean lldpMonitoringEnabled(IfTunnel ifTunnel) {
+        return ifTunnel.isInternal() && ifTunnel.isMonitorEnabled()
+                && TunnelMonitoringTypeLldp.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
     }
 }