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.util.concurrent.ExecutionException;
  13 import java.util.concurrent.Future;
  14 import java.util.List;
  15
  16 import com.google.common.base.Optional;
  17 import com.google.common.util.concurrent.CheckedFuture;
  18 import com.google.common.util.concurrent.FutureCallback;
  19 import com.google.common.util.concurrent.Futures;
  20
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  23 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  24 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  25 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  26 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  27 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  28 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  33 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.*;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.VpnIds;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.Vpn;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.VpnKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.Extraroute;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteKey;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdPools;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  65 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  66 import org.opendaylight.yangtools.yang.common.RpcResult;
  67 import org.opendaylight.yangtools.yang.binding.DataObject;
  68 import org.slf4j.Logger;
  69 import org.slf4j.LoggerFactory;
  70
  71 public class VpnUtil {
  72     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
  73     private static final int DEFAULT_PREFIX_LENGTH = 32;
  74     private static final String PREFIX_SEPARATOR = "/";
  75
  76     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
  77         return InstanceIdentifier.builder(VpnInterfaces.class)
  78                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
  79     }
  80
  81     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
  82         return InstanceIdentifier.builder(VpnInstances.class)
  83                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
  84     }
  85
  86     static VpnInterface getVpnInterface(String intfName, String vpnName, Adjacencies aug, boolean opState) {
  87         return new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(intfName)).setVpnInstanceName(vpnName)
  88                 .addAugmentation(Adjacencies.class, aug)
  89                 .addAugmentation(OpState.class, new OpStateBuilder().setStateUp(opState).build())
  90                 .build();
  91     }
  92
  93     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
  94         return InstanceIdentifier.builder(PrefixToInterface.class)
  95             .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
  96                                                              new PrefixesKey(ipPrefix)).build();
  97     }
  98
  99     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix) {
 100         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
 101             vpnInterfaceName).setIpAddress(ipPrefix).build();
 102     }
 103
 104     static InstanceIdentifier<Extraroute> getVpnToExtrarouteIdentifier(String vrfId, String ipPrefix) {
 105         return InstanceIdentifier.builder(VpnToExtraroute.class)
 106                 .child(Vpn.class, new VpnKey(vrfId)).child(Extraroute.class,
 107                  new ExtrarouteKey(ipPrefix)).build();
 108     }
 109
 110     static Extraroute getVpnToExtraroute(String ipPrefix, String nextHop) {
 111         return new ExtrarouteBuilder().setPrefix(ipPrefix).setNexthopIp(nextHop).build();
 112     }
 113
 114     static Adjacencies
 115     getVpnInterfaceAugmentation(List<Adjacency> nextHops) {
 116         return new AdjacenciesBuilder().setAdjacency(nextHops).build();
 117     }
 118
 119     public static InstanceIdentifier<IdPool> getPoolId(String poolName){
 120         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 121                         InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 122         InstanceIdentifier<IdPool> id = idBuilder.build();
 123         return id;
 124     }
 125
 126     static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
 127         return InstanceIdentifier.builder(VpnInterfaces.class).build();
 128     }
 129
 130     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 131         return InstanceIdentifier.builder(Interfaces.class)
 132                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
 133     }
 134
 135     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
 136         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 137             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
 138             .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
 139     }
 140
 141     public static BigInteger getCookieArpFlow(int interfaceTag) {
 142         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
 143             BigInteger.valueOf(interfaceTag));
 144     }
 145
 146     public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lPortTag, int arpType) {
 147             return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 148                     .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lPortTag)
 149                     .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
 150     }
 151
 152     public static int getUniqueId(IdManagerService idManager, String poolName,String idKey) {
 153         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
 154                                            .setPoolName(poolName)
 155                                            .setIdKey(idKey).build();
 156
 157         try {
 158             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 159             RpcResult<AllocateIdOutput> rpcResult = result.get();
 160             if(rpcResult.isSuccessful()) {
 161                 return rpcResult.getResult().getIdValue().intValue();
 162             } else {
 163                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 164             }
 165         } catch (InterruptedException | ExecutionException e) {
 166             LOG.warn("Exception when getting Unique Id",e);
 167         }
 168         return 0;
 169     }
 170
 171     public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
 172         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 173         try {
 174             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
 175             RpcResult<Void> rpcResult = result.get();
 176             if(!rpcResult.isSuccessful()) {
 177                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 178             }
 179         } catch (InterruptedException | ExecutionException e) {
 180             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
 181         }
 182     }
 183
 184     public static String getNextHopLabelKey(String rd, String prefix){
 185         String key = rd + VpnConstants.SEPARATOR + prefix;
 186         return key;
 187     }
 188
 189     public static long getVpnId(DataBroker broker, String vpnName) {
 190
 191         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 192             = getVpnInstanceToVpnIdIdentifier(vpnName);
 193         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 194             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 195
 196         long vpnId = VpnConstants.INVALID_ID;
 197         if(vpnInstance.isPresent()) {
 198             vpnId = vpnInstance.get().getVpnId();
 199         }
 200         return vpnId;
 201     }
 202
 203     public static String getVpnRd(DataBroker broker, String vpnName) {
 204
 205         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 206                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 207         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 208                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 209
 210         String rd = null;
 211         if(vpnInstance.isPresent()) {
 212             rd = vpnInstance.get().getVrfId();
 213         }
 214         return rd;
 215     }
 216
 217     static org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
 218            getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
 219         return new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder()
 220             .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
 221
 222     }
 223
 224     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
 225            getVpnInstanceToVpnIdIdentifier(String vpnName) {
 226         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 227             .child(org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
 228                    new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
 229     }
 230
 231     static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 232         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 233             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 234     }
 235
 236     static VpnInstanceOpDataEntry getVpnInstanceOpDataBuilder(String rd, long vpnId) {
 237         return new VpnInstanceOpDataEntryBuilder().setVrfId(rd).setVpnId(vpnId).build();
 238     }
 239
 240     static VpnInstanceOpDataEntry updateIntfCntInVpnInstOpData(Long count, String vrfId) {
 241         return new VpnInstanceOpDataEntryBuilder().setVpnInterfaceCount(count).setVrfId(vrfId).build();
 242     }
 243
 244     static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
 245         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
 246         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
 247         if(vpnInstanceOpData.isPresent()) {
 248             return vpnInstanceOpData.get();
 249         }
 250         return null;
 251     }
 252
 253     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
 254         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 255         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 256
 257         if (configuredVpnInterface.isPresent()) {
 258             return configuredVpnInterface.get();
 259         }
 260         return null;
 261     }
 262
 263     static VpnInterface getOperationalVpnInterface(DataBroker broker, String interfaceName) {
 264         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 265         Optional<VpnInterface> operationalVpnInterface = read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 266
 267         if (operationalVpnInterface.isPresent()) {
 268             return operationalVpnInterface.get();
 269         }
 270         return null;
 271     }
 272
 273     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName)
 274     {
 275         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 276         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 277
 278         if (configuredVpnInterface.isPresent()) {
 279             return true;
 280         }
 281         return false;
 282     }
 283
 284     static String getIpPrefix(String prefix) {
 285         String prefixValues[] = prefix.split("/");
 286         if (prefixValues.length == 1) {
 287             prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH ;
 288         }
 289         return prefix;
 290     }
 291
 292     static final FutureCallback<Void> DEFAULT_CALLBACK =
 293             new FutureCallback<Void>() {
 294                 public void onSuccess(Void result) {
 295                     LOG.debug("Success in Datastore operation");
 296                 }
 297
 298                 public void onFailure(Throwable error) {
 299                     LOG.error("Error in Datastore operation", error);
 300                 };
 301             };
 302
 303     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 304                                                     InstanceIdentifier<T> path) {
 305
 306         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 307
 308         Optional<T> result = Optional.absent();
 309         try {
 310             result = tx.read(datastoreType, path).get();
 311         } catch (Exception e) {
 312             throw new RuntimeException(e);
 313         }
 314
 315         return result;
 316     }
 317
 318     static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 319                                                       InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 320         WriteTransaction tx = broker.newWriteOnlyTransaction();
 321         tx.merge(datastoreType, path, data, true);
 322         Futures.addCallback(tx.submit(), callback);
 323     }
 324
 325     static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 326                                                    InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 327         WriteTransaction tx = broker.newWriteOnlyTransaction();
 328         tx.put(datastoreType, path, data, true);
 329         Futures.addCallback(tx.submit(), callback);
 330     }
 331
 332     static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 333                                                InstanceIdentifier<T> path, FutureCallback<Void> callback) {
 334         WriteTransaction tx = broker.newWriteOnlyTransaction();
 335         tx.delete(datastoreType, path);
 336         Futures.addCallback(tx.submit(), callback);
 337     }
 338
 339     public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 340                     InstanceIdentifier<T> path, T data) {
 341         WriteTransaction tx = broker.newWriteOnlyTransaction();
 342         tx.put(datastoreType, path, data, true);
 343         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 344         try {
 345             futures.get();
 346         } catch (InterruptedException | ExecutionException e) {
 347             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 348             throw new RuntimeException(e.getMessage());
 349         }
 350     }
 351
 352     public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 353                     InstanceIdentifier<T> path, T data) {
 354         WriteTransaction tx = broker.newWriteOnlyTransaction();
 355         tx.merge(datastoreType, path, data, true);
 356         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 357         try {
 358             futures.get();
 359         } catch (InterruptedException | ExecutionException e) {
 360             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 361             throw new RuntimeException(e.getMessage());
 362         }
 363     }
 364
 365 }