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