renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.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.util;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.util.concurrent.Futures;
  14 import com.google.common.util.concurrent.ListenableFuture;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppPathMapper;
  18 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispState;
  19 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
  20 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispNotFoundException;
  21 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
  22 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.EthernetCsmacd;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.Address;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.Containment;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.HmacKeyType;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.local.mapping.Eid;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170315.interfaces._interface.Routing;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170315.interfaces._interface.RoutingBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  52 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  54 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 import javax.annotation.Nonnull;
  59 import java.util.List;
  60 import java.util.Map;
  61 import java.util.Set;
  62
  63
  64 /**
  65  * Created by Shakib Ahmed on 3/31/17.
  66  */
  67 public class ConfigManagerHelper {
  68     private static final Logger LOG = LoggerFactory.getLogger(ConfigManagerHelper.class);
  69
  70     private static final String TENANT_INTERFACE = "tenant-interface";
  71     private MountedDataBrokerProvider mountedDataBrokerProvider;
  72
  73     public ConfigManagerHelper(MountedDataBrokerProvider mountedDataBrokerProvider) {
  74         this.mountedDataBrokerProvider = mountedDataBrokerProvider;
  75     }
  76
  77     public Optional<DataBroker> getPotentialExternalDataBroker(AddressEndpointWithLocation addressEpWithLoc) {
  78         ExternalLocationCase externalLocationCase = resolveAndValidateLocation(addressEpWithLoc);
  79         InstanceIdentifier<?> vppNodeIid = externalLocationCase.getExternalNodeMountPoint();
  80         String interfacePath = externalLocationCase.getExternalNodeConnector();
  81
  82         Optional<DataBroker> potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid);
  83
  84         Preconditions.checkArgument(potentialVppDataProvider.isPresent(),
  85                 "Cannot resolve data broker for interface path: {}", interfacePath);
  86
  87         return potentialVppDataProvider;
  88     }
  89
  90     public Optional<DataBroker> getPotentialExternalDataBroker(VppEndpoint vppEp) {
  91         InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(vppEp.getVppNodeId());
  92         Optional<DataBroker> potentialVppDataProvider =
  93                 mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid);
  94
  95         Preconditions.checkArgument(potentialVppDataProvider.isPresent(),
  96                 "Cannot resolve data broker for Vpp Endpoint: {}", vppEp);
  97         return potentialVppDataProvider;
  98     }
  99
 100     public Optional<DataBroker> getPotentialExternalDataBroker(String hostId) {
 101         InstanceIdentifier<Node> nodeIid = VppIidFactory.getNetconfNodeIid(new NodeId(hostId));
 102         Optional<DataBroker> potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(nodeIid);
 103         Preconditions.checkArgument(potentialVppDataProvider.isPresent(),
 104                 "Data Broker not found for {}", hostId);
 105         return potentialVppDataProvider;
 106     }
 107
 108     public Optional<String> getHostName(AddressEndpointWithLocation addrEp) {
 109         ExternalLocationCase locationCase = resolveAndValidateLocation(addrEp);
 110         NodeKey nodeKey = locationCase.getExternalNodeMountPoint().firstKeyOf(Node.class);
 111         String hostId = Preconditions.checkNotNull(nodeKey.getNodeId().getValue(),
 112                 "Host Id extraction failed from address endpoint: {}", addrEp);
 113         return Optional.fromNullable(hostId);
 114     }
 115
 116     public ExternalLocationCase resolveAndValidateLocation(AddressEndpointWithLocation addrEpWithLoc) {
 117         LocationType locationType = addrEpWithLoc.getAbsoluteLocation().getLocationType();
 118         if (!(locationType instanceof ExternalLocationCase)) {
 119             throw new IllegalArgumentException("Endpoint does not have external location " + addrEpWithLoc);
 120         }
 121         ExternalLocationCase result = (ExternalLocationCase) locationType;
 122         if (result.getExternalNodeMountPoint() == null || result.getExternalNodeConnector() == null) {
 123             throw new IllegalArgumentException(
 124                     "Endpoint does not have external-node-mount-point or external-node-connector " + addrEpWithLoc);
 125         }
 126         return result;
 127     }
 128
 129     //This is almost identical to VBD's equivalent method
 130     public ListenableFuture<String> readRlocInterface(@Nonnull String hostName, @Nonnull DataBroker vppDataBroker) {
 131         Preconditions.checkNotNull(hostName, "Hostname is null!");
 132         Preconditions.checkNotNull(vppDataBroker, "Vpp DataBroker is null!");
 133         final Optional<InterfacesState> opInterfaceState = GbpNetconfTransaction.read(vppDataBroker,
 134                 LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class),
 135                 GbpNetconfTransaction.RETRY_COUNT);
 136
 137         if (!opInterfaceState.isPresent()) {
 138             LOG.debug("There appear to be no interfaces on node {}.", hostName);
 139             return Futures.immediateFailedFuture(new LispNotFoundException("No interfaces found"));
 140         }
 141
 142         String interfaceName = null;
 143         for(Interface intf: opInterfaceState.get().getInterface()) {
 144             if(!ipAddressPresent(intf)) {
 145                 continue;
 146             }
 147             interfaceName = intf.getName();
 148         }
 149
 150         final Optional<Interfaces> opInterfaces =
 151                 GbpNetconfTransaction.read(vppDataBroker, LogicalDatastoreType.CONFIGURATION,
 152                         InstanceIdentifier.create(Interfaces.class), GbpNetconfTransaction.RETRY_COUNT);
 153
 154
 155         if (opInterfaces.isPresent()) {
 156             for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.
 157                     interfaces.Interface intf : opInterfaces.get().getInterface()) {
 158                 if (TENANT_INTERFACE.equals(intf.getDescription())
 159                         && ipAddressPresent(intf)
 160                         && intf.getType().equals(EthernetCsmacd.class)) {
 161                     return Futures.immediateFuture(intf.getName());
 162                 }
 163             }
 164         }
 165
 166         if (interfaceName == null) {
 167             LOG.warn("No interface with IP found for host {}", hostName);
 168             return Futures.immediateFailedFuture(new LispNotFoundException("No interface with Ip address found!"));
 169         }
 170         return Futures.immediateFuture(interfaceName);
 171     }
 172
 173     private boolean ipAddressPresent(Interface intf) {
 174         Interface2 augIntf = intf.getAugmentation(Interface2.class);
 175
 176         if (augIntf == null) {
 177             return false;
 178         }
 179
 180         Ipv4 ipv4 = augIntf.getIpv4();
 181
 182         if (ipv4 == null) {
 183             return false;
 184         }
 185
 186         final List<Address> addresses = ipv4.getAddress();
 187
 188         if (addresses == null || addresses.isEmpty()) {
 189             return false;
 190         }
 191
 192         final Ipv4AddressNoZone ip = addresses.iterator().next().getIp();
 193
 194         if (ip == null) {
 195             return false;
 196         }
 197
 198         return true;
 199     }
 200
 201     private boolean ipAddressPresent(final org.opendaylight.yang.gen.v1.urn.ietf.
 202             params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface intf) {
 203         final Interface1 augIntf = intf.getAugmentation(Interface1.class);
 204
 205         if (augIntf == null) {
 206             LOG.debug("Cannot get Interface1 augmentation for intf {}", intf);
 207             return false;
 208         }
 209
 210         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4 ipv4 =
 211                 augIntf.getIpv4();
 212         if (ipv4 == null) {
 213             return false;
 214         }
 215
 216         final List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address> addresses =
 217                 ipv4.getAddress();
 218         if (addresses == null || addresses.isEmpty()) {
 219             return false;
 220         }
 221
 222         final Ipv4AddressNoZone ip = addresses.iterator().next().getIp();
 223         if (ip == null) {
 224             return false;
 225         }
 226
 227         return true;
 228     }
 229
 230     public String constructLocatorSetName(int locatorSetCount) {
 231         return LispStateManager.DEFAULT_LOCATOR_SET_NAME_PREFIX + (locatorSetCount + 1);
 232     }
 233
 234     public String constructMappingName(int presentMappingCount) {
 235         return LispStateManager.DEFAULT_MAPPINGRECORD_NAME_PREFIX + (presentMappingCount + 1);
 236     }
 237
 238     public String getSubnet(AddressEndpointWithLocation addressEp) {
 239         String subnetUuid = null;
 240         Containment containment = addressEp.getNetworkContainment().getContainment();
 241         if (containment instanceof NetworkDomainContainment) {
 242             NetworkDomainContainment networkDomainContainment = (NetworkDomainContainment) containment;
 243             subnetUuid = networkDomainContainment.getNetworkDomainId().getValue();
 244         }
 245         return subnetUuid;
 246     }
 247
 248     public Eid getEid(AddressEndpointWithLocation addressEp, long vni) {
 249         String ipPrefix = getIpWithPrefixOfEndpoint(addressEp);
 250         return LispUtil.toEid(LispUtil.toIpv4(ipPrefix), vni, Ipv4Afi.class);
 251     }
 252
 253     public String getIpWithPrefixOfEndpoint(AddressEndpointWithLocation addressEp) {
 254         String ipPrefix = null;
 255         if (addressEp.getAddressType().equals(IpPrefixType.class)) {
 256             ipPrefix = addressEp.getAddress();
 257         }
 258         return Preconditions.checkNotNull(ipPrefix,
 259                 "No IP address found for Address Endpoint: {}", addressEp);
 260     }
 261
 262     public Ipv4Address getInterfaceIp(AddressEndpointWithLocation addressEp) {
 263         String ipPrefix = getIpWithPrefixOfEndpoint(addressEp);
 264         return LispUtil.toIpv4(ipPrefix).getIpv4();
 265     }
 266
 267     public Ipv4Prefix getInterfaceIpAsPrefix(AddressEndpointWithLocation addressEp) {
 268         return new Ipv4Prefix(getInterfaceIp(addressEp).getValue() + "/32");
 269     }
 270
 271     public String getFirstLocatorSetName(LispState lispState) {
 272         Set<Map.Entry<String, String >> locatorSet = lispState.getLocatorSetEntry();
 273         Preconditions.checkNotNull(locatorSet, "No locator set found!");
 274         if (!locatorSet.iterator().hasNext()) {
 275             return null;
 276         }
 277
 278         return locatorSet.iterator().next().getValue();
 279     }
 280
 281     public Optional<String> getInterfaceName(AddressEndpointWithLocation addedEp) {
 282         ExternalLocationCase epLoc = resolveAndValidateLocation(addedEp);
 283         String interfacePath = epLoc.getExternalNodeConnector();
 284
 285         return VppPathMapper.interfacePathToInterfaceName(interfacePath);
 286     }
 287
 288     public HmacKey getDefaultHmacKey() {
 289         return LispUtil.toHmacKey(HmacKeyType.Sha196Key, LispStateManager.DEFAULT_XTR_KEY);
 290     }
 291
 292     public String getPhysicalAddress(AddressEndpointWithLocation addressEp) {
 293         String physicalAddress = null;
 294
 295         List<ChildEndpoint> childEndpoints = addressEp.getChildEndpoint();
 296         for (ChildEndpoint childEndpoint : childEndpoints) {
 297             if (childEndpoint.getAddressType().equals(MacAddressType.class)) {
 298                 physicalAddress = childEndpoint.getAddress();
 299                 break;
 300             }
 301         }
 302         return Preconditions.checkNotNull(physicalAddress, "Physical address not found " +
 303                 "in address endpoint: " + addressEp);
 304     }
 305
 306     public Routing getRouting(long vrf) {
 307         return new RoutingBuilder().setIpv4VrfId(vrf).build();
 308     }
 309 }