itm/itm-impl/src/main/java/org/opendaylight/vpnservice/itm/impl/ItmUtils.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.vpnservice.itm.impl;
   9
  10 import java.math.BigInteger;
  11 import java.net.InetAddress;
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.List;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.Future;
  17
  18 import org.apache.commons.lang3.StringUtils;
  19 import org.apache.commons.net.util.SubnetUtils;
  20 import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
  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.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.*;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.DpnEndpoints;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.DpnEndpointsBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfo;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfoBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfoKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.dpn.teps.info.TunnelEndPointsKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnel;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnelBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnelKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.InternalTunnel;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.InternalTunnelBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.InternalTunnelKey;
  49 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  50 import org.opendaylight.vpnservice.itm.globals.ITMConstants;
  51 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  57 //import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice._interface.service.rev150602._interface.service.info.ServiceInfo;
  58 import org.opendaylight.yangtools.yang.binding.DataObject;
  59 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  60 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  62 import org.opendaylight.yangtools.yang.common.RpcResult;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  67 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  68 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  69 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
  70 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
  71 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  72 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  73 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
  74 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  75 import com.google.common.base.Optional;
  76 import com.google.common.base.Preconditions;
  77 import com.google.common.net.InetAddresses;
  78 import com.google.common.util.concurrent.FutureCallback;
  79 import com.google.common.util.concurrent.Futures;
  80
  81 public class ItmUtils {
  82
  83     public static final String DUMMY_IP_ADDRESS = "0.0.0.0";
  84     public static final String TUNNEL_TYPE_VXLAN = "VXLAN";
  85     public static final String TUNNEL_TYPE_GRE = "GRE";
  86     public static final String TUNNEL = "TUNNEL";
  87
  88     private static final Logger LOG = LoggerFactory.getLogger(ItmUtils.class);
  89
  90     public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
  91         public void onSuccess(Void result) {
  92             LOG.debug("Success in Datastore write operation");
  93         }
  94
  95         public void onFailure(Throwable error) {
  96             LOG.error("Error in Datastore write operation", error);
  97         }
  98     };
  99
 100     public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 101                     InstanceIdentifier<T> path, DataBroker broker) {
 102
 103         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 104
 105         Optional<T> result = Optional.absent();
 106         try {
 107             result = tx.read(datastoreType, path).get();
 108         } catch (Exception e) {
 109             throw new RuntimeException(e);
 110         }
 111
 112         return result;
 113     }
 114
 115     public static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
 116                     InstanceIdentifier<T> path, T data, DataBroker broker, FutureCallback<Void> callback) {
 117         WriteTransaction tx = broker.newWriteOnlyTransaction();
 118         tx.put(datastoreType, path, data, true);
 119         Futures.addCallback(tx.submit(), callback);
 120     }
 121
 122     public static <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
 123                     InstanceIdentifier<T> path, T data, DataBroker broker, FutureCallback<Void> callback) {
 124         WriteTransaction tx = broker.newWriteOnlyTransaction();
 125         tx.merge(datastoreType, path, data, true);
 126         Futures.addCallback(tx.submit(), callback);
 127     }
 128
 129     public static <T extends DataObject> void asyncDelete(LogicalDatastoreType datastoreType,
 130                     InstanceIdentifier<T> path, DataBroker broker, FutureCallback<Void> callback) {
 131         WriteTransaction tx = broker.newWriteOnlyTransaction();
 132         tx.delete(datastoreType, path);
 133         Futures.addCallback(tx.submit(), callback);
 134     }
 135
 136     public static String getInterfaceName(final BigInteger datapathid, final String portName, final Integer vlanId) {
 137         return String.format("%s:%s:%s", datapathid, portName, vlanId);
 138     }
 139
 140     public static BigInteger getDpnIdFromInterfaceName(String interfaceName) {
 141         String[] dpnStr = interfaceName.split(":");
 142         BigInteger dpnId = new BigInteger(dpnStr[0]);
 143         return dpnId;
 144     }
 145
 146     public static String getTrunkInterfaceName(IdManagerService idManager, String parentInterfaceName, String localHostName, String remoteHostName) {
 147         String trunkInterfaceName = String.format("%s:%s:%s", parentInterfaceName, localHostName, remoteHostName);
 148         trunkInterfaceName = String.format("%s:%s", TUNNEL, getUniqueId(idManager, trunkInterfaceName));
 149         return trunkInterfaceName;
 150     }
 151
 152     public static void releaseIdForTrunkInterfaceName(IdManagerService idManager, String parentInterfaceName, String localHostName, String remoteHostName) {
 153         String trunkInterfaceName = String.format("%s:%s:%s", parentInterfaceName, localHostName, remoteHostName);
 154         LOG.trace("Releasing Id for trunkInterface - {}", trunkInterfaceName );
 155         releaseId(idManager, trunkInterfaceName) ;
 156     }
 157
 158     public static InetAddress getInetAddressFromIpAddress(IpAddress ip) {
 159         return InetAddresses.forString(ip.getIpv4Address().getValue());
 160     }
 161
 162     public static InstanceIdentifier<DPNTEPsInfo> getDPNTEPInstance(BigInteger dpIdKey) {
 163         InstanceIdentifier.InstanceIdentifierBuilder<DPNTEPsInfo> dpnTepInfoBuilder =
 164                         InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpIdKey));
 165         InstanceIdentifier<DPNTEPsInfo> dpnInfo = dpnTepInfoBuilder.build();
 166         return dpnInfo;
 167     }
 168
 169     public static DPNTEPsInfo createDPNTepInfo(BigInteger dpId, List<TunnelEndPoints> endpoints) {
 170
 171         return new DPNTEPsInfoBuilder().setKey(new DPNTEPsInfoKey(dpId)).setTunnelEndPoints(endpoints).build();
 172     }
 173
 174     public static TunnelEndPoints createTunnelEndPoints(BigInteger dpnId, IpAddress ipAddress, String portName, int vlanId,
 175                     IpPrefix prefix, IpAddress gwAddress, String zoneName, Class<? extends TunnelTypeBase>  tunnel_type) {
 176         // when Interface Mgr provides support to take in Dpn Id
 177         return new TunnelEndPointsBuilder().setKey(new TunnelEndPointsKey(ipAddress, portName, vlanId))
 178                         .setSubnetMask(prefix).setGwIpAddress(gwAddress).setTransportZone(zoneName)
 179                         .setInterfaceName(ItmUtils.getInterfaceName(dpnId, portName, vlanId)).setTunnelType(tunnel_type).build();
 180     }
 181
 182     public static DpnEndpoints createDpnEndpoints(List<DPNTEPsInfo> dpnTepInfo) {
 183         return new DpnEndpointsBuilder().setDPNTEPsInfo(dpnTepInfo).build();
 184     }
 185
 186     public static InstanceIdentifier<Interface> buildId(String interfaceName) {
 187         InstanceIdentifierBuilder<Interface> idBuilder =
 188                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName));
 189         InstanceIdentifier<Interface> id = idBuilder.build();
 190         return id;
 191     }
 192
 193     public static Interface buildTunnelInterface(BigInteger dpn, String ifName, String desc, boolean enabled, Class<? extends TunnelTypeBase> tunType,
 194        IpAddress localIp, IpAddress remoteIp, IpAddress gatewayIp, boolean internal) {
 195        InterfaceBuilder builder = new InterfaceBuilder().setKey(new InterfaceKey(ifName)).setName(ifName)
 196        .setDescription(desc).setEnabled(enabled).setType(Tunnel.class);
 197        ParentRefs parentRefs = new ParentRefsBuilder().setDatapathNodeIdentifier(dpn).build();
 198        builder.addAugmentation(ParentRefs.class, parentRefs);
 199        IfTunnel tunnel = new IfTunnelBuilder().setTunnelDestination(remoteIp).setTunnelGateway(gatewayIp).setTunnelSource(localIp)
 200        .setTunnelInterfaceType( tunType).setInternal(internal).build();
 201        builder.addAugmentation(IfTunnel.class, tunnel);
 202        return builder.build();
 203     }
 204
 205     public static InternalTunnel buildInternalTunnel( BigInteger srcDpnId, BigInteger dstDpnId, String trunkInterfaceName) {
 206         InternalTunnel tnl = new InternalTunnelBuilder().setKey(new InternalTunnelKey(srcDpnId, dstDpnId))
 207             .setDestinationDPN(dstDpnId)
 208             .setSourceDPN(srcDpnId)
 209             .setTunnelInterfaceName(trunkInterfaceName).build();
 210         return tnl ;
 211     }
 212
 213     public static ExternalTunnel buildExternalTunnel( BigInteger srcDpnId, IpAddress dstIp, String trunkInterfaceName) {
 214         ExternalTunnel extTnl = new ExternalTunnelBuilder().setKey(new ExternalTunnelKey(dstIp, srcDpnId)).setSourceDPN(srcDpnId).setDestinationIP(dstIp).setTunnelInterfaceName(trunkInterfaceName).build();
 215         return extTnl ;
 216     }
 217
 218     public static List<DPNTEPsInfo> getTunnelMeshInfo(DataBroker dataBroker) {
 219         List<DPNTEPsInfo> dpnTEPs= null ;
 220
 221         // Read the EndPoint Info from the operational database
 222         InstanceIdentifierBuilder<DpnEndpoints> depBuilder = InstanceIdentifier.builder( DpnEndpoints.class) ;
 223         InstanceIdentifier<DpnEndpoints> deps = depBuilder.build() ;
 224         Optional<DpnEndpoints> dpnEps = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, deps, dataBroker);
 225         if( dpnEps.isPresent()) {
 226            DpnEndpoints tn= dpnEps.get() ;
 227            dpnTEPs = tn.getDPNTEPsInfo() ;
 228            LOG.debug( "Read from CONFIGURATION datastore - No. of Dpns " , dpnTEPs.size() );
 229         }else
 230             LOG.debug( "No Dpn information in CONFIGURATION datastore "  );
 231          return dpnTEPs ;
 232     }
 233
 234     public static int getUniqueId(IdManagerService idManager, String idKey) {
 235         AllocateIdInput getIdInput = new AllocateIdInputBuilder()
 236             .setPoolName(ITMConstants.ITM_IDPOOL_NAME)
 237             .setIdKey(idKey).build();
 238
 239         try {
 240             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 241             RpcResult<AllocateIdOutput> rpcResult = result.get();
 242             if(rpcResult.isSuccessful()) {
 243                 return rpcResult.getResult().getIdValue().intValue();
 244             } else {
 245                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 246             }
 247         } catch (InterruptedException | ExecutionException e) {
 248             LOG.warn("Exception when getting Unique Id",e);
 249         }
 250         return 0;
 251     }
 252
 253     public static void releaseId(IdManagerService idManager, String idKey) {
 254         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(ITMConstants.ITM_IDPOOL_NAME).setIdKey(idKey).build();
 255         try {
 256             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
 257             RpcResult<Void> rpcResult = result.get();
 258             if(!rpcResult.isSuccessful()) {
 259                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 260             }
 261         } catch (InterruptedException | ExecutionException e) {
 262             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
 263         }
 264     }
 265
 266     public static List<DPNTEPsInfo> getDPNTEPListFromDPNId(DataBroker dataBroker, List<BigInteger> dpnIds) {
 267         List<DPNTEPsInfo> meshedDpnList = getTunnelMeshInfo(dataBroker) ;
 268         List<DPNTEPsInfo> cfgDpnList = new ArrayList<DPNTEPsInfo>();
 269         if( null != meshedDpnList) {
 270            for(BigInteger dpnId : dpnIds) {
 271               for( DPNTEPsInfo teps : meshedDpnList ) {
 272                  if( dpnId.equals(teps.getDPNID()))
 273                  cfgDpnList.add( teps) ;
 274               }
 275             }
 276         }
 277         return cfgDpnList;
 278     }
 279
 280     public static void setUpOrRemoveTerminatingServiceTable(BigInteger dpnId, IMdsalApiManager mdsalManager, boolean addFlag) {
 281         String logmsg = ( addFlag == true) ? "Installing" : "Removing";
 282         LOG.trace( logmsg + " PUNT to Controller flow in DPN {} ", dpnId );
 283         long dpId;
 284         List<ActionInfo> listActionInfo = new ArrayList<ActionInfo>();
 285         listActionInfo.add(new ActionInfo(ActionType.punt_to_controller,
 286                 new String[] {}));
 287
 288         try {
 289             List<MatchInfo> mkMatches = new ArrayList<MatchInfo>();
 290
 291             mkMatches.add(new MatchInfo(MatchFieldType.tunnel_id, new BigInteger[] {
 292                     BigInteger.valueOf(ITMConstants.LLDP_SERVICE_ID) }));
 293
 294             List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
 295             mkInstructions.add(new InstructionInfo(InstructionType.apply_actions,
 296                    listActionInfo));
 297
 298             FlowEntity terminatingServiceTableFlowEntity = MDSALUtil
 299                     .buildFlowEntity(
 300                              dpnId,
 301                              NwConstants.INTERNAL_TUNNEL_TABLE,
 302                             getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,
 303                                    ITMConstants.LLDP_SERVICE_ID), 5, String.format("%s:%d","ITM Flow Entry ",ITMConstants.LLDP_SERVICE_ID),
 304                             0, 0, ITMConstants.COOKIE_ITM
 305                                     .add(BigInteger.valueOf(ITMConstants.LLDP_SERVICE_ID)),
 306                                     mkMatches, mkInstructions);
 307             if(addFlag)
 308                 mdsalManager.installFlow(terminatingServiceTableFlowEntity);
 309             else
 310                 mdsalManager.removeFlow(terminatingServiceTableFlowEntity);
 311         } catch (Exception e) {
 312             LOG.error("Error while setting up Table 36 for {}", dpnId, e);
 313         }
 314     }
 315
 316     private static String getFlowRef(long termSvcTable, int svcId) {
 317         return new StringBuffer().append(termSvcTable).append(svcId).toString();
 318     }
 319 }