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.concurrent.BlockingQueue;
  15 import java.util.concurrent.LinkedBlockingQueue;
  16 import javax.annotation.PostConstruct;
  17 import javax.annotation.PreDestroy;
  18 import javax.inject.Inject;
  19 import javax.inject.Singleton;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  23 import org.opendaylight.genius.utils.batching.ActionableResource;
  24 import org.opendaylight.genius.utils.batching.ActionableResourceImpl;
  25 import org.opendaylight.genius.utils.batching.DefaultBatchHandler;
  26 import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
  27 import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_afi;
  28 import org.opendaylight.netvirt.bgpmanager.thrift.gen.af_safi;
  29 import org.opendaylight.netvirt.bgpmanager.thrift.gen.encap_type;
  30 import org.opendaylight.netvirt.bgpmanager.thrift.gen.protocol_type;
  31 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.Bgp;
  32 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.BgpControlPlaneType;
  33 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.EncapType;
  34 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.LayerType;
  35 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.Vrfs;
  36 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.VrfsKey;
  37 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.bgp.vrfs.AddressFamiliesVrf;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTeps;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTepsBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ExternalTepsKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.EvpnRdToNetworks;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetwork;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.evpn.rd.to.networks.EvpnRdToNetworkKey;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  56 import org.opendaylight.yangtools.yang.binding.DataObject;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 @Singleton
  63 public class BgpUtil implements AutoCloseable {
  64     private static final Logger LOG = LoggerFactory.getLogger(BgpUtil.class);
  65     private static final String RESOURCE_TYPE = "BGP-RESOURCES";
  66     private static final int DEFAULT_BATCH_SIZE = 1000;
  67     private static final int DEFAULT_BATCH_INTERVAL = 500;
  68
  69     private final DataBroker dataBroker;
  70
  71     private final BlockingQueue<ActionableResource> bgpResourcesBufferQ = new LinkedBlockingQueue<>();
  72
  73     @Inject
  74     public BgpUtil(DataBroker dataBroker) {
  75         this.dataBroker = dataBroker;
  76     }
  77
  78     @PostConstruct
  79     public void init() {
  80         ResourceBatchingManager resBatchingManager = ResourceBatchingManager.getInstance();
  81
  82         Integer batchSize = Integer.getInteger("batch.size", DEFAULT_BATCH_SIZE);
  83         Integer batchInterval = Integer.getInteger("batch.wait.time", DEFAULT_BATCH_INTERVAL);
  84
  85         resBatchingManager.registerBatchableResource(RESOURCE_TYPE, bgpResourcesBufferQ,
  86                 new DefaultBatchHandler(dataBroker, LogicalDatastoreType.CONFIGURATION, batchSize, batchInterval));
  87     }
  88
  89     @Override
  90     @PreDestroy
  91     public void close() {
  92         ResourceBatchingManager.getInstance().deregisterBatchableResource(RESOURCE_TYPE);
  93     }
  94
  95     /**
  96      * get a translation from prefix ipv6 to afi<br>.
  97      * "ffff::1/128" sets afi as 2 because is an IPv6 value
  98      * @param argPrefix ip address as ipv4 or ipv6
  99      * @return afi 1 for AFI_IP 2 for AFI_IPV6
 100      */
 101     public static int getAFItranslatedfromPrefix(String argPrefix) {
 102         int retValue = af_afi.AFI_IP.getValue();//default afiValue is 1 (= ipv4)
 103         String prefixOnly;
 104         if (!argPrefix.contains("/")) {
 105             prefixOnly = argPrefix;
 106         } else {
 107             prefixOnly = argPrefix.substring(0, argPrefix.indexOf("/"));
 108         }
 109         try {
 110             InetAddress address = InetAddress.getByName(prefixOnly);
 111             if (address instanceof Inet6Address) {
 112                 retValue = af_afi.AFI_IPV6.getValue();
 113             } else if (address instanceof Inet4Address) {
 114                 retValue = af_afi.AFI_IP.getValue();
 115             }
 116         } catch (java.net.UnknownHostException e) {
 117             /*if exception is catched then the prefix is not an IPv6 and IPv4*/
 118             LOG.error("Unrecognized ip address ipAddress: {}", argPrefix);
 119             retValue = af_afi.AFI_IP.getValue();//default afiValue is 1 (= ipv4)
 120         }
 121         return retValue;
 122     }
 123
 124     public <T extends DataObject> void update(final InstanceIdentifier<T> path, final T data) {
 125         ActionableResource actResource = new ActionableResourceImpl(path.toString());
 126         actResource.setAction(ActionableResource.UPDATE);
 127         actResource.setInstanceIdentifier(path);
 128         actResource.setInstance(data);
 129         bgpResourcesBufferQ.add(actResource);
 130     }
 131
 132     public <T extends DataObject> void write(final InstanceIdentifier<T> path, final T data) {
 133         ActionableResource actResource = new ActionableResourceImpl(path.toString());
 134         actResource.setAction(ActionableResource.CREATE);
 135         actResource.setInstanceIdentifier(path);
 136         actResource.setInstance(data);
 137         bgpResourcesBufferQ.add(actResource);
 138     }
 139
 140     public <T extends DataObject> void delete(final InstanceIdentifier<T> path) {
 141         ActionableResource actResource = new ActionableResourceImpl(path.toString());
 142         actResource.setAction(ActionableResource.DELETE);
 143         actResource.setInstanceIdentifier(path);
 144         actResource.setInstance(null);
 145         bgpResourcesBufferQ.add(actResource);
 146     }
 147
 148     // Convert ProtocolType to thrift protocol_type
 149     public static protocol_type convertToThriftProtocolType(BgpControlPlaneType protocolType) {
 150         switch (protocolType) {
 151             case PROTOCOLLU:
 152                 return protocol_type.PROTOCOL_LU;
 153             case PROTOCOLL3VPN:
 154                 return protocol_type.PROTOCOL_L3VPN;
 155             case PROTOCOLEVPN:
 156                 return protocol_type.PROTOCOL_EVPN;
 157             default:
 158                 return protocol_type.PROTOCOL_ANY;
 159         }
 160     }
 161
 162     // Convert EncapType to thrift encap_type
 163     public static encap_type convertToThriftEncapType(EncapType encapType) {
 164         switch (encapType) {
 165             case L2TPV3OVERIP:
 166                 return encap_type.L2TPV3_OVER_IP;
 167             case GRE:
 168                 return encap_type.GRE;
 169             case IPINIP:
 170                 return encap_type.IP_IN_IP;
 171             case VXLAN:
 172                 return encap_type.VXLAN;
 173             case MPLS:
 174             default:
 175                 return encap_type.MPLS;
 176         }
 177     }
 178
 179     public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd)  {
 180         InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
 181         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = MDSALUtil.read(dataBroker,
 182                 LogicalDatastoreType.OPERATIONAL, id);
 183         if (vpnInstanceOpData.isPresent()) {
 184             return vpnInstanceOpData.get();
 185         }
 186         return null;
 187     }
 188
 189     public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 190         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 191                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 192     }
 193
 194     private String getElanNamefromRd(String rd)  {
 195         InstanceIdentifier<EvpnRdToNetwork> id = getEvpnRdToNetworkIdentifier(rd);
 196         Optional<EvpnRdToNetwork> evpnRdToNetworkOpData = MDSALUtil.read(dataBroker,
 197                 LogicalDatastoreType.CONFIGURATION, id);
 198         if (evpnRdToNetworkOpData.isPresent()) {
 199             return evpnRdToNetworkOpData.get().getNetworkId();
 200         }
 201         return null;
 202     }
 203
 204     private static InstanceIdentifier<EvpnRdToNetwork> getEvpnRdToNetworkIdentifier(String rd) {
 205         return InstanceIdentifier.builder(EvpnRdToNetworks.class)
 206                 .child(EvpnRdToNetwork.class, new EvpnRdToNetworkKey(rd)).build();
 207     }
 208
 209     public void addTepToElanInstance(String rd, String tepIp) {
 210         if (rd == null || tepIp == null) {
 211             LOG.error("addTepToElanInstance : Null parameters returning");
 212             return;
 213         }
 214         String elanName = getElanNamefromRd(rd);
 215         if (elanName == null) {
 216             LOG.error("Elan null while processing RT2 for RD {}", rd);
 217             return;
 218         }
 219         LOG.debug("Adding tepIp {} to elan {}", tepIp, elanName);
 220         InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
 221         ExternalTepsBuilder externalTepsBuilder = new ExternalTepsBuilder();
 222         ExternalTepsKey externalTepsKey = externalTepsId.firstKeyOf(ExternalTeps.class);
 223         externalTepsBuilder.setKey(externalTepsKey);
 224         externalTepsBuilder.setTepIp(externalTepsKey.getTepIp());
 225         update(externalTepsId, externalTepsBuilder.build());
 226     }
 227
 228     public void deleteTepFromElanInstance(String rd, String tepIp) {
 229         if (rd == null || tepIp == null) {
 230             LOG.error("deleteTepFromElanInstance : Null parameters returning");
 231             return;
 232         }
 233         String elanName = getElanNamefromRd(rd);
 234         if (elanName == null) {
 235             LOG.error("Elan null while processing RT2 withdraw for RD {}", rd);
 236             return;
 237         }
 238         LOG.debug("Deleting tepIp {} from elan {}", tepIp, elanName);
 239         InstanceIdentifier<ExternalTeps> externalTepsId = getExternalTepsIdentifier(elanName, tepIp);
 240         delete(externalTepsId);
 241     }
 242
 243     private static InstanceIdentifier<ExternalTeps> getExternalTepsIdentifier(String elanInstanceName, String tepIp) {
 244         IpAddress tepAdress = tepIp == null ? null : new IpAddress(tepIp.toCharArray());
 245         return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
 246                 new ElanInstanceKey(elanInstanceName)).child(ExternalTeps.class,
 247                 new ExternalTepsKey(tepAdress)).build();
 248     }
 249
 250     public String getVpnNameFromRd(String rd) {
 251         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
 252         return vpnInstanceOpData != null ? vpnInstanceOpData.getVpnInstanceName() : null;
 253     }
 254
 255     /** get the vrf with the RouterDistinguisher pass in param.
 256      * @param rd is the RouteDistinguisher of vrf
 257      * @return the vrf of rd or null if no exist
 258      */
 259     public Vrfs getVrfFromRd(String rd) {
 260         Vrfs vrfs = null;
 261         KeyedInstanceIdentifier<Vrfs, VrfsKey> id = InstanceIdentifier.create(Bgp.class)
 262                 .child(Vrfs.class, new VrfsKey(rd));
 263         Optional<Vrfs> vrfsFromDs = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 264         if (vrfsFromDs.isPresent()) {
 265             vrfs = vrfsFromDs.get();
 266         }
 267         return vrfs;
 268     }
 269
 270     /** get layerType used from an AddressFamiliesVrf.
 271      * @param adf is the AddressFamiliesVrf from which the layer is asked.
 272      * @return the layerType to reach from the argument addressFamilyVrf or null if not found
 273      */
 274     public static LayerType getLayerType(AddressFamiliesVrf adf) {
 275         LayerType layerTypeValue = null;
 276         if (adf.getSafi() == af_safi.SAFI_EVPN.getValue()) {
 277             layerTypeValue = LayerType.LAYER2;
 278         } else if (adf.getSafi() == af_safi.SAFI_MPLS_VPN.getValue()) {
 279             layerTypeValue = LayerType.LAYER3;
 280         }
 281         return layerTypeValue;
 282     }
 283
 284     public void removeVrfEntry(String rd, VrfEntry vrfEntry) {
 285         LOG.debug("removeVrfEntry : vrf {} prefix {}", rd, vrfEntry.getDestPrefix());
 286         InstanceIdentifier<VrfEntry> vrfEntryId =
 287                    InstanceIdentifier.builder(FibEntries.class)
 288                    .child(VrfTables.class, new VrfTablesKey(rd))
 289                    .child(VrfEntry.class, new VrfEntryKey(vrfEntry.getDestPrefix())).build();
 290         delete(vrfEntryId);
 291     }
 292 }