itm/itm-impl/src/main/java/org/opendaylight/vpnservice/itm/monitoring/ItmTunnelEventListener.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.vpnservice.itm.monitoring;
   9
  10 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  11 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  12 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  14 import org.opendaylight.vpnservice.itm.impl.ItmUtils;
  15 import org.opendaylight.vpnservice.mdsalutil.AbstractDataChangeListener;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.TunnelList;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnel;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.InternalTunnel;
  22 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  23 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 import java.math.BigInteger;
  28
  29 /**
  30  * Created by emnqrrw on 11/2/2015.
  31  */
  32 public class ItmTunnelEventListener extends AbstractDataChangeListener<Interface> implements AutoCloseable {
  33
  34     private static final Logger logger = LoggerFactory.getLogger(ItmTunnelEventListener.class);
  35     private final DataBroker broker;
  36     private ListenerRegistration<DataChangeListener> listenerRegistration;
  37     public static final JMXAlarmAgent alarmAgent = new JMXAlarmAgent();
  38
  39     public ItmTunnelEventListener(final DataBroker db){
  40         super(Interface.class);
  41         broker = db;
  42         registerListener(db);
  43         alarmAgent.registerMbean();
  44     }
  45
  46     private void registerListener(final DataBroker db) {
  47         try {
  48             listenerRegistration = broker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  49                             getWildCardPath(), ItmTunnelEventListener.this, AsyncDataBroker.DataChangeScope.SUBTREE);
  50         } catch (final Exception e) {
  51             logger.error("ITM Monitor Interfaces DataChange listener registration fail!", e);
  52             throw new IllegalStateException("ITM Monitor registration Listener failed.", e);
  53         }
  54     }
  55
  56     private InstanceIdentifier<Interface> getWildCardPath() {
  57         return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
  58     }
  59
  60     @Override
  61     protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
  62         String ifName = del.getName() ;
  63         if( del.getType() != null && del.getType().equals(Tunnel.class)) {
  64             InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName,broker);
  65             if( internalTunnel != null) {
  66                 BigInteger srcDpId = internalTunnel.getSourceDPN();
  67                 BigInteger dstDpId = internalTunnel.getDestinationDPN();
  68                 String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
  69                 logger.trace("ITM Tunnel removed b/w srcDpn: {} and dstDpn: {} for tunnelType: {}", srcDpId, dstDpId, tunnelType);
  70                 clearInternalDataPathAlarm(srcDpId.toString(),dstDpId.toString(),tunnelType);
  71             }else {
  72                 ExternalTunnel externalTunnel = ItmUtils.getExternalTunnel(ifName,broker);
  73                 if( externalTunnel != null) {
  74                     String srcNode = externalTunnel.getSourceDevice();
  75                     String dstNode = externalTunnel.getDestinationDevice();
  76                     String tunnelType = ItmUtils.convertTunnelTypetoString(externalTunnel.getTransportType());
  77                     logger.trace("ITM Tunnel removed b/w srcNode: {} and dstNode: {} for tunnelType: {}", srcNode, dstNode, tunnelType);
  78                     clearExternalDataPathAlarm(srcNode,dstNode,tunnelType);
  79                 }
  80             }
  81         }
  82     }
  83
  84     @Override
  85     protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
  86         String ifName = update.getName() ;
  87         if( update.getType() != null && update.getType().equals(Tunnel.class)) {
  88             InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName,broker);
  89             if( internalTunnel != null) {
  90                 BigInteger srcDpId = internalTunnel.getSourceDPN();
  91                 BigInteger dstDpId = internalTunnel.getDestinationDPN();
  92                 String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
  93                 logger.trace("ITM Tunnel state event changed from :{} to :{} for Tunnel Interface - {}", isTunnelInterfaceUp(original), isTunnelInterfaceUp(update), ifName);
  94                 if(isTunnelInterfaceUp(update)) {
  95                     logger.trace("ITM Tunnel State is UP b/w srcDpn: {} and dstDpn: {} for tunnelType {} ", srcDpId, dstDpId, tunnelType);
  96                     clearInternalDataPathAlarm(srcDpId.toString(),dstDpId.toString(),tunnelType);
  97                 }else {
  98                     logger.trace("ITM Tunnel State is DOWN b/w srcDpn: {} and dstDpn: {}", srcDpId, dstDpId);
  99                     StringBuilder alarmText = new StringBuilder();
 100                     alarmText.append("Data Path Connectivity is lost between ").append("openflow:").append(srcDpId).append(" and openflow:")
 101                                     .append(dstDpId).append(" for tunnelType:").append(tunnelType);
 102                     raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType,alarmText.toString());
 103                 }
 104             }else{
 105                 ExternalTunnel externalTunnel = ItmUtils.getExternalTunnel(ifName,broker);
 106                 if( externalTunnel != null) {
 107                     String srcNode = externalTunnel.getSourceDevice();
 108                     String dstNode = externalTunnel.getDestinationDevice();
 109                     String tunnelType = ItmUtils.convertTunnelTypetoString(externalTunnel.getTransportType());
 110                     logger.trace("ITM Tunnel state event changed from :{} to :{} for Tunnel Interface - {}", isTunnelInterfaceUp(original), isTunnelInterfaceUp(update), ifName);
 111                     if(isTunnelInterfaceUp(update)) {
 112                         logger.trace("ITM Tunnel State is UP b/w srcNode: {} and dstNode: {} for tunnelType: {}", srcNode, dstNode, tunnelType);
 113                         clearExternalDataPathAlarm(srcNode.toString(),dstNode.toString(),tunnelType);
 114                     }else {
 115                         logger.trace("ITM Tunnel State is DOWN b/w srcNode: {} and dstNode: {}", srcNode, dstNode);
 116                         StringBuilder alarmText = new StringBuilder();
 117                         alarmText.append("Data Path Connectivity is lost between ").append(srcNode).append(dstNode).append(" for tunnelType:").append(tunnelType);
 118                         raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,alarmText.toString());
 119                     }
 120                 }
 121             }
 122         }
 123     }
 124
 125     @Override
 126     protected void add(InstanceIdentifier<Interface> identifier, Interface add) {
 127         String ifName = add.getName() ;
 128         if( add.getType() != null && add.getType().equals(Tunnel.class)) {
 129             InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName,broker);
 130             if( internalTunnel != null) {
 131                 BigInteger srcDpId = internalTunnel.getSourceDPN();
 132                 BigInteger dstDpId = internalTunnel.getDestinationDPN();
 133                 String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
 134                 if(!isTunnelInterfaceUp(add)) {
 135                     logger.trace("ITM Tunnel State during tep add is DOWN b/w srcDpn: {} and dstDpn: {} for tunnelType: {}", srcDpId, dstDpId, tunnelType);
 136                     StringBuilder alarmText = new StringBuilder();
 137                     alarmText.append("Data Path Connection is down between ").append("openflow:").append(srcDpId).append(" and openflow:")
 138                                     .append(dstDpId).append(" for tunnelType:").append(tunnelType).append(" during initial state");
 139                     raiseInternalDataPathAlarm(srcDpId.toString(), dstDpId.toString(), tunnelType, alarmText.toString());
 140                 }
 141             }else {
 142                 ExternalTunnel externalTunnel = ItmUtils.getExternalTunnel(ifName,broker);
 143                 if( externalTunnel != null) {
 144                     String srcNode = externalTunnel.getSourceDevice();
 145                     String dstNode = externalTunnel.getDestinationDevice();
 146                     String tunnelType = ItmUtils.convertTunnelTypetoString(externalTunnel.getTransportType());
 147                     if(!isTunnelInterfaceUp(add)) {
 148                         logger.trace("ITM Tunnel State during tep add is DOWN b/w srcNode: {} and dstNode: {} for tunnelType: {}", srcNode, dstNode, tunnelType);
 149                         StringBuilder alarmText = new StringBuilder();
 150                         alarmText.append("Data Path Connection is down between ").append(srcNode).append(dstNode).append(" for tunnelType:").append(tunnelType).append(" during initial state");
 151                         raiseExternalDataPathAlarm(srcNode, dstNode, tunnelType,alarmText.toString());
 152                     }
 153                 }
 154             }
 155         }
 156     }
 157
 158     @Override
 159     public void close() throws Exception {
 160         if (listenerRegistration != null) {
 161             try {
 162                 listenerRegistration.close();
 163             } catch (final Exception e) {
 164                 logger.error("Error when cleaning up DataChangeListener.", e);
 165             }
 166             listenerRegistration = null;
 167         }
 168     }
 169
 170     public void raiseInternalDataPathAlarm(String srcDpnId,String dstDpnId,String tunnelType,String alarmText) {
 171
 172         StringBuilder source = new StringBuilder();
 173         source.append("srcDpn=openflow:").append(srcDpnId).append("-dstDpn=openflow:").append(dstDpnId).append("-tunnelType").append(tunnelType);
 174
 175         logger.trace("Raising DataPathConnectionFailure alarm... alarmText {} source {} ", alarmText, source);
 176         //Invokes JMX raiseAlarm method
 177         alarmAgent.invokeFMraisemethod("DataPathConnectionFailure", alarmText, source.toString());
 178     }
 179
 180     public void clearInternalDataPathAlarm(String srcDpnId,String dstDpnId,String tunnelType) {
 181         StringBuilder source = new StringBuilder();
 182
 183         source.append("srcDpn=openflow:").append(srcDpnId).append("-dstDpn=openflow:").append(dstDpnId).append("-tunnelType").append(tunnelType);
 184         logger.trace("Clearing DataPathConnectionFailure alarm of source {} ", source);
 185         //Invokes JMX clearAlarm method
 186         alarmAgent.invokeFMclearmethod("DataPathConnectionFailure", "Clearing ITM Tunnel down alarm", source.toString());
 187     }
 188
 189     public void raiseExternalDataPathAlarm(String srcDevice,String dstDevice,String tunnelType, String alarmText) {
 190
 191         StringBuilder source = new StringBuilder();
 192         source.append("srcDevice=").append(srcDevice).append("-dstDevice=").append(dstDevice).append("-tunnelType").append(tunnelType);
 193
 194         logger.trace("Raising DataPathConnectionFailure alarm... alarmText {} source {} ", alarmText, source);
 195         //Invokes JMX raiseAlarm method
 196         alarmAgent.invokeFMraisemethod("DataPathConnectionFailure", alarmText, source.toString());
 197     }
 198
 199
 200     public void clearExternalDataPathAlarm(String srcDevice,String dstDevice,String tunnelType) {
 201
 202         StringBuilder source = new StringBuilder();
 203
 204         source.append("srcDevice=").append(srcDevice).append("-dstDevice=").append(dstDevice).append("-tunnelType").append(tunnelType);
 205
 206         //logger.trace("Clearing DataPathConnectionFailure alarm of source {} ", source);
 207         //Invokes JMX clearAlarm method
 208         alarmAgent.invokeFMclearmethod("DataPathConnectionFailure", "Clearing ITM Tunnel down alarm", source.toString());
 209
 210     }
 211
 212     private boolean isTunnelInterfaceUp( Interface intf) {
 213         boolean interfaceUp = (intf.getOperStatus().equals(Interface.OperStatus.Up)) ? true :false ;
 214         return interfaceUp ;
 215     }
 216
 217 }