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 java.util.concurrent.ExecutionException;
  13 import java.util.concurrent.Future;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.EtherTypes;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInputBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  33 import org.opendaylight.yangtools.yang.binding.DataObject;
  34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  35 import org.opendaylight.yangtools.yang.common.RpcResult;
  36
  37 abstract class AbstractAlivenessProtocolHandler implements AlivenessProtocolHandler {
  38
  39     private final DataBroker dataBroker;
  40     private final OdlInterfaceRpcService interfaceManager;
  41     private InventoryReader inventoryReader;
  42
  43     public AbstractAlivenessProtocolHandler(final DataBroker dataBroker,
  44                                             final OdlInterfaceRpcService interfaceManager,
  45                                             final AlivenessMonitor alivenessMonitor,
  46                                             final EtherTypes etherType) {
  47         this.dataBroker = dataBroker;
  48         this.interfaceManager = interfaceManager;
  49         alivenessMonitor.registerHandler(etherType, this);
  50         inventoryReader = new InventoryReader(dataBroker);
  51     }
  52
  53     private InstanceIdentifier<NodeConnector> getNodeConnectorId(String interfaceName) {
  54         InstanceIdentifier<Interface> id =  InstanceIdentifier.builder(Interfaces.class)
  55                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
  56
  57         if (read(LogicalDatastoreType.CONFIGURATION, id).isPresent()) {
  58             NodeConnectorId ncId = getNodeConnectorIdFromInterface(interfaceName);
  59             NodeId nodeId = getNodeIdFromNodeConnectorId(ncId);
  60
  61             InstanceIdentifier<NodeConnector> ncIdentifier =
  62                     InstanceIdentifier.builder(Nodes.class)
  63                             .child(Node.class, new NodeKey(nodeId))
  64                             .child(NodeConnector.class, new NodeConnectorKey(ncId)).build();
  65             return ncIdentifier;
  66         }
  67         return null;
  68     }
  69
  70     private NodeConnectorId getNodeConnectorIdFromInterface(String interfaceName) {
  71         GetNodeconnectorIdFromInterfaceInput input = new GetNodeconnectorIdFromInterfaceInputBuilder().setIntfName(interfaceName).build();
  72         Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> output =
  73                 interfaceManager.getNodeconnectorIdFromInterface(input);
  74         RpcResult<GetNodeconnectorIdFromInterfaceOutput> result = null;
  75         try {
  76             result = output.get();
  77             if(result.isSuccessful()) {
  78                 GetNodeconnectorIdFromInterfaceOutput ncIdOutput = result.getResult();
  79                 return ncIdOutput.getNodeconnectorId();
  80             }
  81         } catch(ExecutionException | InterruptedException e) {
  82             //TODO: Handle exception
  83         }
  84
  85         return null;
  86     }
  87
  88     private NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
  89         return new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
  90     }
  91
  92     protected org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceFromOperDS(String interfaceName){
  93         InstanceIdentifier.InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
  94                 InstanceIdentifier.builder(InterfacesState.class).child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
  95                         new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(interfaceName));
  96         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id = idBuilder.build();
  97         return read(LogicalDatastoreType.OPERATIONAL, id).orNull();
  98     }
  99
 100     protected byte[] getMacAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState, String interfaceName) {
 101         String macAddress = interfaceState.getPhysAddress().getValue();
 102         if(!Strings.isNullOrEmpty(macAddress)) {
 103             return AlivenessMonitorUtil.parseMacAddress(macAddress);
 104         }
 105         return null;
 106     }
 107
 108     private InstanceIdentifier<Interface> getInterfaceIdentifier(InterfaceKey interfaceKey) {
 109         InstanceIdentifier.InstanceIdentifierBuilder<Interface> interfaceInstanceIdentifierBuilder =
 110                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, interfaceKey);
 111         return interfaceInstanceIdentifierBuilder.build();
 112     }
 113
 114     protected Interface getInterfaceFromConfigDS(String interfaceName) {
 115         InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 116         InstanceIdentifier<Interface> interfaceId = getInterfaceIdentifier(interfaceKey);
 117         return read(LogicalDatastoreType.CONFIGURATION, interfaceId).orNull();
 118     }
 119
 120     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 121                                                     InstanceIdentifier<T> path) {
 122
 123         try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
 124             return tx.read(datastoreType, path).get();
 125         } catch (Exception e) {
 126             throw new RuntimeException(e);
 127         }
 128     }
 129 }