50c5eef4a4d64fac607934655cb18a3b8225d919
[vpnservice.git] / vpnmanager / vpnmanager-impl / src / main / java / org / opendaylight / vpnservice / VpnUtil.java
1 /*
2  * Copyright (c) 2015 - 2016 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
9 package org.opendaylight.vpnservice;
10
11 import java.math.BigInteger;
12 import java.net.InetAddress;
13 import java.util.concurrent.ExecutionException;
14 import java.util.concurrent.Future;
15 import java.util.List;
16
17 import com.google.common.base.Optional;
18 import com.google.common.primitives.Ints;
19 import com.google.common.util.concurrent.CheckedFuture;
20 import com.google.common.util.concurrent.FutureCallback;
21 import com.google.common.util.concurrent.Futures;
22
23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
27 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
28 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
29 import org.opendaylight.vpnservice.mdsalutil.packet.ARP;
30 import org.opendaylight.vpnservice.mdsalutil.packet.Ethernet;
31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
33 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
34 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
35 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
36 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
37 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.*;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.VpnIds;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.Vpn;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.VpnKey;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.Extraroute;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteKey;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.ElanDpnInterfaces;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdPools;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.IfIndexesInterfaceMap;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterface;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterfaceKey;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthop;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.VpnNexthops;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronPortData;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortName;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortNameKey;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.tag.name.map.ElanTagName;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.ElanTagNameMap;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
88 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
89 import org.opendaylight.yangtools.yang.common.RpcResult;
90 import org.opendaylight.yangtools.yang.binding.DataObject;
91 import org.slf4j.Logger;
92 import org.slf4j.LoggerFactory;
93
94 public class VpnUtil {
95     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
96     private static final int DEFAULT_PREFIX_LENGTH = 32;
97     private static final String PREFIX_SEPARATOR = "/";
98
99     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
100         return InstanceIdentifier.builder(VpnInterfaces.class)
101                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
102     }
103
104     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
105         return InstanceIdentifier.builder(VpnInstances.class)
106                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
107     }
108
109     static VpnInterface getVpnInterface(String intfName, String vpnName, Adjacencies aug) {
110         return new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(intfName)).setVpnInstanceName(vpnName)
111                 .addAugmentation(Adjacencies.class, aug)
112                 .build();
113     }
114
115     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
116         return InstanceIdentifier.builder(PrefixToInterface.class)
117             .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
118                                                              new PrefixesKey(ipPrefix)).build();
119     }
120
121     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix) {
122         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
123             vpnInterfaceName).setIpAddress(ipPrefix).build();
124     }
125
126     static InstanceIdentifier<Extraroute> getVpnToExtrarouteIdentifier(String vrfId, String ipPrefix) {
127         return InstanceIdentifier.builder(VpnToExtraroute.class)
128                 .child(Vpn.class, new VpnKey(vrfId)).child(Extraroute.class,
129                  new ExtrarouteKey(ipPrefix)).build();
130     }
131
132     static Extraroute getVpnToExtraroute(String ipPrefix, String nextHop) {
133         return new ExtrarouteBuilder().setPrefix(ipPrefix).setNexthopIp(nextHop).build();
134     }
135
136     static Adjacencies
137     getVpnInterfaceAugmentation(List<Adjacency> nextHops) {
138         return new AdjacenciesBuilder().setAdjacency(nextHops).build();
139     }
140
141     public static InstanceIdentifier<IdPool> getPoolId(String poolName){
142         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
143                         InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
144         InstanceIdentifier<IdPool> id = idBuilder.build();
145         return id;
146     }
147
148     static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
149         return InstanceIdentifier.builder(VpnInterfaces.class).build();
150     }
151
152     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
153         return InstanceIdentifier.builder(Interfaces.class)
154                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
155     }
156
157     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
158         return InstanceIdentifier.builder(VpnInstanceOpData.class)
159             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
160             .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
161     }
162
163     public static BigInteger getCookieArpFlow(int interfaceTag) {
164         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
165             BigInteger.valueOf(interfaceTag));
166     }
167
168     public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lPortTag, int arpType) {
169             return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
170                     .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lPortTag)
171                     .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
172     }
173
174     public static int getUniqueId(IdManagerService idManager, String poolName,String idKey) {
175         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
176                                            .setPoolName(poolName)
177                                            .setIdKey(idKey).build();
178
179         try {
180             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
181             RpcResult<AllocateIdOutput> rpcResult = result.get();
182             if(rpcResult.isSuccessful()) {
183                 return rpcResult.getResult().getIdValue().intValue();
184             } else {
185                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
186             }
187         } catch (InterruptedException | ExecutionException e) {
188             LOG.warn("Exception when getting Unique Id",e);
189         }
190         return 0;
191     }
192
193     public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
194         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
195         try {
196             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
197             RpcResult<Void> rpcResult = result.get();
198             if(!rpcResult.isSuccessful()) {
199                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
200             }
201         } catch (InterruptedException | ExecutionException e) {
202             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
203         }
204     }
205
206     public static String getNextHopLabelKey(String rd, String prefix){
207         String key = rd + VpnConstants.SEPARATOR + prefix;
208         return key;
209     }
210
211     public static long getVpnId(DataBroker broker, String vpnName) {
212
213         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
214             = getVpnInstanceToVpnIdIdentifier(vpnName);
215         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
216             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
217
218         long vpnId = VpnConstants.INVALID_ID;
219         if(vpnInstance.isPresent()) {
220             vpnId = vpnInstance.get().getVpnId();
221         }
222         return vpnId;
223     }
224
225     public static String getVpnRd(DataBroker broker, String vpnName) {
226
227         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
228                 = getVpnInstanceToVpnIdIdentifier(vpnName);
229         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
230                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
231
232         String rd = null;
233         if(vpnInstance.isPresent()) {
234             rd = vpnInstance.get().getVrfId();
235         }
236         return rd;
237     }
238
239     static org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
240            getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
241         return new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder()
242             .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
243
244     }
245
246     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
247            getVpnInstanceToVpnIdIdentifier(String vpnName) {
248         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
249             .child(org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
250                    new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
251     }
252
253     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
254         return InstanceIdentifier.builder(VpnInstanceOpData.class)
255             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
256     }
257
258     static VpnInstanceOpDataEntry getVpnInstanceOpDataBuilder(String rd, long vpnId) {
259         return new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).build();
260     }
261
262     static VpnInstanceOpDataEntry updateIntfCntInVpnInstOpData(Long count, String vrfId) {
263         return new VpnInstanceOpDataEntryBuilder().setVpnInterfaceCount(count).setVrfId(vrfId).build();
264     }
265
266     static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
267         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
268         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
269         if(vpnInstanceOpData.isPresent()) {
270             return vpnInstanceOpData.get();
271         }
272         return null;
273     }
274
275     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
276         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
277         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
278
279         if (configuredVpnInterface.isPresent()) {
280             return configuredVpnInterface.get();
281         }
282         return null;
283     }
284
285     static VpnInterface getOperationalVpnInterface(DataBroker broker, String interfaceName) {
286         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
287         Optional<VpnInterface> operationalVpnInterface = read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
288
289         if (operationalVpnInterface.isPresent()) {
290             return operationalVpnInterface.get();
291         }
292         return null;
293     }
294
295     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName)
296     {
297         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
298         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
299
300         if (configuredVpnInterface.isPresent()) {
301             return true;
302         }
303         return false;
304     }
305
306     static String getIpPrefix(String prefix) {
307         String prefixValues[] = prefix.split("/");
308         if (prefixValues.length == 1) {
309             prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH ;
310         }
311         return prefix;
312     }
313
314     static final FutureCallback<Void> DEFAULT_CALLBACK =
315             new FutureCallback<Void>() {
316                 public void onSuccess(Void result) {
317                     LOG.debug("Success in Datastore operation");
318                 }
319
320                 public void onFailure(Throwable error) {
321                     LOG.error("Error in Datastore operation", error);
322                 };
323             };
324
325     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
326                                                     InstanceIdentifier<T> path) {
327
328         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
329
330         Optional<T> result = Optional.absent();
331         try {
332             result = tx.read(datastoreType, path).get();
333         } catch (Exception e) {
334             throw new RuntimeException(e);
335         } finally {
336             tx.close();
337         }
338
339         return result;
340     }
341
342     static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
343                                                       InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
344         WriteTransaction tx = broker.newWriteOnlyTransaction();
345         tx.merge(datastoreType, path, data, true);
346         Futures.addCallback(tx.submit(), callback);
347     }
348
349     static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
350                                                    InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
351         WriteTransaction tx = broker.newWriteOnlyTransaction();
352         tx.put(datastoreType, path, data, true);
353         Futures.addCallback(tx.submit(), callback);
354     }
355
356     static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
357                                                InstanceIdentifier<T> path, FutureCallback<Void> callback) {
358         WriteTransaction tx = broker.newWriteOnlyTransaction();
359         tx.delete(datastoreType, path);
360         Futures.addCallback(tx.submit(), callback);
361     }
362
363     public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
364                     InstanceIdentifier<T> path, T data) {
365         WriteTransaction tx = broker.newWriteOnlyTransaction();
366         tx.put(datastoreType, path, data, true);
367         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
368         try {
369             futures.get();
370         } catch (InterruptedException | ExecutionException e) {
371             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
372             throw new RuntimeException(e.getMessage());
373         }
374     }
375
376     public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
377                     InstanceIdentifier<T> path, T data) {
378         WriteTransaction tx = broker.newWriteOnlyTransaction();
379         tx.merge(datastoreType, path, data, true);
380         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
381         try {
382             futures.get();
383         } catch (InterruptedException | ExecutionException e) {
384             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
385             throw new RuntimeException(e.getMessage());
386         }
387     }
388
389     public static long getRemoteBCGroup(long elanTag) {
390         return VpnConstants.ELAN_GID_MIN + ((elanTag % VpnConstants.ELAN_GID_MIN) *2);
391     }
392
393     // interface-index-tag operational container
394     public static IfIndexInterface getInterfaceInfoByInterfaceTag(DataBroker broker, long interfaceTag) {
395         InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
396         Optional<IfIndexInterface> existingInterfaceInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
397         if(existingInterfaceInfo.isPresent()) {
398             return existingInterfaceInfo.get();
399         }
400         return null;
401     }
402
403     private static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
404         return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
405                 new IfIndexInterfaceKey((int) interfaceTag)).build();
406     }
407
408     public static String getNeutronPortNamefromPortFixedIp(DataBroker broker, String fixedIp) {
409         InstanceIdentifier id = buildFixedIpToPortNameIdentifier(fixedIp);
410         Optional<PortFixedipToPortName> portFixedipToPortNameData = read(broker, LogicalDatastoreType.CONFIGURATION,
411                 id);
412         if (portFixedipToPortNameData.isPresent()) {
413             return portFixedipToPortNameData.get().getPortName();
414         }
415         return null;
416     }
417
418     private static InstanceIdentifier<PortFixedipToPortName> buildFixedIpToPortNameIdentifier(String fixedIp) {
419         InstanceIdentifier<PortFixedipToPortName> id = InstanceIdentifier.builder(NeutronPortData.class).child
420                 (PortFixedipToPortName.class, new PortFixedipToPortNameKey(fixedIp)).build();
421         return id;
422     }
423
424     public static ElanTagName getElanInfoByElanTag(DataBroker broker,long elanTag) {
425         InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
426         Optional<ElanTagName> existingElanInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanId);
427         if(existingElanInfo.isPresent()) {
428             return existingElanInfo.get();
429         }
430         return null;
431     }
432
433     private static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
434         return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
435                 new ElanTagNameKey(elanTag)).build();
436     }
437
438
439     public static boolean isIpInSubnet(int ipAddress, String subnetCidr) {
440         String[] subSplit = subnetCidr.split("/");
441         LOG.trace("SubnetRoutePacketInHandler: Viewing Subnet Split " + subSplit);
442         if (subSplit.length < 2) {
443             return false;
444         }
445
446         String subnetStr = subSplit[0];
447         int subnet = 0;
448         try {
449             InetAddress subnetAddress = InetAddress.getByName(subnetStr);
450             subnet = Ints.fromByteArray(subnetAddress.getAddress());
451         } catch (Exception ex) {
452             LOG.error("Passed in Subnet IP string not convertible to InetAdddress " + subnetStr);
453             return false;
454         }
455         int prefixLength = Integer.valueOf(subSplit[1]);
456         int mask = -1 << (32 - prefixLength);
457         LOG.trace("SubnetRoutePacketInHandler: prefixLength " + prefixLength + " mask " + mask);
458         LOG.trace("SubnetRoutePacketInHandler: subnet & mask " + (subnet & mask));
459         LOG.trace("SubnetRoutePacketInHandler: subnet & mask " + (ipAddress & mask));
460         if ((subnet & mask) == (ipAddress & mask)) {
461             return true;
462         }
463         return false;
464     }
465
466     public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId) {
467         try {
468             // Clean up PrefixToInterface Operational DS
469             delete(broker, LogicalDatastoreType.OPERATIONAL,
470                     InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build(),
471                     DEFAULT_CALLBACK);
472         } catch (Exception e) {
473             LOG.error("Exception during cleanup of PrefixToInterface for VPN ID {}", vpnId, e);
474         }
475     }
476
477     public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName) {
478         try {
479             // Clean up VPNExtraRoutes Operational DS
480             delete(broker, LogicalDatastoreType.OPERATIONAL,
481                     InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnName)).build(),
482                     DEFAULT_CALLBACK);
483         } catch (Exception e) {
484             LOG.error("Exception during cleanup of VPNToExtraRoute for VPN {}", vpnName, e);
485         }
486     }
487
488     public static void removeVpnOpInstance(DataBroker broker, String vpnName) {
489         try {
490             // Clean up VPNInstanceOpDataEntry
491             delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
492                     DEFAULT_CALLBACK);
493         } catch (Exception e) {
494             LOG.error("Exception during cleanup of VPNInstanceOpDataEntry for VPN {}", vpnName, e);
495         }
496     }
497
498     public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName) {
499         try {
500             delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName),
501                     DEFAULT_CALLBACK);
502         } catch (Exception e) {
503             LOG.error("Exception during clean up of VpnInstanceToVpnId for VPN {}", vpnName, e);
504         }
505     }
506
507     public static void removeVrfTableForVpn(DataBroker broker, String vpnName) {
508         // Clean up FIB Entries Config DS
509         try {
510             delete(broker, LogicalDatastoreType.CONFIGURATION,
511                     InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(vpnName)).build(),
512                     DEFAULT_CALLBACK);
513         } catch (Exception e) {
514             LOG.error("Exception during clean up of VrfTable from FIB for VPN {}", vpnName, e);
515         }
516     }
517
518     public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId) {
519         try {
520             // Clean up L3NextHop Operational DS
521             delete(broker, LogicalDatastoreType.OPERATIONAL,
522                     InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build(),
523                     DEFAULT_CALLBACK);
524         } catch (Exception e) {
525             LOG.error("Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
526         }
527     }
528 }