renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems. 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.groupbasedpolicy.renderer.vpp.lisp.loopback;
  10
  11 import com.google.common.base.Preconditions;
  12 import org.apache.commons.lang3.tuple.Pair;
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.LoopbackCommand;
  15 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.LoopbackCommandWrapper;
  16 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ProxyRangeCommand;
  17 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.AbstractLispCommand;
  18 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandWrapper;
  19 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateCommandExecutor;
  20 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException;
  21 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispHelperArgumentException;
  22 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.LoopbackHostSpecificInfoMapper;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.SubnetUuidToGbpSubnetMapper;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.IpAddressUtil;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpSubnet;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntry;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.RemoteEid;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unnumbered.interfaces.rev170510.InterfaceUnnumberedAugmentation;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unnumbered.interfaces.rev170510.InterfaceUnnumberedAugmentationBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unnumbered.interfaces.rev170510.unnumbered.config.attributes.UnnumberedBuilder;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 import javax.annotation.Nonnull;
  50 import java.util.List;
  51
  52 /**
  53  * Created by Shakib Ahmed on 4/26/17.
  54  */
  55 public class LoopbackManager {
  56     private static final Logger LOG = LoggerFactory.getLogger(LoopbackManager.class);
  57
  58     private ConfigManagerHelper loopbackManagerHelper;
  59
  60     private LoopbackHostSpecificInfoMapper subnetHostSpecificInfo;
  61     private NeutronTenantToVniMapper neutronTenantToVniMapper;
  62     private SubnetUuidToGbpSubnetMapper subnetUuidToGbpSubnetMapper;
  63
  64     private static final String LOOP_NAME_PREFIX = "loop-";
  65     private static final String GPE_ENTRY_PREFIX = "gpe-entry-";
  66
  67     public LoopbackManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
  68         this.loopbackManagerHelper = new ConfigManagerHelper(mountedDataBrokerProvider);
  69         this.subnetHostSpecificInfo = new LoopbackHostSpecificInfoMapper();
  70         this.neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
  71         this.subnetUuidToGbpSubnetMapper = SubnetUuidToGbpSubnetMapper.getInstance();
  72     }
  73
  74     public void createBviLoopbackIfNeeded(AddressEndpointWithLocation addressEp,
  75                                           String bridgeDomainName) {
  76         try {
  77             DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get();
  78             String hostName = loopbackManagerHelper.getHostName(addressEp).get();
  79             String subnetUuid = loopbackManagerHelper.getSubnet(addressEp);
  80
  81             if (subnetHostSpecificInfo.loopbackAlreadyExists(hostName, subnetUuid)) {
  82                 subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid);
  83                 return;
  84             }
  85
  86             GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(getSubnetInfo(subnetUuid),
  87                     "Subnet UUID {} hasn't been created yet!", subnetUuid);
  88
  89             String interfaceName = LOOP_NAME_PREFIX + subnetHostSpecificInfo.getLoopbackCount(hostName);
  90             long vni = getVni(addressEp.getTenant().getValue());
  91
  92             LoopbackCommand bviLoopbackCommand = LoopbackCommandWrapper
  93                     .bviLoopbackPutCommand(interfaceName, vni, gbpSubnetInfo.getGatewayIp(), gbpSubnetInfo.getCidr(),
  94                             bridgeDomainName);
  95             createLoopbackInterface(hostName, subnetUuid, vppDataBroker, bviLoopbackCommand);
  96         } catch (LispConfigCommandFailedException e) {
  97             LOG.warn("LISP couldn't be configured: {}", e.getMessage());
  98         }
  99     }
 100
 101     public void createSimpleLoopbackIfNeeded(AddressEndpointWithLocation addressEp) {
 102         try {
 103             DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get();
 104             String hostName = loopbackManagerHelper.getHostName(addressEp).get();
 105             String subnetUuid = loopbackManagerHelper.getSubnet(addressEp);
 106
 107             if (subnetHostSpecificInfo.loopbackAlreadyExists(hostName, subnetUuid)) {
 108                 subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid);
 109                 String loopbackInterfaceName = subnetHostSpecificInfo
 110                         .getInterfaceNameForLoopbackInHost(hostName, subnetUuid);
 111                 addUnnumberedInterface(addressEp, loopbackInterfaceName);
 112                 return;
 113             }
 114
 115             String interfaceName = LOOP_NAME_PREFIX + subnetHostSpecificInfo.getLoopbackCount(hostName);
 116             long vni = getVni(addressEp.getTenant().getValue());
 117             long vrf = vni;
 118
 119             GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(getSubnetInfo(subnetUuid),
 120                     "Subnet UUID {} hasn't been created yet!", subnetUuid);
 121
 122             LoopbackCommand simpleLoopbackCommand = LoopbackCommandWrapper
 123                     .simpleLoopbackPutCommand(interfaceName, vrf, gbpSubnetInfo.getGatewayIp(),
 124                             gbpSubnetInfo.getCidr());
 125
 126             createLoopbackInterface(hostName, subnetUuid, vppDataBroker, simpleLoopbackCommand);
 127             addProxyArpRange(vppDataBroker, vrf, gbpSubnetInfo, hostName);
 128             addGpeEntry(vppDataBroker, gbpSubnetInfo, vni);
 129             addUnnumberedInterface(addressEp, interfaceName);
 130         } catch (LispConfigCommandFailedException e) {
 131             LOG.warn("LISP couldn't be configured: {}", e.getMessage());
 132         }
 133     }
 134
 135     private void createLoopbackInterface(String hostName, String subnetUuid, DataBroker vppDataBroker,
 136                                         LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException {
 137
 138         if (GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker,
 139                                                      loopbackCommand,
 140                                                      GbpNetconfTransaction.RETRY_COUNT)) {
 141             subnetHostSpecificInfo.addLoopbackForHost(hostName, subnetUuid, loopbackCommand.getName(),
 142                     loopbackCommand.getVrfId());
 143             subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid);
 144         } else {
 145             throw new LispConfigCommandFailedException("BVI could not be created for "
 146                     + hostName + " and bridge domain " + loopbackCommand.getBridgeDomain());
 147         }
 148     }
 149
 150     public void deleteLoopbackIfExists(String subnetUuid) {
 151
 152         List<String> hostsWithSubnet = subnetHostSpecificInfo.getHostsWithSubnet(subnetUuid);
 153
 154         hostsWithSubnet.forEach(host -> {
 155             DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(host).get();
 156             String interfaceName = subnetHostSpecificInfo.getInterfaceNameForLoopbackInHost(host, subnetUuid);
 157
 158             try {
 159                 deleteSpecificLoopback(vppDataBroker, interfaceName);
 160             } catch (LispConfigCommandFailedException e) {
 161                 e.printStackTrace();
 162             }
 163         });
 164
 165         subnetHostSpecificInfo.clearSubnet(subnetUuid);
 166     }
 167
 168     public void handleEndpointDelete(AddressEndpointWithLocation addressEp) {
 169         DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get();
 170         String hostId = loopbackManagerHelper.getHostName(addressEp).get();
 171         String portSubnetUuid = loopbackManagerHelper.getSubnet(addressEp);
 172         String interfaceName = subnetHostSpecificInfo.getInterfaceNameForLoopbackInHost(hostId, portSubnetUuid);
 173         if (subnetHostSpecificInfo.deletePortFromHostSubnetAndTriggerLoopbackDelete(hostId, portSubnetUuid)) {
 174             GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(subnetUuidToGbpSubnetMapper.getSubnetInfo(portSubnetUuid),
 175                     "Invalid port!");
 176             long vni = getVni(addressEp.getTenant().getValue());
 177             try {
 178                 deleteSpecificLoopback(vppDataBroker, interfaceName);
 179                 deleteProxyArpRange(vppDataBroker, vni, gbpSubnetInfo, hostId);
 180                 deleteGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1");
 181                 deleteGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2");
 182             } catch (LispConfigCommandFailedException e) {
 183                 LOG.warn("Loopback not deleted properly: {}", e.getMessage());
 184             }
 185         }
 186     }
 187
 188     private void deleteSpecificLoopback(DataBroker vppDataBroker, String interfaceName) throws LispConfigCommandFailedException {
 189         if (!GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker,
 190                 VppIidFactory.getInterfaceIID(new InterfaceKey(interfaceName)), GbpNetconfTransaction.RETRY_COUNT)) {
 191             throw new LispConfigCommandFailedException("Failed to delete Loopback interface!");
 192         } else {
 193             LOG.debug("Deleted loopback interface!");
 194         }
 195     }
 196
 197     private void addProxyArpRange(DataBroker vppDataBroker,
 198                                   long vrf,
 199                                   GbpSubnet gbpSubnetInfo,
 200                                   String hostName) throws LispConfigCommandFailedException {
 201         Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix();
 202
 203         Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for "
 204         + "subnet uuid =" +  gbpSubnetInfo.getId() + "!");
 205
 206         Pair<Ipv4Address, Ipv4Address> startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix);
 207
 208         if (!putArpRangesCommand(vppDataBroker,
 209                                  vrf,
 210                                  startAndEndAddress.getLeft(),
 211                                  startAndEndAddress.getRight())) {
 212             throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " +
 213             gbpSubnetInfo.getId() + "!");
 214         } else {
 215             LOG.debug("Configured proxy arp for range {} to {} on node : {}!", startAndEndAddress.getLeft(),
 216                     startAndEndAddress.getRight(), hostName);
 217         }
 218     }
 219
 220     private void deleteProxyArpRange(DataBroker vppDataBroker,
 221                                 long vrf,
 222                                 GbpSubnet gbpSubnetInfo,
 223                                 String hostName) throws LispConfigCommandFailedException {
 224         Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix();
 225
 226         Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for "
 227                 + "subnet uuid =" +  gbpSubnetInfo.getId() + "!");
 228
 229         Pair<Ipv4Address, Ipv4Address> startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix);
 230
 231         if (!deleteArpRangesCommand(vppDataBroker,
 232                                     vrf,
 233                                     startAndEndAddress.getLeft(),
 234                                     startAndEndAddress.getRight())) {
 235             throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " +
 236                     gbpSubnetInfo.getId() + "!");
 237         } else {
 238             LOG.debug("Removed proxy arp for range {} to {} on node : {}!", startAndEndAddress.getLeft(),
 239                     startAndEndAddress.getRight(), hostName);
 240         }
 241     }
 242
 243     private boolean putArpRangesCommand(DataBroker vppDataBroker, long vrf, Ipv4Address start, Ipv4Address end) {
 244         ProxyRangeCommand.ProxyRangeCommandBuilder builder = new ProxyRangeCommand.ProxyRangeCommandBuilder();
 245         builder.setOperation(General.Operations.PUT);
 246         builder.setVrf(vrf);
 247         builder.setStartAddress(start);
 248         builder.setEndAddress(end);
 249
 250         return GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker,
 251                                                         builder.build(),
 252                                                         GbpNetconfTransaction.RETRY_COUNT);
 253     }
 254
 255     private boolean deleteArpRangesCommand(DataBroker vppDataBroker,
 256                                            long vrf,
 257                                            Ipv4Address start,
 258                                            Ipv4Address end) {
 259         ProxyRangeCommand.ProxyRangeCommandBuilder builder = new ProxyRangeCommand.ProxyRangeCommandBuilder();
 260         builder.setOperation(General.Operations.DELETE);
 261         builder.setVrf(vrf);
 262         builder.setStartAddress(start);
 263         builder.setEndAddress(end);
 264
 265         return GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker,
 266                                                          builder.build(),
 267                                                          GbpNetconfTransaction.RETRY_COUNT);
 268     }
 269
 270     private void addUnnumberedInterface(AddressEndpointWithLocation addressEp, String loopbackName) throws LispConfigCommandFailedException {
 271         DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get();
 272         String neutronInterfaceName = loopbackManagerHelper.getInterfaceName(addressEp).get();
 273
 274         if (putUnnumberedInterface(vppDataBroker, neutronInterfaceName, loopbackName)) {
 275             LOG.debug("Added Interface {} as unnumberd for {}", loopbackName, neutronInterfaceName);
 276         } else {
 277             throw new LispConfigCommandFailedException("Unnumbered configuration failed for " +
 278                     neutronInterfaceName + " - " + loopbackName);
 279         }
 280     }
 281
 282     private boolean putUnnumberedInterface(DataBroker vppDataBroker, String interfaceFor, String interfaceWith) {
 283         UnnumberedBuilder unnumberedBuilder = new UnnumberedBuilder();
 284         unnumberedBuilder.setUse(interfaceWith);
 285         InstanceIdentifier<Interface> interfaceIid = VppIidFactory.getInterfaceIID(new InterfaceKey(interfaceFor));
 286         InterfaceUnnumberedAugmentationBuilder augBuilder = new InterfaceUnnumberedAugmentationBuilder();
 287         augBuilder.setUnnumbered(unnumberedBuilder.build());
 288         InterfaceBuilder interfaceBuilder = new InterfaceBuilder().setKey(new InterfaceKey(interfaceFor));
 289         interfaceBuilder.addAugmentation(InterfaceUnnumberedAugmentation.class, augBuilder.build());
 290         return GbpNetconfTransaction.netconfSyncedMerge(vppDataBroker,
 291                 interfaceIid,
 292                 interfaceBuilder.build(),
 293                 GbpNetconfTransaction.RETRY_COUNT);
 294     }
 295
 296     private void addGpeEntry(DataBroker vppDataBroker, GbpSubnet gbpSubnetInfo, long vni) {
 297         try {
 298             Pair<Ipv4Prefix, Ipv4Prefix> delegatingSubnets = IpAddressUtil
 299                     .getSmallerSubnet(gbpSubnetInfo.getCidr().getIpv4Prefix());
 300
 301             RemoteEid firstREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getLeft()),
 302                                                        vni,
 303                                                        Ipv4PrefixAfi.class);
 304             putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1", firstREid, vni, vni);
 305
 306             if (delegatingSubnets.getLeft().equals(delegatingSubnets.getRight())) {
 307                 return;
 308             }
 309
 310             RemoteEid secondREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getRight()),
 311                                                         vni,
 312                                                         Ipv4PrefixAfi.class);
 313
 314             putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni);
 315         } catch (LispHelperArgumentException e) {
 316             e.printStackTrace();
 317         }
 318     }
 319
 320     private boolean putGpeEntry(DataBroker vppDataBroker, String id, RemoteEid rEid, long vni, long vrf) {
 321         AbstractLispCommand<GpeEntry> gpeEntryCommand = LispCommandWrapper
 322                 .addGpeSendMapregisterAction(id, rEid, vni, vrf);
 323         return LispStateCommandExecutor.executePutCommand(vppDataBroker, gpeEntryCommand);
 324     }
 325
 326     private boolean deleteGpeEntry(DataBroker vppDataBroker, String id) {
 327         AbstractLispCommand<GpeEntry> gpeEntryDeletionCommand = LispCommandWrapper
 328                 .deleteGpeEntry(id);
 329         return LispStateCommandExecutor.executeDeleteCommand(vppDataBroker, gpeEntryDeletionCommand);
 330     }
 331
 332     private long getVni(String tenantUuid) {
 333         return neutronTenantToVniMapper.getVni(tenantUuid);
 334     }
 335
 336     private GbpSubnet getSubnetInfo(String subnetUuid) {
 337         return subnetUuidToGbpSubnetMapper.getSubnetInfo(subnetUuid);
 338     }
 339 }