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