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

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.alivenessmonitor.internal;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Strings;
  12 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  14 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  15 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInputBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
  28 import org.opendaylight.yangtools.yang.binding.DataObject;
  29 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  30 import org.opendaylight.yangtools.yang.common.RpcResult;
  31
  32 import java.util.concurrent.ExecutionException;
  33 import java.util.concurrent.Future;
  34
  35 abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHandler {
  36
  37     protected ServiceProvider serviceProvider;
  38     private InventoryReader inventoryReader;
  39
  40     public AbstractAlivenessProtocolHandler(ServiceProvider serviceProvider) {
  41         this.serviceProvider = serviceProvider;
  42         inventoryReader = new InventoryReader(serviceProvider.getDataBroker());
  43     }
  44
  45     private InstanceIdentifier<NodeConnector> getNodeConnectorId(String interfaceName) {
  46         InstanceIdentifier<Interface> id =  InstanceIdentifier.builder(Interfaces.class)
  47                                       .child(Interface.class, new InterfaceKey(interfaceName)).build();
  48
  49         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
  50         if(port.isPresent()) {
  51             NodeConnectorId ncId = getNodeConnectorIdFromInterface(interfaceName);
  52             NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
  53
  54             InstanceIdentifier<NodeConnector> ncIdentifier =
  55                                           InstanceIdentifier.builder(Nodes.class)
  56                                                       .child(Node.class, new NodeKey(nodeId))
  57                                                       .child(NodeConnector.class, new NodeConnectorKey(ncId)).build();
  58             return ncIdentifier;
  59         }
  60         return null;
  61     }
  62
  63     private NodeConnectorId getNodeConnectorIdFromInterface(String interfaceName) {
  64         GetNodeconnectorIdFromInterfaceInput input = new GetNodeconnectorIdFromInterfaceInputBuilder().setIntfName(interfaceName).build();
  65         Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> output =  serviceProvider.getInterfaceManager().getNodeconnectorIdFromInterface(input);
  66         RpcResult<GetNodeconnectorIdFromInterfaceOutput> result = null;
  67         try {
  68              result = output.get();
  69              if(result.isSuccessful()) {
  70                  GetNodeconnectorIdFromInterfaceOutput ncIdOutput = result.getResult();
  71                  return ncIdOutput.getNodeconnectorId();
  72              }
  73         } catch(ExecutionException | InterruptedException e) {
  74             //TODO: Handle exception
  75         }
  76
  77         return null;
  78     }
  79
  80     private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
  81         return new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
  82     }
  83
  84     protected org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceFromOperDS(String interfaceName){
  85         InstanceIdentifier.InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
  86                 InstanceIdentifier.builder(InterfacesState.class).child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
  87                         new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
  88         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id = idBuilder.build();
  89         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateOptional = read(LogicalDatastoreType.OPERATIONAL, id);
  90         if(interfaceStateOptional.isPresent()) {
  91             return interfaceStateOptional.get();
  92         }
  93         return null;
  94     }
  95
  96     protected byte[] getMacAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState, String interfaceName) {
  97         String macAddress = interfaceState.getPhysAddress().getValue();
  98         if(!Strings.isNullOrEmpty(macAddress)) {
  99             return AlivenessMonitorUtil.parseMacAddress(macAddress);
 100         }
 101         return null;
 102     }
 103
 104     private InstanceIdentifier<Interface> getInterfaceIdentifier(InterfaceKey interfaceKey) {
 105         InstanceIdentifier.InstanceIdentifierBuilder<Interface> interfaceInstanceIdentifierBuilder =
 106                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, interfaceKey);
 107         return interfaceInstanceIdentifierBuilder.build();
 108     }
 109
 110     protected Interface getInterfaceFromConfigDS(String interfaceName) {
 111         InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 112         InstanceIdentifier<Interface> interfaceId = getInterfaceIdentifier(interfaceKey);
 113         Optional<Interface> interfaceOptional = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
 114         if (!interfaceOptional.isPresent()) {
 115             return null;
 116         }
 117
 118         return interfaceOptional.get();
 119     }
 120
 121
 122     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 123                                                     InstanceIdentifier<T> path) {
 124
 125         ReadOnlyTransaction tx = serviceProvider.getDataBroker().newReadOnlyTransaction();
 126
 127         Optional<T> result = Optional.absent();
 128         try {
 129             result = tx.read(datastoreType, path).get();
 130         } catch (Exception e) {
 131             throw new RuntimeException(e);
 132         } finally {
 133             tx.close();
 134         }
 135
 136         return result;
 137     }
 138
 139 }