dhcpservice/impl/src/main/java/org/opendaylight/netvirt/dhcpservice/DhcpServiceUtils.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
   9 package org.opendaylight.netvirt.dhcpservice;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import java.math.BigInteger;
  14 import java.net.InetAddress;
  15 import java.net.UnknownHostException;
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.Collections;
  19 import java.util.LinkedList;
  20 import java.util.List;
  21 import java.util.Objects;
  22 import java.util.function.BiConsumer;
  23 import java.util.function.Consumer;
  24 import java.util.stream.Collectors;
  25 import java.util.stream.IntStream;
  26 import java.util.stream.LongStream;
  27 import javax.annotation.Nonnull;
  28 import javax.annotation.Nullable;
  29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  30 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  31 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  32 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  33 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  34 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  35 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  36 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
  37 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  38 import org.opendaylight.genius.mdsalutil.ActionInfo;
  39 import org.opendaylight.genius.mdsalutil.FlowEntity;
  40 import org.opendaylight.genius.mdsalutil.InstructionInfo;
  41 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  42 import org.opendaylight.genius.mdsalutil.MatchInfo;
  43 import org.opendaylight.genius.mdsalutil.NWUtil;
  44 import org.opendaylight.genius.mdsalutil.NwConstants;
  45 import org.opendaylight.genius.mdsalutil.actions.ActionDrop;
  46 import org.opendaylight.genius.mdsalutil.actions.ActionPuntToController;
  47 import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
  48 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  49 import org.opendaylight.genius.mdsalutil.matches.MatchArpOp;
  50 import org.opendaylight.genius.mdsalutil.matches.MatchArpTpa;
  51 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetSource;
  52 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
  53 import org.opendaylight.genius.mdsalutil.matches.MatchIpProtocol;
  54 import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
  55 import org.opendaylight.genius.mdsalutil.matches.MatchUdpDestinationPort;
  56 import org.opendaylight.genius.mdsalutil.matches.MatchUdpSourcePort;
  57 import org.opendaylight.genius.utils.ServiceIndex;
  58 import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
  59 import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
  60 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceTypeFlowBased;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflow;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.StypeOpenflowBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesKey;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionBase;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionV4;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVxlan;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.InterfaceNameMacAddresses;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.SubnetDhcpPortData;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddress;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddressBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710._interface.name.mac.addresses.InterfaceNameMacAddressKey;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.subnet.dhcp.port.data.SubnetToDhcpPort;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.subnet.dhcp.port.data.SubnetToDhcpPortBuilder;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dhcpservice.api.rev150710.subnet.dhcp.port.data.SubnetToDhcpPortKey;
 107 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 108 import org.slf4j.Logger;
 109 import org.slf4j.LoggerFactory;
 110
 111 public final class DhcpServiceUtils {
 112
 113     private static final Logger LOG = LoggerFactory.getLogger(DhcpServiceUtils.class);
 114     private static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
 115         @Override
 116         public void onSuccess(Void result) {
 117             LOG.debug("Success in Datastore write operation");
 118         }
 119
 120         @Override
 121         public void onFailure(Throwable error) {
 122             LOG.error("Error in Datastore write operation", error);
 123         }
 124     };
 125
 126     private DhcpServiceUtils() { }
 127
 128     public static void setupDhcpFlowEntry(@Nullable BigInteger dpId, short tableId, @Nullable String vmMacAddress,
 129                                           int addOrRemove,
 130                                           IMdsalApiManager mdsalUtil, WriteTransaction tx) {
 131         if (dpId == null || dpId.equals(DhcpMConstants.INVALID_DPID) || vmMacAddress == null) {
 132             return;
 133         }
 134         List<MatchInfo> matches = getDhcpMatch(vmMacAddress);
 135         List<InstructionInfo> instructions = new ArrayList<>();
 136         List<ActionInfo> actionsInfos = new ArrayList<>();
 137
 138         // Punt to controller
 139         actionsInfos.add(new ActionPuntToController());
 140         instructions.add(new InstructionApplyActions(actionsInfos));
 141         if (addOrRemove == NwConstants.DEL_FLOW) {
 142             FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, tableId,
 143                     getDhcpFlowRef(dpId, tableId, vmMacAddress),
 144                     DhcpMConstants.DEFAULT_DHCP_FLOW_PRIORITY, "DHCP", 0, 0,
 145                     DhcpMConstants.COOKIE_DHCP_BASE, matches, null);
 146             LOG.trace("Removing DHCP Flow DpId {}, vmMacAddress {}", dpId, vmMacAddress);
 147             DhcpServiceCounters.remove_dhcp_flow.inc();
 148             mdsalUtil.removeFlowToTx(flowEntity, tx);
 149         } else {
 150             FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, tableId,
 151                     getDhcpFlowRef(dpId, tableId, vmMacAddress), DhcpMConstants.DEFAULT_DHCP_FLOW_PRIORITY,
 152                     "DHCP", 0, 0, DhcpMConstants.COOKIE_DHCP_BASE, matches, instructions);
 153             LOG.trace("Installing DHCP Flow DpId {}, vmMacAddress {}", dpId, vmMacAddress);
 154             DhcpServiceCounters.install_dhcp_flow.inc();
 155             mdsalUtil.addFlowToTx(flowEntity, tx);
 156         }
 157     }
 158
 159     private static String getDhcpFlowRef(BigInteger dpId, long tableId, String vmMacAddress) {
 160         return new StringBuffer().append(DhcpMConstants.FLOWID_PREFIX)
 161                 .append(dpId).append(NwConstants.FLOWID_SEPARATOR)
 162                 .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 163                 .append(vmMacAddress).toString();
 164     }
 165
 166     private static String getDhcpArpFlowRef(BigInteger dpId, long tableId, long lportTag, String ipAddress) {
 167         return new StringBuffer().append(DhcpMConstants.FLOWID_PREFIX)
 168                 .append(dpId).append(NwConstants.FLOWID_SEPARATOR)
 169                 .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 170                 .append(lportTag).append(NwConstants.FLOWID_SEPARATOR)
 171                 .append(ipAddress).toString();
 172     }
 173
 174     public static void setupDhcpDropAction(BigInteger dpId, short tableId, String vmMacAddress, int addOrRemove,
 175                                            IMdsalApiManager mdsalUtil, WriteTransaction tx) {
 176         if (dpId == null || dpId.equals(DhcpMConstants.INVALID_DPID) || vmMacAddress == null) {
 177             return;
 178         }
 179         List<MatchInfo> matches = getDhcpMatch(vmMacAddress);
 180
 181         List<ActionInfo> actionsInfos = new ArrayList<>();
 182         List<InstructionInfo> instructions = new ArrayList<>();
 183         instructions.add(new InstructionApplyActions(actionsInfos));
 184         // Drop Action
 185         actionsInfos.add(new ActionDrop());
 186         if (addOrRemove == NwConstants.DEL_FLOW) {
 187             FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, tableId,
 188                     getDhcpFlowRef(dpId, tableId, vmMacAddress),
 189                     DhcpMConstants.DEFAULT_DHCP_FLOW_PRIORITY, "DHCP", 0, 0,
 190                     DhcpMConstants.COOKIE_DHCP_BASE, matches, null);
 191             LOG.trace("Removing DHCP Drop Flow DpId {}, vmMacAddress {}", dpId, vmMacAddress);
 192             DhcpServiceCounters.remove_dhcp_drop_flow.inc();
 193             mdsalUtil.removeFlowToTx(flowEntity, tx);
 194         } else {
 195             FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, tableId,
 196                     getDhcpFlowRef(dpId, tableId, vmMacAddress), DhcpMConstants.DEFAULT_DHCP_FLOW_PRIORITY,
 197                     "DHCP", 0, 0, DhcpMConstants.COOKIE_DHCP_BASE, matches, instructions);
 198             LOG.trace("Installing DHCP Drop Flow DpId {}, vmMacAddress {}", dpId, vmMacAddress);
 199             DhcpServiceCounters.install_dhcp_drop_flow.inc();
 200             mdsalUtil.addFlowToTx(flowEntity, tx);
 201         }
 202     }
 203
 204     @SuppressWarnings("checkstyle:IllegalCatch")
 205     public static void setupDhcpArpRequest(BigInteger dpId, short tableId, BigInteger vni, String dhcpIpAddress,
 206                                            int lportTag, Long elanTag, boolean add, IMdsalApiManager mdsalUtil) {
 207         List<MatchInfo> matches = getDhcpArpMatch(vni, dhcpIpAddress);
 208         if (add) {
 209             Flow flow = MDSALUtil.buildFlowNew(tableId, getDhcpArpFlowRef(dpId, tableId, lportTag, dhcpIpAddress),
 210                     DhcpMConstants.DEFAULT_DHCP_ARP_FLOW_PRIORITY, "DHCPArp", 0, 0,
 211                     generateDhcpArpCookie(lportTag, dhcpIpAddress), matches, null);
 212             LOG.trace("Removing DHCP ARP Flow DpId {}, DHCP Port IpAddress {}", dpId, dhcpIpAddress);
 213             mdsalUtil.removeFlow(dpId, flow);
 214         } else {
 215             Flow flow = MDSALUtil.buildFlowNew(tableId, getDhcpArpFlowRef(dpId, tableId, lportTag, dhcpIpAddress),
 216                     DhcpMConstants.DEFAULT_DHCP_ARP_FLOW_PRIORITY, "DHCPArp", 0, 0,
 217                     generateDhcpArpCookie(lportTag, dhcpIpAddress), matches,
 218                     getDhcpArpInstructions(elanTag, lportTag));
 219             LOG.trace("Adding DHCP ARP Flow DpId {}, DHCPPort IpAddress {}", dpId, dhcpIpAddress);
 220             mdsalUtil.installFlow(dpId, flow);
 221         }
 222     }
 223
 224     public static List<MatchInfo> getDhcpMatch() {
 225         List<MatchInfo> matches = new ArrayList<>();
 226         matches.add(MatchEthernetType.IPV4);
 227         matches.add(MatchIpProtocol.UDP);
 228         matches.add(new MatchUdpSourcePort(DhcpMConstants.DHCP_CLIENT_PORT));
 229         matches.add(new MatchUdpDestinationPort(DhcpMConstants.DHCP_SERVER_PORT));
 230         return matches;
 231     }
 232
 233     public static List<MatchInfo> getDhcpMatch(String vmMacAddress) {
 234         List<MatchInfo> matches = getDhcpMatch();
 235         matches.add(new MatchEthernetSource(new MacAddress(vmMacAddress)));
 236         return matches;
 237     }
 238
 239     private static List<MatchInfo> getDhcpArpMatch(BigInteger vni, String ipAddress) {
 240         return Arrays.asList(MatchEthernetType.ARP, MatchArpOp.REQUEST, new MatchTunnelId(vni),
 241                 new MatchArpTpa(ipAddress, "32"));
 242     }
 243
 244     private static List<Instruction> getDhcpArpInstructions(Long elanTag, int lportTag) {
 245         List<Instruction> mkInstructions = new ArrayList<>();
 246         int instructionKey = 0;
 247         mkInstructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(
 248                 ElanHelper.getElanMetadataLabel(elanTag, lportTag), ElanHelper.getElanMetadataMask(),
 249                 ++instructionKey));
 250         mkInstructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.ARP_RESPONDER_TABLE,
 251                 ++instructionKey));
 252         return mkInstructions;
 253     }
 254
 255     private static BigInteger generateDhcpArpCookie(int lportTag, String ipAddress) {
 256         try {
 257             BigInteger cookie = NwConstants.TUNNEL_TABLE_COOKIE.add(BigInteger.valueOf(255))
 258                     .add(BigInteger.valueOf(NWUtil.convertInetAddressToLong(InetAddress.getByName(ipAddress))));
 259             return cookie.add(BigInteger.valueOf(lportTag));
 260         } catch (UnknownHostException e) {
 261             return NwConstants.TUNNEL_TABLE_COOKIE.add(BigInteger.valueOf(lportTag));
 262         }
 263     }
 264
 265     public static List<BigInteger> getListOfDpns(DataBroker broker) {
 266         return extractDpnsFromNodes(MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
 267                 InstanceIdentifier.builder(Nodes.class).build()));
 268     }
 269
 270     @Nonnull
 271     public static List<BigInteger> getListOfDpns(ReadTransaction tx) throws ReadFailedException {
 272         return extractDpnsFromNodes(tx.read(LogicalDatastoreType.OPERATIONAL,
 273                 InstanceIdentifier.builder(Nodes.class).build()).checkedGet());
 274     }
 275
 276     @Nonnull
 277     private static List<BigInteger> extractDpnsFromNodes(Optional<Nodes> optionalNodes) {
 278         return optionalNodes.toJavaUtil().map(
 279             nodes -> nodes.getNode().stream().map(Node::getId).filter(Objects::nonNull).map(
 280                     MDSALUtil::getDpnIdFromNodeName).collect(
 281                     Collectors.toList())).orElse(Collections.emptyList());
 282     }
 283
 284     @Nonnull
 285     public static List<BigInteger> getDpnsForElan(String elanInstanceName, DataBroker broker) {
 286         List<BigInteger> elanDpns = new LinkedList<>();
 287         InstanceIdentifier<ElanDpnInterfacesList> elanDpnInstanceIdentifier =
 288                 InstanceIdentifier.builder(ElanDpnInterfaces.class)
 289                         .child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName)).build();
 290         Optional<ElanDpnInterfacesList> elanDpnOptional =
 291                 MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInstanceIdentifier);
 292         if (elanDpnOptional.isPresent()) {
 293             List<DpnInterfaces> dpns = elanDpnOptional.get().getDpnInterfaces();
 294             for (DpnInterfaces dpnInterfaces : dpns) {
 295                 elanDpns.add(dpnInterfaces.getDpId());
 296             }
 297         }
 298         return elanDpns;
 299     }
 300
 301     public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 302             .state.Interface getInterfaceFromOperationalDS(String interfaceName, DataBroker dataBroker) {
 303         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 304                 .state.InterfaceKey interfaceKey =
 305                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 306                         .state.InterfaceKey(interfaceName);
 307         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 308                 .interfaces.state.Interface> interfaceId = InstanceIdentifier.builder(InterfacesState.class)
 309                 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 310                         .interfaces.state.Interface.class, interfaceKey).build();
 311         return MDSALUtil.read(LogicalDatastoreType.OPERATIONAL, interfaceId, dataBroker).orNull();
 312     }
 313
 314
 315     public static String getSegmentationId(Uuid networkId, DataBroker broker) {
 316         InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class)
 317                 .child(Networks.class).child(Network.class, new NetworkKey(networkId));
 318         Optional<Network> optionalNetwork = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
 319         if (!optionalNetwork.isPresent()) {
 320             return null;
 321         }
 322         Network network = optionalNetwork.get();
 323         String segmentationId = NeutronUtils.getSegmentationIdFromNeutronNetwork(network, NetworkTypeVxlan.class);
 324         return segmentationId;
 325     }
 326
 327     public static String getNodeIdFromDpnId(BigInteger dpnId) {
 328         return MDSALUtil.NODE_PREFIX + MDSALUtil.SEPARATOR + dpnId.toString();
 329     }
 330
 331     public static String getTrunkPortMacAddress(String parentRefName,
 332             DataBroker broker) {
 333         InstanceIdentifier<Port> portInstanceIdentifier =
 334                 InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
 335         Optional<Port> trunkPort = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, portInstanceIdentifier);
 336         if (!trunkPort.isPresent()) {
 337             LOG.warn("Trunk port {} not available for sub-port", parentRefName);
 338             return null;
 339         }
 340         return trunkPort.get().getMacAddress().getValue();
 341     }
 342
 343     public static String getJobKey(String interfaceName) {
 344         return new StringBuilder().append(DhcpMConstants.DHCP_JOB_KEY_PREFIX).append(interfaceName).toString();
 345     }
 346
 347     public static void bindDhcpService(String interfaceName, short tableId, WriteTransaction tx) {
 348         int instructionKey = 0;
 349         List<Instruction> instructions = new ArrayList<>();
 350         instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(tableId, ++instructionKey));
 351         short serviceIndex = ServiceIndex.getIndex(NwConstants.DHCP_SERVICE_NAME, NwConstants.DHCP_SERVICE_INDEX);
 352         BoundServices
 353                 serviceInfo =
 354                 getBoundServices(String.format("%s.%s", "dhcp", interfaceName),
 355                         serviceIndex, DhcpMConstants.DEFAULT_FLOW_PRIORITY,
 356                         DhcpMConstants.COOKIE_VM_INGRESS_TABLE, instructions);
 357         tx.put(LogicalDatastoreType.CONFIGURATION,
 358                 buildServiceId(interfaceName, serviceIndex), serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
 359     }
 360
 361     public static void unbindDhcpService(String interfaceName, WriteTransaction tx) {
 362         short serviceIndex = ServiceIndex.getIndex(NwConstants.DHCP_SERVICE_NAME, NwConstants.DHCP_SERVICE_INDEX);
 363         tx.delete(LogicalDatastoreType.CONFIGURATION,
 364                 buildServiceId(interfaceName, serviceIndex));
 365     }
 366
 367     private static InstanceIdentifier<BoundServices> buildServiceId(String interfaceName,
 368                                                              short dhcpServicePriority) {
 369         return InstanceIdentifier.builder(ServiceBindings.class)
 370                 .child(ServicesInfo.class, new ServicesInfoKey(interfaceName, ServiceModeIngress.class))
 371                 .child(BoundServices.class, new BoundServicesKey(dhcpServicePriority)).build();
 372     }
 373
 374     public static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
 375                                           BigInteger cookie, List<Instruction> instructions) {
 376         StypeOpenflowBuilder augBuilder = new StypeOpenflowBuilder().setFlowCookie(cookie)
 377                 .setFlowPriority(flowPriority).setInstruction(instructions);
 378         return new BoundServicesBuilder().setKey(new BoundServicesKey(servicePriority))
 379                 .setServiceName(serviceName).setServicePriority(servicePriority)
 380                 .setServiceType(ServiceTypeFlowBased.class)
 381                 .addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
 382     }
 383
 384     @SuppressWarnings("checkstyle:IllegalCatch")
 385     protected static void createSubnetDhcpPortData(Port port,
 386             BiConsumer<InstanceIdentifier<SubnetToDhcpPort>, SubnetToDhcpPort> consumer) {
 387         java.util.Optional<String> ip4Address = getIpV4Address(port);
 388         java.util.Optional<String> subnetId = getNeutronSubnetId(port);
 389         if (!(ip4Address.isPresent() && subnetId.isPresent())) {
 390             return;
 391         }
 392         LOG.trace("Adding SubnetPortData entry for subnet {}", subnetId.get());
 393         InstanceIdentifier<SubnetToDhcpPort> identifier = buildSubnetToDhcpPort(subnetId.get());
 394         SubnetToDhcpPort subnetToDhcpPort = getSubnetToDhcpPort(port, subnetId.get(), ip4Address.get());
 395         try {
 396             LOG.trace("Adding to SubnetToDhcpPort subnet {}  mac {}.", subnetId.get(),
 397                     port.getMacAddress().getValue());
 398             consumer.accept(identifier, subnetToDhcpPort);
 399         } catch (Exception e) {
 400             LOG.error("Failure while creating SubnetToDhcpPort map for network {}.", port.getNetworkId(), e);
 401         }
 402     }
 403
 404     @SuppressWarnings("checkstyle:IllegalCatch")
 405     protected static void removeSubnetDhcpPortData(Port port, Consumer<InstanceIdentifier<SubnetToDhcpPort>> consumer) {
 406         String subnetId = port.getDeviceId().substring("OpenDaylight".length() + 1);
 407         LOG.trace("Removing NetworkPortData entry for Subnet {}", subnetId);
 408         InstanceIdentifier<SubnetToDhcpPort> identifier = buildSubnetToDhcpPort(subnetId);
 409         try {
 410             consumer.accept(identifier);
 411             LOG.trace("Deleted SubnetDhcpPort for Subnet {}", subnetId);
 412         } catch (Exception e) {
 413             LOG.error("Failure while removing SubnetToDhcpPort for subnet {}.", subnetId, e);
 414         }
 415
 416     }
 417
 418     static InstanceIdentifier<SubnetToDhcpPort> buildSubnetToDhcpPort(String subnetId) {
 419         return InstanceIdentifier.builder(SubnetDhcpPortData.class)
 420                 .child(SubnetToDhcpPort.class, new SubnetToDhcpPortKey(subnetId)).build();
 421     }
 422
 423     public static java.util.Optional<SubnetToDhcpPort> getSubnetDhcpPortData(DataBroker broker, String subnetId) {
 424         InstanceIdentifier<SubnetToDhcpPort> id = buildSubnetToDhcpPort(subnetId);
 425         try {
 426             return java.util.Optional
 427                     .ofNullable(SingleTransactionDataBroker.syncRead(broker, LogicalDatastoreType.CONFIGURATION, id));
 428         } catch (ReadFailedException e) {
 429             LOG.warn("Failed to read SubnetToDhcpPort for DS due to error {}", e.getMessage());
 430         }
 431         return java.util.Optional.empty();
 432     }
 433
 434     static IpAddress convertIntToIp(int ipn) {
 435         String[] array = IntStream.of(24, 16, 8, 0) //
 436                 .map(x -> ipn >> x & 0xFF).boxed() //
 437                 .map(String::valueOf) //
 438                 .toArray(String[]::new);
 439         return new IpAddress(String.join(".", array).toCharArray());
 440     }
 441
 442     static IpAddress convertLongToIp(long ip) {
 443         String[] array = LongStream.of(24, 16, 8, 0) //
 444                 .map(x -> ip >> x & 0xFF).boxed() //
 445                 .map(String::valueOf) //
 446                 .toArray(String[]::new);
 447         return new IpAddress(String.join(".", array).toCharArray());
 448     }
 449
 450     static long convertIpToLong(IpAddress ipa) {
 451         String[] splitIp = String.valueOf(ipa.getValue()).split("\\.");
 452         long result = 0;
 453         for (String part : splitIp) {
 454             result <<= 8;
 455             result |= Integer.parseInt(part);
 456         }
 457         return result;
 458     }
 459
 460
 461     static SubnetToDhcpPort getSubnetToDhcpPort(Port port, String subnetId, String ipAddress) {
 462         return new SubnetToDhcpPortBuilder()
 463                 .setKey(new SubnetToDhcpPortKey(subnetId))
 464                 .setSubnetId(subnetId).setPortName(port.getUuid().getValue())
 465                 .setPortMacaddress(port.getMacAddress().getValue()).setPortFixedip(ipAddress).build();
 466     }
 467
 468     static InterfaceInfo getInterfaceInfo(IInterfaceManager interfaceManager, String interfaceName) {
 469         return interfaceManager.getInterfaceInfoFromOperationalDataStore(interfaceName);
 470     }
 471
 472     static BigInteger getDpIdFromInterface(IInterfaceManager interfaceManager, String interfaceName) {
 473         return interfaceManager.getDpnForInterface(interfaceName);
 474     }
 475
 476     public static java.util.Optional<String> getIpV4Address(Port port) {
 477         if (port.getFixedIps() == null) {
 478             return java.util.Optional.empty();
 479         }
 480         return port.getFixedIps().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
 481                 .map(v -> v.getIpAddress().getIpv4Address().getValue()).findFirst();
 482     }
 483
 484     public static java.util.Optional<String> getNeutronSubnetId(Port port) {
 485         if (port.getFixedIps() == null) {
 486             return java.util.Optional.empty();
 487         }
 488         return port.getFixedIps().stream().filter(DhcpServiceUtils::isIpV4AddressAvailable)
 489                 .map(v -> v.getSubnetId().getValue()).findFirst();
 490     }
 491
 492     public static boolean isIpV4AddressAvailable(FixedIps fixedIp) {
 493         return fixedIp != null && fixedIp.getIpAddress() != null && fixedIp.getIpAddress().getIpv4Address() != null;
 494     }
 495
 496     @Nullable
 497     public static String getAndUpdateVmMacAddress(ReadWriteTransaction tx, String interfaceName,
 498             DhcpManager dhcpManager) throws ReadFailedException {
 499         InstanceIdentifier<InterfaceNameMacAddress> instanceIdentifier =
 500                 InstanceIdentifier.builder(InterfaceNameMacAddresses.class)
 501                         .child(InterfaceNameMacAddress.class, new InterfaceNameMacAddressKey(interfaceName)).build();
 502         Optional<InterfaceNameMacAddress> existingEntry =
 503                 tx.read(LogicalDatastoreType.OPERATIONAL, instanceIdentifier).checkedGet();
 504         if (!existingEntry.isPresent()) {
 505             LOG.trace("Entry for interface {} missing in InterfaceNameVmMacAddress map", interfaceName);
 506             String vmMacAddress = getNeutronMacAddress(interfaceName, dhcpManager);
 507             if (vmMacAddress == null || vmMacAddress.isEmpty()) {
 508                 return null;
 509             }
 510             LOG.trace("Updating InterfaceNameVmMacAddress map with {}, {}", interfaceName,vmMacAddress);
 511             InterfaceNameMacAddress interfaceNameMacAddress =
 512                     new InterfaceNameMacAddressBuilder()
 513                             .setKey(new InterfaceNameMacAddressKey(interfaceName))
 514                             .setInterfaceName(interfaceName).setMacAddress(vmMacAddress).build();
 515             tx.merge(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, interfaceNameMacAddress,
 516                     WriteTransaction.CREATE_MISSING_PARENTS);
 517             return vmMacAddress;
 518         }
 519         return existingEntry.get().getMacAddress();
 520     }
 521
 522     private static String getNeutronMacAddress(String interfaceName, DhcpManager dhcpManager) {
 523         Port port = dhcpManager.getNeutronPort(interfaceName);
 524         if (port != null) {
 525             LOG.trace("Port found in neutron. Interface Name {}, port {}", interfaceName, port);
 526             return port.getMacAddress().getValue();
 527         }
 528         return null;
 529     }
 530
 531     public static List<Uuid> getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) {
 532         InstanceIdentifier id = buildNetworkMapIdentifier(networkId);
 533         Optional<NetworkMap> optionalNetworkMap = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 534         if (optionalNetworkMap.isPresent()) {
 535             return optionalNetworkMap.get().getSubnetIdList();
 536         }
 537         return null;
 538     }
 539
 540     static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
 541         InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
 542                 NetworkMapKey(networkId)).build();
 543         return id;
 544     }
 545
 546     public static boolean isIpv4Subnet(DataBroker broker, Uuid subnetUuid) {
 547         final SubnetKey subnetkey = new SubnetKey(subnetUuid);
 548         final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
 549                 .child(Subnets.class).child(Subnet.class, subnetkey);
 550         final Optional<Subnet> subnet = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
 551         if (subnet.isPresent()) {
 552             Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
 553             if (ipVersionBase.equals(IpVersionV4.class)) {
 554                 return true;
 555             }
 556         }
 557         return false;
 558     }
 559
 560 }
 561