dhcpservice/dhcpservice-impl/src/main/java/org/opendaylight/vpnservice/dhcpservice/DhcpInterfaceEventListener.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.dhcpservice;
   9
  10 import java.math.BigInteger;
  11 import java.util.List;
  12
  13 import org.apache.commons.lang3.tuple.ImmutablePair;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  16 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  18 import org.opendaylight.vpnservice.dhcpservice.api.DHCPMConstants;
  19 import org.opendaylight.vpnservice.mdsalutil.AbstractDataChangeListener;
  20 import org.opendaylight.vpnservice.mdsalutil.MDSALDataStoreUtils;
  21 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.InterfaceNameMacAddresses;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddress;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddressBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddressKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
  34 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 import com.google.common.base.Optional;
  40 import com.google.common.util.concurrent.FutureCallback;
  41
  42 public class DhcpInterfaceEventListener extends AbstractDataChangeListener<Interface> implements AutoCloseable {
  43
  44     private static final Logger logger = LoggerFactory.getLogger(DhcpInterfaceEventListener.class);
  45     private DhcpManager dhcpManager;
  46     private ListenerRegistration<DataChangeListener> listenerRegistration;
  47     private DataBroker dataBroker;
  48     private static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
  49         @Override
  50         public void onSuccess(Void result) {
  51             logger.debug("Success in Datastore write operation");
  52         }
  53
  54         @Override
  55         public void onFailure(Throwable error) {
  56             logger.error("Error in Datastore write operation", error);
  57         }
  58     };
  59     private DhcpExternalTunnelManager dhcpExternalTunnelManager;
  60
  61     public DhcpInterfaceEventListener(DhcpManager dhcpManager, DataBroker dataBroker, DhcpExternalTunnelManager dhcpExternalTunnelManager) {
  62         super(Interface.class);
  63         this.dhcpManager = dhcpManager;
  64         this.dataBroker = dataBroker;
  65         this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
  66         registerListener();
  67     }
  68
  69     private void registerListener() {
  70         try {
  71             listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  72                 getWildCardPath(), DhcpInterfaceEventListener.this, DataChangeScope.SUBTREE);
  73         } catch (final Exception e) {
  74             logger.error("DhcpInterfaceEventListener DataChange listener registration fail!", e);
  75             throw new IllegalStateException("DhcpInterfaceEventListener registration Listener failed.", e);
  76         }
  77     }
  78
  79     private InstanceIdentifier<Interface> getWildCardPath() {
  80         return InstanceIdentifier.create(InterfacesState.class).child(Interface.class);
  81     }
  82
  83     @Override
  84     public void close() throws Exception {
  85         if (listenerRegistration != null) {
  86             try {
  87                 listenerRegistration.close();
  88             } catch (final Exception e) {
  89                 logger.error("Error when cleaning up DataChangeListener.", e);
  90             }
  91             listenerRegistration = null;
  92         }
  93         logger.info("Interface Manager Closed");
  94     }
  95
  96
  97     @Override
  98     protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
  99         List<String> ofportIds = del.getLowerLayerIf();
 100         if (ofportIds == null || ofportIds.isEmpty()) {
 101             return;
 102         }
 103         NodeConnectorId nodeConnectorId = new NodeConnectorId(ofportIds.get(0));
 104         BigInteger dpId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(nodeConnectorId));
 105         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
 106                 DhcpServiceUtils.getInterfaceFromConfigDS(del.getName(), dataBroker);
 107         if (iface != null) {
 108             IfTunnel tunnelInterface = iface.getAugmentation(IfTunnel.class);
 109             if (tunnelInterface != null && !tunnelInterface.isInternal()) {
 110                 IpAddress tunnelIp = tunnelInterface.getTunnelDestination();
 111                 List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(dataBroker);
 112                 if (dpns.contains(dpId)) {
 113                     dhcpExternalTunnelManager.handleTunnelStateDown(tunnelIp, dpId);
 114                 }
 115                 return;
 116             }
 117         }
 118         String interfaceName = del.getName();
 119         logger.trace("Received remove DCN for interface {} dpId {}", interfaceName, dpId);
 120         unInstallDhcpEntries(interfaceName, dpId);
 121         dhcpManager.removeInterfaceCache(interfaceName);
 122     }
 123
 124     @Override
 125     protected void update(InstanceIdentifier<Interface> identifier,
 126             Interface original, Interface update) {
 127         List<String> ofportIds = update.getLowerLayerIf();
 128         if (ofportIds == null || ofportIds.isEmpty()) {
 129             return;
 130         }
 131         NodeConnectorId nodeConnectorId = new NodeConnectorId(ofportIds.get(0));
 132         BigInteger dpId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(nodeConnectorId));
 133         String interfaceName = update.getName();
 134         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
 135                 DhcpServiceUtils.getInterfaceFromConfigDS(interfaceName, dataBroker);
 136         if (iface == null) {
 137             logger.trace("Interface {} is not present in the config DS", interfaceName);
 138             return;
 139         }
 140         if (update.getType() == null) {
 141             logger.trace("Interface type for interface {} is null", interfaceName);
 142             return;
 143         }
 144         if ((original.getOperStatus().getIntValue() ^ update.getOperStatus().getIntValue()) == 0) {
 145             logger.trace("Interface operstatus {} is same", update.getOperStatus());
 146             return;
 147         }
 148         if (Tunnel.class.equals(update.getType())) {
 149             IfTunnel tunnelInterface = iface.getAugmentation(IfTunnel.class);
 150             if (tunnelInterface != null && !tunnelInterface.isInternal()) {
 151                 IpAddress tunnelIp = tunnelInterface.getTunnelDestination();
 152                 List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(dataBroker);
 153                 if (dpns.contains(dpId)) {
 154                     if (update.getOperStatus() == OperStatus.Down) {
 155                         dhcpExternalTunnelManager.handleTunnelStateDown(tunnelIp, dpId);
 156                     } else if (update.getOperStatus() == OperStatus.Up) {
 157                         dhcpExternalTunnelManager.handleTunnelStateUp(tunnelIp, dpId);
 158                     }
 159                 }
 160             }
 161             return;
 162         }
 163     }
 164
 165     @Override
 166     protected void add(InstanceIdentifier<Interface> identifier, Interface add) {
 167         String interfaceName = add.getName();
 168         List<String> ofportIds = add.getLowerLayerIf();
 169         if (ofportIds == null || ofportIds.isEmpty()) {
 170             return;
 171         }
 172         NodeConnectorId nodeConnectorId = new NodeConnectorId(ofportIds.get(0));
 173         BigInteger dpId = BigInteger.valueOf(MDSALUtil.getDpnIdFromPortName(nodeConnectorId));
 174         logger.trace("Received add DCN for interface {}, dpid {}", interfaceName, dpId);
 175         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
 176                 DhcpServiceUtils.getInterfaceFromConfigDS(add.getName(), dataBroker);
 177         if (iface != null) {
 178             IfTunnel tunnelInterface = iface.getAugmentation(IfTunnel.class);
 179             if (tunnelInterface != null && !tunnelInterface.isInternal()) {
 180                 IpAddress tunnelIp = tunnelInterface.getTunnelDestination();
 181                 List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(dataBroker);
 182                 if (dpns.contains(dpId)) {
 183                     dhcpExternalTunnelManager.handleTunnelStateUp(tunnelIp, dpId);
 184                 }
 185                 return;
 186             }
 187         }
 188         if (!dpId.equals(DHCPMConstants.INVALID_DPID)) {
 189             installDhcpEntries(interfaceName, dpId);
 190             dhcpManager.updateInterfaceCache(interfaceName, new ImmutablePair<BigInteger, String>(dpId, add.getPhysAddress().getValue()));
 191         }
 192     }
 193
 194     private String getNeutronMacAddress(String interfaceName) {
 195         Port port = dhcpManager.getNeutronPort(interfaceName);
 196         if (port!=null) {
 197             logger.trace("Port found in neutron. Interface Name {}, port {}", interfaceName, port);
 198             return port.getMacAddress();
 199         }
 200         return null;
 201     }
 202
 203     private void unInstallDhcpEntries(String interfaceName, BigInteger dpId) {
 204         String vmMacAddress = getAndRemoveVmMacAddress(interfaceName);
 205         dhcpManager.unInstallDhcpEntries(dpId, vmMacAddress);
 206     }
 207
 208     private void installDhcpEntries(String interfaceName, BigInteger dpId) {
 209         String vmMacAddress = getAndUpdateVmMacAddress(interfaceName);
 210         dhcpManager.installDhcpEntries(dpId, vmMacAddress);
 211     }
 212
 213     private String getAndUpdateVmMacAddress(String interfaceName) {
 214         InstanceIdentifier<InterfaceNameMacAddress> instanceIdentifier = InstanceIdentifier.builder(InterfaceNameMacAddresses.class).child(InterfaceNameMacAddress.class, new InterfaceNameMacAddressKey(interfaceName)).build();
 215         Optional<InterfaceNameMacAddress> existingEntry = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
 216         if (!existingEntry.isPresent()) {
 217             logger.trace("Entry for interface {} missing in InterfaceNameVmMacAddress map", interfaceName);
 218             String vmMacAddress = getNeutronMacAddress(interfaceName);
 219             if (vmMacAddress==null || vmMacAddress.isEmpty()) {
 220                 return null;
 221             }
 222             logger.trace("Updating InterfaceNameVmMacAddress map with {}, {}", interfaceName,vmMacAddress);
 223             InterfaceNameMacAddress interfaceNameMacAddress = new InterfaceNameMacAddressBuilder().setKey(new InterfaceNameMacAddressKey(interfaceName)).setInterfaceName(interfaceName).setMacAddress(vmMacAddress).build();
 224             MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, instanceIdentifier, interfaceNameMacAddress);
 225             return vmMacAddress;
 226         }
 227         return existingEntry.get().getMacAddress();
 228     }
 229
 230     private String getAndRemoveVmMacAddress(String interfaceName) {
 231         InstanceIdentifier<InterfaceNameMacAddress> instanceIdentifier = InstanceIdentifier.builder(InterfaceNameMacAddresses.class).child(InterfaceNameMacAddress.class, new InterfaceNameMacAddressKey(interfaceName)).build();
 232         Optional<InterfaceNameMacAddress> existingEntry = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
 233         if (existingEntry.isPresent()) {
 234             String vmMacAddress = existingEntry.get().getMacAddress();
 235             logger.trace("Entry for interface found in InterfaceNameVmMacAddress map {}, {}", interfaceName, vmMacAddress);
 236             MDSALDataStoreUtils.asyncRemove(dataBroker, LogicalDatastoreType.OPERATIONAL, instanceIdentifier, DEFAULT_CALLBACK);
 237             return vmMacAddress;
 238         }
 239         logger.trace("Entry for interface {} missing in InterfaceNameVmMacAddress map", interfaceName);
 240         return null;
 241     }
 242 }