renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.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.flat.overlay;
  10
  11
  12 import javax.annotation.Nonnull;
  13
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.StaticArpCommand;
  17 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.EndpointHost;
  18 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer;
  19 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces;
  20 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortInterfaces;
  21 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortRouteState;
  22 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.SubnetState;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfHolder;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfState;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.IpAddressUtil;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
  32 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
  33 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  34 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Routing;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.RoutingBuilder;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import com.google.common.base.Optional;
  51 import com.google.common.base.Preconditions;
  52
  53 /**
  54  * Created by Shakib Ahmed on 5/2/17.
  55  */
  56 public class FlatOverlayManager {
  57     private static final Logger LOG = LoggerFactory.getLogger(FlatOverlayManager.class);
  58
  59     private ConfigManagerHelper overlayHelper;
  60     private DataBroker dataBroker;
  61
  62     private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
  63     private HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance();
  64
  65     private StaticRoutingHelper staticRoutingHelper;
  66
  67     public FlatOverlayManager(@Nonnull DataBroker dataBroker,
  68                               @Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
  69         this.overlayHelper = new ConfigManagerHelper(mountedDataBrokerProvider);
  70         staticRoutingHelper = new StaticRoutingHelper();
  71         this.dataBroker = dataBroker;
  72     }
  73
  74     public void configureEndpointForFlatOverlay(AddressEndpointWithLocation addressEp) {
  75         if (!overlayHelper.hasRelativeLocations(addressEp)) {
  76             configureInterfaceForFlatOverlay(addressEp);
  77             addStaticArp(addressEp);
  78             addStaticRoute(addressEp);
  79         } else {
  80             Ipv4Address metadataIp = overlayHelper.getInterfaceIp(addressEp);
  81             Ipv4Prefix metadataIpPrefix = overlayHelper.getInterfaceIpAsPrefix(addressEp);
  82             addressEp.getRelativeLocations().getExternalLocation().forEach(externalLocation -> {
  83                 String hostName = overlayHelper.getHostName(externalLocation).get();
  84                 String metadataInterfaceName = overlayHelper.getInterfaceName(externalLocation).get();
  85
  86                 long vrf = getVni(addressEp.getTenant().getValue());
  87
  88                 String metadataSubnetUuid = Constants.METADATA_SUBNET_UUID;
  89
  90                 PortInterfaces portInterfacesOfHost = hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName);
  91
  92                 if (!portInterfacesOfHost.isInterfaceConfiguredForMetadata(metadataInterfaceName)) {
  93                     addInterfaceInVrf(hostName, metadataInterfaceName, vrf);
  94                     String physicalAddress = resolvePhysicalAddress(hostName, metadataInterfaceName);
  95                     addStaticArp(hostName, metadataInterfaceName, physicalAddress, metadataIp);
  96                     addStaticRoute(hostName, vrf, metadataSubnetUuid, metadataIp, metadataIpPrefix,
  97                             metadataInterfaceName);
  98                     portInterfacesOfHost.addInterfaceInMetadataInterfaceSet(metadataInterfaceName);
  99                 }
 100             });
 101         }
 102     }
 103
 104     private String resolvePhysicalAddress(String hostName, String metadataInterfaceName) {
 105         String physAddress = null;
 106         Optional<Config> configOptional =
 107             DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getVppRendererConfig(),
 108                 dataBroker.newReadOnlyTransaction());
 109         if (configOptional.isPresent() && configOptional.get().getVppEndpoint() != null) {
 110             java.util.Optional<VppEndpoint> vppEndpointOptional = configOptional.get().getVppEndpoint().stream()
 111                     .filter(vppEndpoint -> vppEndpoint.getVppNodeId().getValue().equals(hostName))
 112                     .filter(vppEndpoint -> vppEndpoint.getVppInterfaceName().equals(metadataInterfaceName))
 113                     .findFirst();
 114             if (vppEndpointOptional.isPresent() && vppEndpointOptional.get()
 115                 .getInterfaceTypeChoice() instanceof TapCase) {
 116                 TapCase tapCase = (TapCase) vppEndpointOptional.get().getInterfaceTypeChoice();
 117                 physAddress = tapCase.getPhysicalAddress().getValue();
 118                 LOG.trace("Resolved PhysicalAddress : {} for metadataInterfaceName: {}, on node: {}", physAddress
 119                     , metadataInterfaceName, hostName);
 120             } else {
 121                 LOG.warn("PhysicalAddress was not resolved for metadataInterfaceName: {}, on node: {}",
 122                     metadataInterfaceName, hostName);
 123             }
 124         }
 125
 126         return physAddress;
 127     }
 128
 129     public void handleEndpointDeleteForFlatOverlay(AddressEndpointWithLocation addressEp) {
 130         if (overlayHelper.hasRelativeLocations(addressEp)) {
 131             // okay to ignore
 132             // routes will be deleted on interface delete
 133             return;
 134         }
 135         deleteStaticRoute(addressEp);
 136     }
 137
 138     public void handleInterfaceDeleteForFlatOverlay(DataBroker vppDataBroker, VppEndpoint vppEndpoint) {
 139         String hostName = vppEndpoint.getVppNodeId().getValue();
 140         String interfaceName = vppEndpoint.getVppInterfaceName();
 141
 142         staticRoutingHelper.deleteAllRoutesThroughInterface(vppDataBroker, hostName, interfaceName);
 143
 144         PortInterfaces portInterfaces = hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName);
 145         portInterfaces.removePortInterface(interfaceName);
 146     }
 147
 148     private void configureInterfaceForFlatOverlay(AddressEndpointWithLocation addressEp) {
 149         addInterfaceInVrf(addressEp);
 150     }
 151
 152     private void addInterfaceInVrf(AddressEndpointWithLocation addressEp) {
 153         EndpointHost endpointHost = overlayHelper.getEndpointHostInformation(addressEp);
 154         long vni = getVni(addressEp.getTenant().getValue());
 155         long vrf = vni;
 156         Optional<String> interfaceNameOptional = overlayHelper.getInterfaceName(addressEp);
 157
 158         Preconditions.checkArgument(interfaceNameOptional.isPresent());
 159
 160         addInterfaceInVrf(endpointHost.getHostName(), interfaceNameOptional.get(), vrf);
 161     }
 162
 163     private void addInterfaceInVrf(String hostName, String interfaceName, long vrf) {
 164         if (hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName)
 165                 .isVrfConfiguredForInterface(interfaceName)) {
 166             return;
 167         }
 168
 169         if (!putVrfInInterface(hostName, interfaceName, vrf)) {
 170             LOG.warn("Failed to put interface {} to vrf {}", interfaceName, vrf);
 171         } else {
 172             hostRelatedInfoContainer
 173                     .getPortInterfaceStateOfHost(hostName)
 174                     .initializeRoutingContextForInterface(interfaceName, vrf);
 175             LOG.debug("Added interface {} to vrf {}", interfaceName, vrf);
 176         }
 177     }
 178
 179     private boolean putVrfInInterface(String hostName,
 180                                   String interfaceName,
 181                                   Long vrf) {
 182         InstanceIdentifier<Routing> iid = VppIidFactory.getRoutingIid(new InterfaceKey(interfaceName));
 183         RoutingBuilder builder = new RoutingBuilder();
 184         builder.setIpv4VrfId(vrf);
 185         return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.HOSTNAME_TO_IID.apply(hostName), iid,
 186                 builder.build(), GbpNetconfTransaction.RETRY_COUNT);
 187     }
 188
 189     private void addStaticArp(AddressEndpointWithLocation addressEp) {
 190         String hostName = overlayHelper.getHostName(addressEp).get();
 191         String physicalAddress = overlayHelper.getPhysicalAddress(addressEp);
 192         Optional<String> interfaceNameOptional = overlayHelper.getInterfaceName(addressEp);
 193
 194         Preconditions.checkArgument(interfaceNameOptional.isPresent());
 195
 196         String interfaceName = interfaceNameOptional.get();
 197
 198         addStaticArp(hostName, interfaceName, physicalAddress, overlayHelper.getInterfaceIp(addressEp));
 199     }
 200
 201     private void addStaticArp(String hostName,
 202                               String interfaceName,
 203                               String physicalAddress,
 204                               Ipv4Address ipv4Address) {
 205         Ipv4AddressNoZone ip = new Ipv4AddressNoZone(ipv4Address);
 206         InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
 207         if (!putStaticArp(hostName,
 208                              interfaceKey,
 209                              new PhysAddress(physicalAddress),
 210                              ip)) {
 211             LOG.warn("Failed to put static arp with interface {} for ip={} and physical-address={}",
 212                     interfaceName, ip, physicalAddress);
 213         } else {
 214             LOG.debug("Added Static arp ({} {}) in host {} for interface {}", ip, physicalAddress, hostName,
 215                     interfaceName);
 216         }
 217     }
 218
 219     private boolean putStaticArp(String hostName,
 220                                  InterfaceKey interfaceKey,
 221                                  PhysAddress physAddress,
 222                                  Ipv4AddressNoZone ip) {
 223         StaticArpCommand.StaticArpCommandBuilder staticArpCommandBuilder = new StaticArpCommand.StaticArpCommandBuilder();
 224
 225         staticArpCommandBuilder.setOperation(General.Operations.PUT);
 226         staticArpCommandBuilder.setInterfaceKey(interfaceKey);
 227         staticArpCommandBuilder.setIp(ip);
 228         staticArpCommandBuilder.setLinkLayerAddress(physAddress);
 229
 230         return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.HOSTNAME_TO_IID.apply(hostName),
 231                 staticArpCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT);
 232     }
 233
 234     private void addStaticRoute(AddressEndpointWithLocation addressEp) {
 235         String hostName = overlayHelper.getHostName(addressEp).get();
 236         long vni = getVni(addressEp.getTenant().getValue());
 237         long vrf = vni;
 238
 239         String portSubnetUuid = overlayHelper.getSubnet(addressEp);
 240
 241         String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get();
 242         Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp);
 243
 244         if (overlayHelper.isMetadataPort(addressEp)) {
 245             //override original port subnet to handle the Absolute location case of address endpoint
 246             portSubnetUuid = Constants.METADATA_SUBNET_UUID;
 247         }
 248
 249         Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp);
 250
 251         addStaticRoute(hostName, vrf, portSubnetUuid, ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName);
 252     }
 253
 254     private void addStaticRoute(String hostName, long vrfId, String hostIpSubnetUuid,
 255                                 Ipv4Address ipWithoutPrefix, Ipv4Prefix ipv4Prefix, String outgoingInterfaceName) {
 256
 257         VrfHolder vrfHolderOfHost = hostRelatedInfoContainer.getVrfStateOfHost(hostName);
 258
 259         if (!vrfHolderOfHost.hasVrf(vrfId)) {
 260             if (!staticRoutingHelper.addRoutingProtocolForVrf(LispUtil.HOSTNAME_TO_IID.apply(hostName), vrfId,
 261                     vrfHolderOfHost)) {
 262                 addStaticRouteToPublicInterface(hostName, vrfId);
 263                 LOG.warn("Failed to add Routing protocol for host {} and vrf {}!", hostName, vrfId);
 264             }
 265         }
 266
 267         VrfState vrfStateOfVrfId = vrfHolderOfHost.getVrfState(vrfId);
 268
 269         if (vrfStateOfVrfId.getSubnetHolder().getSubnetState(hostIpSubnetUuid).isIpPresent(ipWithoutPrefix)) {
 270             LOG.info("Ip already exists in host {} vrf {} ip {}", hostName, vrfId, ipWithoutPrefix);
 271             return;
 272         }
 273
 274         if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(hostName, vrfId, hostIpSubnetUuid,
 275                 ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName)) {
 276             LOG.warn("Failed to add routing ({} via {}) in vrf {} in compute host {}!",
 277                     ipv4Prefix, outgoingInterfaceName, vrfId, hostName);
 278         } else {
 279             LOG.debug("Added route ({} via {}) in vrf {} in compute host {}",
 280                     ipv4Prefix, outgoingInterfaceName, vrfId, hostName);
 281         }
 282     }
 283
 284     private void addStaticRouteToPublicInterface(String hostName, long vrfId) {
 285         Ipv4Address physicalInterfaceIp = hostRelatedInfoContainer
 286                 .getPhysicalInterfaceState(hostName)
 287                 .getIp(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC).getIpv4Address();
 288         String physicalInterfaceName = hostRelatedInfoContainer
 289                 .getPhysicalInterfaceState(hostName)
 290                 .getName(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC);
 291         if (physicalInterfaceName != null && !physicalInterfaceName.isEmpty()) {
 292             if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(hostName, vrfId,
 293                     Constants.PUBLIC_SUBNET_UUID, physicalInterfaceIp,
 294                     IpAddressUtil.toIpV4Prefix(physicalInterfaceIp), physicalInterfaceName)) {
 295                 LOG.warn("Failed to add route for physical interface in vrf {} compute host {}", vrfId, hostName);
 296             } else {
 297                 LOG.debug("Added route for physical interface {} in vrf {}", physicalInterfaceName, vrfId);
 298             }
 299         }
 300     }
 301
 302     private void deleteStaticRoute(AddressEndpointWithLocation addressEp) {
 303         String hostName = overlayHelper.getHostName(addressEp).get();
 304         String interfaceName = overlayHelper.getInterfaceName(addressEp).get();
 305
 306         long vni = getVni(addressEp.getTenant().getValue());
 307         long vrfId = vni;
 308
 309         String ipSubnetUuid = overlayHelper.getSubnet(addressEp);
 310
 311         if (overlayHelper.isMetadataPort(addressEp)) {
 312             //override original port subnet to handle the Absolute location case of address endpoint
 313             ipSubnetUuid = Constants.METADATA_SUBNET_UUID;
 314         }
 315
 316         Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp);
 317
 318         PortRouteState portRouteState = hostRelatedInfoContainer
 319                                             .getPortInterfaceStateOfHost(hostName)
 320                                             .getPortRouteState(interfaceName);
 321
 322         SubnetState subnetState = hostRelatedInfoContainer
 323                                     .getVrfStateOfHost(hostName)
 324                                     .getVrfState(vrfId)
 325                                     .getSubnetHolder()
 326                                     .getSubnetState(ipSubnetUuid);
 327
 328         if (!subnetState.isIpPresent(ipWithoutPrefix)) {
 329             LOG.debug("Route {} already deleted from vrf {} of host {}", ipWithoutPrefix, vrfId, hostName);
 330             return;
 331         }
 332
 333         long targetRouteId = portRouteState.getRouteIdOfIp(ipWithoutPrefix);
 334
 335         if (!staticRoutingHelper.deleteSingleStaticRouteFromRoutingProtocol(hostName,
 336                                                                             vrfId,
 337                                                                             interfaceName,
 338                                                                             targetRouteId)) {
 339             LOG.warn("Failed to delete route ({} via {}) from vrf {} from host{}",
 340                     ipWithoutPrefix, interfaceName, vrfId, hostName);
 341
 342         } else {
 343             portRouteState.removeIp(ipWithoutPrefix);
 344             subnetState.removeIp(ipWithoutPrefix);
 345             LOG.debug("Delete Static Route ({} via {}) from vrf {} from host {}",
 346                     ipWithoutPrefix, interfaceName, vrfId, hostName);
 347         }
 348     }
 349
 350     private long getVni(String tenantUuid) {
 351         return neutronTenantToVniMapper.getVni(tenantUuid);
 352     }
 353 }