dhcpservice/impl/src/main/java/org/opendaylight/netvirt/dhcpservice/DhcpNeutronPortListener.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.netvirt.dhcpservice;
   9
  10 import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
  11 import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
  12
  13 import java.math.BigInteger;
  14 import java.util.ArrayList;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.Locale;
  18 import java.util.function.Consumer;
  19 import javax.annotation.PostConstruct;
  20 import javax.annotation.PreDestroy;
  21 import javax.inject.Inject;
  22 import javax.inject.Named;
  23 import javax.inject.Singleton;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
  27 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  28 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  29 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  30 import org.opendaylight.genius.mdsalutil.NwConstants;
  31 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  32 import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
  33 import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput;
  34 import org.opendaylight.netvirt.elan.arp.responder.ArpResponderInput.ArpReponderInputBuilder;
  35 import org.opendaylight.netvirt.elan.arp.responder.ArpResponderUtil;
  36 import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
  37 import org.opendaylight.netvirt.elanmanager.api.IElanService;
  38 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.config.rev150710.DhcpserviceConfig;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 @Singleton
  53 public class DhcpNeutronPortListener
  54         extends AsyncClusteredDataTreeChangeListenerBase<Port, DhcpNeutronPortListener> {
  55
  56     private static final Logger LOG = LoggerFactory.getLogger(DhcpNeutronPortListener.class);
  57     private final DhcpExternalTunnelManager dhcpExternalTunnelManager;
  58     private final IElanService elanService;
  59     private final DataBroker broker;
  60     private final ManagedNewTransactionRunner txRunner;
  61     private final DhcpserviceConfig config;
  62     private final IInterfaceManager interfaceManager;
  63     private final JobCoordinator jobCoordinator;
  64     private final DhcpManager dhcpManager;
  65     private final ItmRpcService itmRpcService;
  66
  67     @Inject
  68     public DhcpNeutronPortListener(DataBroker db, DhcpExternalTunnelManager dhcpExternalTunnelManager,
  69             @Named("elanService") IElanService ielanService, IInterfaceManager interfaceManager,
  70             DhcpserviceConfig config, final JobCoordinator jobCoordinator, DhcpManager dhcpManager,
  71             ItmRpcService itmRpcService) {
  72
  73         super(Port.class, DhcpNeutronPortListener.class);
  74         this.dhcpExternalTunnelManager = dhcpExternalTunnelManager;
  75         this.elanService = ielanService;
  76         this.interfaceManager = interfaceManager;
  77         this.broker = db;
  78         this.txRunner = new ManagedNewTransactionRunnerImpl(db);
  79         this.config = config;
  80         this.jobCoordinator = jobCoordinator;
  81         this.dhcpManager = dhcpManager;
  82         this.itmRpcService = itmRpcService;
  83     }
  84
  85     @PostConstruct
  86     public void init() {
  87         if (config.isControllerDhcpEnabled()) {
  88             registerListener(LogicalDatastoreType.CONFIGURATION, broker);
  89         }
  90     }
  91
  92     @Override
  93     protected InstanceIdentifier<Port> getWildCardPath() {
  94         return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
  95     }
  96
  97     @Override
  98     @PreDestroy
  99     public void close() {
 100         super.close();
 101         LOG.debug("DhcpNeutronPortListener Listener Closed");
 102     }
 103
 104     @Override
 105     protected void remove(InstanceIdentifier<Port> identifier, Port del) {
 106         LOG.trace("Port removed: {}", del);
 107         if (NeutronConstants.IS_ODL_DHCP_PORT.test(del)) {
 108             jobCoordinator.enqueueJob(getJobKey(del),
 109                 () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
 110                     java.util.Optional<String> ip4Address = DhcpServiceUtils.getIpV4Address(del);
 111                     if (ip4Address.isPresent()) {
 112                         dhcpExternalTunnelManager.addOrRemoveDhcpArpFlowforElan(del.getNetworkId().getValue(),
 113                                 false, ip4Address.get(), del.getMacAddress().getValue());
 114                     }
 115                     DhcpServiceUtils.removeSubnetDhcpPortData(del, tx::delete);
 116                     processArpResponderForElanDpns(del, arpInput -> {
 117                         LOG.trace("Removing ARPResponder Flows  for dhcp port {} with ipaddress {} with mac {} "
 118                                         + " on dpn {}. ",arpInput.getInterfaceName(), arpInput.getSpa(),
 119                                         arpInput.getSha(), arpInput.getDpId());
 120                         elanService.removeArpResponderFlow(arpInput);
 121                     });
 122                 })));
 123         }
 124         if (isVnicTypeDirectOrMacVtap(del)) {
 125             removePort(del);
 126         }
 127     }
 128
 129     private String getJobKey(Port port) {
 130         return "PORT- " + port.getUuid().getValue();
 131     }
 132
 133     @Override
 134     protected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
 135         LOG.trace("Port changed to {}", update);
 136         //With Ipv6 changes we can get ipv4 subnets later. The below check is to support such scenario.
 137         if (original.nonnullFixedIps().size() < update.nonnullFixedIps().size()) {
 138             final String interfaceName = update.getUuid().getValue();
 139             List<FixedIps> updatedFixedIps = new ArrayList<>(update.nonnullFixedIps());
 140             // Need to check only the newly added fixed ip.
 141             updatedFixedIps.removeAll(original.nonnullFixedIps());
 142             Subnet subnet = dhcpManager.getNeutronSubnet(updatedFixedIps);
 143             if (null == subnet || !subnet.isEnableDhcp()) {
 144                 LOG.trace("Subnet is null/not ipv4 or not enabled {}", subnet);
 145                 return;
 146             }
 147             // Binding the DHCP service for an existing port because of subnet change.
 148             jobCoordinator.enqueueJob(DhcpServiceUtils.getJobKey(interfaceName),
 149                 () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
 150                     LOG.debug("Binding DHCP service for interface {}", interfaceName);
 151                     DhcpServiceUtils.bindDhcpService(interfaceName, NwConstants.DHCP_TABLE, tx);
 152                 })), DhcpMConstants.RETRY_COUNT);
 153             jobCoordinator.enqueueJob(DhcpServiceUtils.getJobKey(interfaceName), () -> {
 154                 BigInteger dpnId = interfaceManager.getDpnForInterface(interfaceName);
 155                 if (dpnId == null || dpnId.equals(DhcpMConstants.INVALID_DPID)) {
 156                     LOG.trace("Unable to install the DHCP flow since dpn is not available");
 157                     return Collections.emptyList();
 158                 }
 159                 String vmMacAddress = txRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
 160                     tx -> DhcpServiceUtils.getAndUpdateVmMacAddress(tx, interfaceName, dhcpManager)).get();
 161                 return Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
 162                     tx -> dhcpManager.installDhcpEntries(dpnId, vmMacAddress, tx)));
 163             }, DhcpMConstants.RETRY_COUNT);
 164         }
 165         if (!isVnicTypeDirectOrMacVtap(update)) {
 166             LOG.trace("Port updated is normal {}", update.getUuid());
 167             if (isVnicTypeDirectOrMacVtap(original)) {
 168                 LOG.trace("Original Port was direct/macvtap {} so removing flows and cache entry if any",
 169                         update.getUuid());
 170                 removePort(original);
 171             }
 172             return;
 173         }
 174         if (!isVnicTypeDirectOrMacVtap(original)) {
 175             LOG.trace("Original port was normal and updated is direct. Calling addPort()");
 176             addPort(update);
 177             return;
 178         }
 179         String macOriginal = getMacAddress(original);
 180         String macUpdated = getMacAddress(update);
 181         String segmentationIdOriginal = DhcpServiceUtils.getSegmentationId(original.getNetworkId(), broker);
 182         String segmentationIdUpdated = DhcpServiceUtils.getSegmentationId(update.getNetworkId(), broker);
 183         if (macOriginal != null && !macOriginal.equalsIgnoreCase(macUpdated) && segmentationIdOriginal != null
 184                 && !segmentationIdOriginal.equalsIgnoreCase(segmentationIdUpdated)) {
 185             LOG.trace("Mac/segment id has changed");
 186             dhcpExternalTunnelManager.removeVniMacToPortCache(new BigInteger(segmentationIdOriginal), macOriginal);
 187             dhcpExternalTunnelManager.updateVniMacToPortCache(new BigInteger(segmentationIdUpdated),
 188                     macUpdated, update);
 189         }
 190     }
 191
 192     @Override
 193     protected void add(InstanceIdentifier<Port> identifier, Port add) {
 194         LOG.trace("Port added {}", add);
 195         if (NeutronConstants.IS_ODL_DHCP_PORT.test(add)) {
 196             jobCoordinator.enqueueJob(getJobKey(add),
 197                 () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
 198                     DhcpServiceUtils.createSubnetDhcpPortData(add, tx::put);
 199                     processArpResponderForElanDpns(add, arpInput -> {
 200                         LOG.trace(
 201                                 "Installing ARP RESPONDER Flows  for dhcp port {} ipaddress {} with mac {} on dpn {}",
 202                                 arpInput.getInterfaceName(), arpInput.getSpa(), arpInput.getSha(),
 203                                 arpInput.getDpId());
 204                         ArpReponderInputBuilder builder = new ArpReponderInputBuilder(arpInput);
 205                         builder.setInstructions(ArpResponderUtil.getInterfaceInstructions(interfaceManager,
 206                                 arpInput.getInterfaceName(), arpInput.getSpa(), arpInput.getSha(), itmRpcService));
 207                         elanService.addArpResponderFlow(builder.buildForInstallFlow());
 208                     });
 209                 })));
 210             java.util.Optional<String> ip4Address = DhcpServiceUtils.getIpV4Address(add);
 211             if (ip4Address.isPresent()) {
 212                 dhcpExternalTunnelManager.addOrRemoveDhcpArpFlowforElan(add.getNetworkId().getValue(),
 213                         true, ip4Address.get(), add.getMacAddress().getValue());
 214             }
 215         }
 216         if (!isVnicTypeDirectOrMacVtap(add)) {
 217             return;
 218         }
 219         addPort(add);
 220     }
 221
 222     private void removePort(Port port) {
 223         String macAddress = getMacAddress(port);
 224         Uuid networkId = port.getNetworkId();
 225         String segmentationId = DhcpServiceUtils.getSegmentationId(networkId, broker);
 226         if (segmentationId == null) {
 227             return;
 228         }
 229         List<BigInteger> listOfDpns = DhcpServiceUtils.getListOfDpns(broker);
 230         dhcpExternalTunnelManager.unInstallDhcpFlowsForVms(networkId.getValue(), listOfDpns, macAddress);
 231         dhcpExternalTunnelManager.removeVniMacToPortCache(new BigInteger(segmentationId), macAddress);
 232     }
 233
 234     private void addPort(Port port) {
 235         String macAddress = getMacAddress(port);
 236         Uuid networkId = port.getNetworkId();
 237         String segmentationId = DhcpServiceUtils.getSegmentationId(networkId, broker);
 238         if (segmentationId == null) {
 239             LOG.trace("segmentation id is null");
 240             return;
 241         }
 242         dhcpExternalTunnelManager.updateVniMacToPortCache(new BigInteger(segmentationId), macAddress, port);
 243
 244     }
 245
 246     private String getMacAddress(Port port) {
 247         return port.getMacAddress().getValue();
 248     }
 249
 250     private boolean isVnicTypeDirectOrMacVtap(Port port) {
 251         PortBindingExtension portBinding = port.augmentation(PortBindingExtension.class);
 252         if (portBinding == null || portBinding.getVnicType() == null) {
 253             // By default, VNIC_TYPE is NORMAL
 254             return false;
 255         }
 256         String vnicType = portBinding.getVnicType().trim().toLowerCase(Locale.getDefault());
 257         return vnicType.equals("direct") || vnicType.equals("macvtap");
 258     }
 259
 260     @Override
 261     protected DhcpNeutronPortListener getDataTreeChangeListener() {
 262         return DhcpNeutronPortListener.this;
 263     }
 264
 265     /**
 266      * Handle(Add/Remove) ARP Responder for DHCP IP on all the DPNs when DHCP is
 267      * enabled/disabled on subnet add or update or delete.
 268      *
 269      * @param port
 270      *            DHCP port for which ARP Responder flow to be added when dhcp
 271      *            flag is enabled on the subnet or DHCP port for which ARP
 272      *            Responder flow to be removed when dhcp flag is disabled on the
 273      *            Subnet
 274      * @param arpResponderAction
 275      *            ARP Responder Action to be performed i.e., add or remove flow
 276      */
 277     private void processArpResponderForElanDpns(Port port, Consumer<ArpResponderInput> arpResponderAction) {
 278
 279         java.util.Optional<String> ip4Address = DhcpServiceUtils.getIpV4Address(port);
 280         if (!ip4Address.isPresent()) {
 281             LOG.warn("There is no IPv4Address for port {}, not performing ARP responder add/remove flow operation",
 282                     port.getName());
 283             return;
 284         }
 285         ElanHelper.getDpnInterfacesInElanInstance(broker, port.getNetworkId().getValue()).stream()
 286                 .map(ifName -> DhcpServiceUtils.getInterfaceInfo(interfaceManager, ifName)).forEach(interfaceInfo -> {
 287                     ArpResponderInput arpResponderInput = new ArpResponderInput.ArpReponderInputBuilder()
 288                             .setDpId(interfaceInfo.getDpId()).setInterfaceName(interfaceInfo.getInterfaceName())
 289                             .setLportTag(interfaceInfo.getInterfaceTag()).setSha(port.getMacAddress().getValue())
 290                             .setSpa(ip4Address.get()).build();
 291                     arpResponderAction.accept(arpResponderInput);
 292                 });
 293
 294     }
 295
 296 }