bgpmanager/impl/src/main/java/org/opendaylight/netvirt/bgpmanager/BgpUtil.java

   1 /*
   2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netvirt.bgpmanager;
   9
  10 import com.google.common.base.Optional;
  11 import java.net.Inet4Address;
  12 import java.net.Inet6Address;
  13 import java.net.InetAddress;
  14 import java.util.ArrayList;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.concurrent.BlockingQueue;
  19 import java.util.concurrent.LinkedBlockingQueue;
  20 import javax.annotation.PostConstruct;
  21 import javax.annotation.PreDestroy;
  22 import javax.inject.Inject;
  23 import javax.inject.Singleton;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  27 import org.opendaylight.genius.mdsalutil.NwConstants;
  28 import org.opendaylight.genius.utils.batching.ActionableResource;
  29 import org.opendaylight.genius.utils.batching.ActionableResourceImpl;
  30 import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
  31 import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
  32 import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
  33 import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
  34 import org.opendaylight.netvirt.bgpmanager.thrift.gen.encap_type;
  35 import org.opendaylight.netvirt.bgpmanager.thrift.gen.protocol_type;
  36 import org.opendaylight.netvirt.fibmanager.api.IFibManager;
  37 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebfd.rev190219.BfdConfig;
  38 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
  39 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.BgpControlPlaneType;
  40 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.EncapType;
  41 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.LayerType;
  42 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.DcgwTepList;
  43 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.VrfsContainer;
  44 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.dcgw.tep.list.DcgwTep;
  45 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.dcgw.tep.list.DcgwTepKey;
  46 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.Vrfs;
  47 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.VrfsKey;
  48 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfscontainer.vrfs.AddressFamiliesVrf;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTeps;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTepsBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTepsKey;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnRdToNetworks;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetwork;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetworkKey;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  72 import org.opendaylight.yangtools.yang.binding.DataObject;
  73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  75 import org.slf4j.Logger;
  76 import org.slf4j.LoggerFactory;
  77
  78 @Singleton
  79 public class BgpUtil implements AutoCloseable {
  80     private static final Logger LOG = LoggerFactory.getLogger(BgpUtil.class);
  81     private static final String RESOURCE_TYPE = "BGP-RESOURCES";
  82     private static final int DEFAULT_BATCH_SIZE = 1000;
  83     private static final int DEFAULT_BATCH_INTERVAL = 500;
  84     private int enableBfdFlag = -1;
  85
  86     private final DataBroker dataBroker;
  87     private final IFibManager fibManager;
  88
  89
  90     private final BlockingQueue<ActionableResource> bgpResourcesBufferQ = new LinkedBlockingQueue<>();
  91
  92     @Inject
  93     public BgpUtil(DataBroker dataBroker, final IFibManager fibManager) {
  94         this.dataBroker = dataBroker;
  95         this.fibManager = fibManager;
  96     }
  97
  98     @PostConstruct
  99     public void init() {
 100         ResourceBatchingManager resBatchingManager = ResourceBatchingManager.getInstance();
 101
 102         Integer batchSize = Integer.getInteger("batch.size", DEFAULT_BATCH_SIZE);
 103         Integer batchInterval = Integer.getInteger("batch.wait.time", DEFAULT_BATCH_INTERVAL);
 104
 105         resBatchingManager.registerBatchableResource(RESOURCE_TYPE, bgpResourcesBufferQ,
 106                 new DefaultBatchHandler(dataBroker, LogicalDatastoreType.CONFIGURATION, batchSize, batchInterval));
 107     }
 108
 109     @Override
 110     @PreDestroy
 111     public void close() {
 112         ResourceBatchingManager.getInstance().deregisterBatchableResource(RESOURCE_TYPE);
 113     }
 114
 115     /**
 116      * get a translation from prefix ipv6 to afi<br>.
 117      * "ffff::1/128" sets afi as 2 because is an IPv6 value
 118      * @param argPrefix ip address as ipv4 or ipv6
 119      * @return afi 1 for AFI_IP 2 for AFI_IPV6
 120      */
 121     public static int getAFItranslatedfromPrefix(String argPrefix) {
 122         int retValue = af_afi.AFI_IP.getValue();//default afiValue is 1 (= ipv4)
 123         String prefixOnly;
 124         if (argPrefix.indexOf("/") == -1) {
 125             prefixOnly = argPrefix;
 126         } else {
 127             prefixOnly = argPrefix.substring(0, argPrefix.indexOf("/"));
 128         }
 129         try {
 130             InetAddress address = InetAddress.getByName(prefixOnly);
 131             if (address instanceof Inet6Address) {
 132                 retValue = af_afi.AFI_IPV6.getValue();
 133             } else if (address instanceof Inet4Address) {
 134                 retValue = af_afi.AFI_IP.getValue();
 135             }
 136         } catch (java.net.UnknownHostException e) {
 137             /*if exception is catched then the prefix is not an IPv6 and IPv4*/
 138             LOG.error("Unrecognized ip address ipAddress: {}", argPrefix);
 139             retValue = af_afi.AFI_IP.getValue();//default afiValue is 1 (= ipv4)
 140         }
 141         return retValue;
 142     }
 143
 144     public <T extends DataObject> void update(final InstanceIdentifier<T> path, final T data) {
 145         ActionableResourceImpl actResource = new ActionableResourceImpl(path.toString());
 146         actResource.setAction(ActionableResource.UPDATE);
 147         actResource.setInstanceIdentifier(path);
 148         actResource.setInstance(data);
 149         bgpResourcesBufferQ.add(actResource);
 150     }
 151
 152     public <T extends DataObject> void write(final InstanceIdentifier<T> path, final T data) {
 153         ActionableResourceImpl actResource = new ActionableResourceImpl(path.toString());
 154         actResource.setAction(ActionableResource.CREATE);
 155         actResource.setInstanceIdentifier(path);
 156         actResource.setInstance(data);
 157         bgpResourcesBufferQ.add(actResource);
 158     }
 159
 160     public <T extends DataObject> void delete(final InstanceIdentifier<T> path) {
 161         ActionableResourceImpl actResource = new ActionableResourceImpl(path.toString());
 162         actResource.setAction(ActionableResource.DELETE);
 163         actResource.setInstanceIdentifier(path);
 164         actResource.setInstance(null);
 165         bgpResourcesBufferQ.add(actResource);
 166     }
 167
 168     // Convert ProtocolType to thrift protocol_type
 169     public static protocol_type convertToThriftProtocolType(BgpControlPlaneType protocolType) {
 170         switch (protocolType) {
 171             case PROTOCOLLU:
 172                 return protocol_type.PROTOCOL_LU;
 173             case PROTOCOLL3VPN:
 174                 return protocol_type.PROTOCOL_L3VPN;
 175             case PROTOCOLEVPN:
 176                 return protocol_type.PROTOCOL_EVPN;
 177             default:
 178                 return protocol_type.PROTOCOL_ANY;
 179         }
 180     }
 181
 182     // Convert EncapType to thrift encap_type
 183     public static encap_type convertToThriftEncapType(EncapType encapType) {
 184         switch (encapType) {
 185             case L2TPV3OVERIP:
 186                 return encap_type.L2TPV3_OVER_IP;
 187             case GRE:
 188                 return encap_type.GRE;
 189             case IPINIP:
 190                 return encap_type.IP_IN_IP;
 191             case VXLAN:
 192                 return encap_type.VXLAN;
 193             case MPLS:
 194             default:
 195                 return encap_type.MPLS;
 196         }
 197     }
 198
 199     public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd)  {
 200         InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
 201         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = MDSALUtil.read(dataBroker,
 202                 LogicalDatastoreType.OPERATIONAL, id);
 203         if (vpnInstanceOpData.isPresent()) {
 204             return vpnInstanceOpData.get();
 205         }
 206         return null;
 207     }
 208
 209     public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 210         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 211                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 212     }
 213
 214     private String getElanNamefromRd(String rd)  {
 215         InstanceIdentifier<EvpnRdToNetwork> id = getEvpnRdToNetworkIdentifier(rd);
 216         Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = MDSALUtil.read(dataBroker,
 217                 LogicalDatastoreType.CONFIGURATION, id);
 218         if (evpnRdToNetworkOpData.isPresent()) {
 219             return evpnRdToNetworkOpData.get().getNetworkId();
 220         }
 221         return null;
 222     }
 223
 224     private static InstanceIdentifier<EvpnRdToNetwork> getEvpnRdToNetworkIdentifier(String rd) {
 225         return InstanceIdentifier.builder(EvpnRdToNetworks.class)
 226                 .child(EvpnRdToNetwork.class, new EvpnRdToNetworkKey(rd)).build();
 227     }
 228
 229     public void addTepToElanInstance(String rd, String tepIp) {
 230         if (rd == null || tepIp == null) {
 231             LOG.error("addTepToElanInstance : Null parameters returning");
 232             return;
 233         }
 234         String elanName = getElanNamefromRd(rd);
 235         if (elanName == null) {
 236             LOG.error("Elan null while processing RT2 for RD {}", rd);
 237             return;
 238         }
 239         LOG.debug("Adding tepIp {} to elan {}", tepIp, elanName);
 240         InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
 241         ExternalTepsBuilder externalTepsBuilder = new ExternalTepsBuilder();
 242         ExternalTepsKey externalTepsKey = externalTepsId.firstKeyOf(ExternalTeps.class);
 243         externalTepsBuilder.setTepIp(externalTepsKey.getTepIp());
 244         update(externalTepsId, externalTepsBuilder.build());
 245     }
 246
 247     public void deleteTepFromElanInstance(String rd, String tepIp) {
 248         if (rd == null || tepIp == null) {
 249             LOG.error("deleteTepFromElanInstance : Null parameters returning");
 250             return;
 251         }
 252         String elanName = getElanNamefromRd(rd);
 253         if (elanName == null) {
 254             LOG.error("Elan null while processing RT2 withdraw for RD {}", rd);
 255             return;
 256         }
 257         LOG.debug("Deleting tepIp {} from elan {}", tepIp, elanName);
 258         InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
 259         delete(externalTepsId);
 260     }
 261
 262     private static InstanceIdentifier<ExternalTeps> getExternalTepsIdentifier(String elanInstanceName, String tepIp) {
 263         IpAddress tepAdress = tepIp == null ? null : new IpAddress(new Ipv4Address(tepIp));
 264         return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
 265                 new ElanInstanceKey(elanInstanceName)).child(ExternalTeps.class,
 266                 new ExternalTepsKey(tepAdress)).build();
 267     }
 268
 269     public String getVpnNameFromRd(String rd) {
 270         final Map<String, String> rdtoVpnMap = new HashMap<>();
 271         if (rdtoVpnMap.get(rd) != null) {
 272             return rdtoVpnMap.get(rd);
 273         } else {
 274             VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
 275             String vpnName = vpnInstanceOpData != null ? vpnInstanceOpData.getVpnInstanceName() : null;
 276             rdtoVpnMap.put(rd, vpnName);
 277             return vpnName;
 278         }
 279     }
 280
 281     /** get the vrf with the RouterDistinguisher pass in param.
 282      * @param rd is the RouteDistinguisher of vrf
 283      * @return the vrf of rd or null if no exist
 284      */
 285     public Vrfs getVrfFromRd(String rd) {
 286         Vrfs vrfs = null;
 287         KeyedInstanceIdentifier<Vrfs, VrfsKey> id = InstanceIdentifier.create(Bgp.class)
 288                 .child(VrfsContainer.class)
 289                 .child(Vrfs.class, new VrfsKey(rd));
 290         Optional<Vrfs> vrfsFromDs = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 291         if (vrfsFromDs.isPresent()) {
 292             vrfs = vrfsFromDs.get();
 293         }
 294         return vrfs;
 295     }
 296
 297     /** get layerType used from an AddressFamiliesVrf.
 298      * @param adf is the AddressFamiliesVrf from which the layer is asked.
 299      * @return the layerType to reach from the argument addressFamilyVrf or null if not found
 300      */
 301     public static LayerType getLayerType(AddressFamiliesVrf adf) {
 302         LayerType layerTypeValue = null;
 303         if (adf.getSafi().intValue() == af_safi.SAFI_EVPN.getValue()) {
 304             layerTypeValue = LayerType.LAYER2;
 305         } else if (adf.getSafi().intValue() == af_safi.SAFI_MPLS_VPN.getValue()) {
 306             layerTypeValue = LayerType.LAYER3;
 307         }
 308         return layerTypeValue;
 309     }
 310
 311     public void removeVrfEntry(String rd, VrfEntry vrfEntry) {
 312         LOG.debug("removeVrfEntry : vrf {} prefix {}", rd, vrfEntry.getDestPrefix());
 313         InstanceIdentifier<VrfEntry> vrfEntryId =
 314                    InstanceIdentifier.builder(FibEntries.class)
 315                    .child(VrfTables.class, new VrfTablesKey(rd))
 316                    .child(VrfEntry.class, new VrfEntryKey(vrfEntry.getDestPrefix())).build();
 317         delete(vrfEntryId);
 318     }
 319
 320     public void enableBfdFlag() {
 321         enableBfdFlag = 1;
 322     }
 323
 324     public void disableBfdFlag() {
 325         enableBfdFlag = 0;
 326     }
 327
 328     public boolean isBfdEnabled() {
 329         if (enableBfdFlag == 1) {
 330             return true;
 331         } else if (enableBfdFlag == 0) {
 332             return false;
 333         }
 334         BfdConfig bfdConfig = getBfdConfig();
 335         if (bfdConfig != null) {
 336             return bfdConfig.isBfdEnabled();
 337         }
 338         return false;
 339     }
 340
 341     public BfdConfig getBfdConfig() {
 342         InstanceIdentifier<BfdConfig> id =
 343                 InstanceIdentifier.builder(BfdConfig.class).build();
 344         Optional<BfdConfig> bfdConfigOptional = MDSALUtil.read(dataBroker,
 345                 LogicalDatastoreType.CONFIGURATION, id);
 346         if (bfdConfigOptional.isPresent()) {
 347             return bfdConfigOptional.get();
 348         }
 349         return null;
 350     }
 351
 352     public DcgwTepList getDcgwTepConfig() {
 353         InstanceIdentifier<DcgwTepList> id =
 354                 InstanceIdentifier.builder(Bgp.class).child(DcgwTepList.class).build();
 355         Optional<DcgwTepList> dcgwTepListOptional = MDSALUtil.read(dataBroker,
 356                 LogicalDatastoreType.CONFIGURATION, id);
 357         if (dcgwTepListOptional.isPresent()) {
 358             return dcgwTepListOptional.get();
 359         }
 360         return null;
 361     }
 362
 363     public List<String> getDcgwTepConfig(String dcgwIp) {
 364         InstanceIdentifier<DcgwTep> id =
 365                 InstanceIdentifier.builder(Bgp.class)
 366                         .child(DcgwTepList.class)
 367                         .child(DcgwTep.class, new DcgwTepKey(dcgwIp)).build();
 368         Optional<DcgwTep> tepListOptional = MDSALUtil.read(dataBroker,
 369                 LogicalDatastoreType.CONFIGURATION, id);
 370         if (tepListOptional.isPresent()) {
 371             return tepListOptional.get().getTepIps();
 372         }
 373         LOG.debug("No tep configured for DCGW {}", dcgwIp);
 374         return null;
 375     }
 376
 377     public static List<DPNTEPsInfo> getDpnTEPsInfos(DataBroker dataBroker) {
 378         InstanceIdentifier<DpnEndpoints> iid = InstanceIdentifier.builder(DpnEndpoints.class).build();
 379         Optional<DpnEndpoints> dpnEndpoints = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
 380         if (dpnEndpoints.isPresent()) {
 381             return dpnEndpoints.get().getDPNTEPsInfo();
 382         } else {
 383             return new ArrayList<>();
 384         }
 385     }
 386
 387     public void removeOrUpdateLBGroups(String tepIp, int addRemoveOrUpdate) {
 388         getDpnTEPsInfos(dataBroker).forEach(dpnInfo -> {
 389             if (NwConstants.MOD_FLOW == addRemoveOrUpdate) {
 390                 LOG.debug("Updating bucket in DPN {}", dpnInfo.getDPNID());
 391             } else if (NwConstants.DEL_FLOW == addRemoveOrUpdate) {
 392                 LOG.debug("Deleting groups in DPN {}", dpnInfo.getDPNID());
 393             }
 394             Class<? extends TunnelTypeBase> tunType = TunnelTypeMplsOverGre.class;
 395             fibManager.programDcGwLoadBalancingGroup(dpnInfo.getDPNID(),
 396                     tepIp, addRemoveOrUpdate, false, tunType);
 397         });
 398     }
 399 }