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
  16 import org.apache.commons.lang3.StringUtils;
  17 import org.apache.commons.net.util.SubnetUtils;
  18 import org.apache.commons.net.util.SubnetUtils.SubnetInfo;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.*;
  27 import org.opendaylight.vpnservice.itm.globals.ITMConstants;
  28 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.Tunnels;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.TunnelsBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.DPNTEPsInfo;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.DPNTEPsInfoBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.DPNTEPsInfoKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.dpn.teps.info.TunnelEndPoints;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.dpn.teps.info.TunnelEndPointsBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels.dpn.teps.info.TunnelEndPointsKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.itm.op.rev150701.tunnels_state.StateTunnelListKey;
  43 //import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice._interface.service.rev150602._interface.service.info.ServiceInfo;
  44 import org.opendaylight.yangtools.yang.binding.DataObject;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import com.google.common.base.Optional;
  52 import com.google.common.base.Preconditions;
  53 import com.google.common.net.InetAddresses;
  54 import com.google.common.util.concurrent.FutureCallback;
  55 import com.google.common.util.concurrent.Futures;
  56
  57 public class ItmUtils {
  58
  59     public static final String DUMMY_IP_ADDRESS = "0.0.0.0";
  60     public static final String TUNNEL_TYPE_VXLAN = "VXLAN";
  61     public static final String TUNNEL_TYPE_GRE = "GRE";
  62
  63     private static final Logger LOG = LoggerFactory.getLogger(ItmUtils.class);
  64
  65     public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
  66         public void onSuccess(Void result) {
  67             LOG.debug("Success in Datastore write operation");
  68         }
  69
  70         public void onFailure(Throwable error) {
  71             LOG.error("Error in Datastore write operation", error);
  72         }
  73     };
  74
  75     public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
  76                     InstanceIdentifier<T> path, DataBroker broker) {
  77
  78         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
  79
  80         Optional<T> result = Optional.absent();
  81         try {
  82             result = tx.read(datastoreType, path).get();
  83         } catch (Exception e) {
  84             throw new RuntimeException(e);
  85         }
  86
  87         return result;
  88     }
  89
  90     public static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
  91                     InstanceIdentifier<T> path, T data, DataBroker broker, FutureCallback<Void> callback) {
  92         WriteTransaction tx = broker.newWriteOnlyTransaction();
  93         tx.put(datastoreType, path, data, true);
  94         Futures.addCallback(tx.submit(), callback);
  95     }
  96
  97     public static <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
  98                     InstanceIdentifier<T> path, T data, DataBroker broker, FutureCallback<Void> callback) {
  99         WriteTransaction tx = broker.newWriteOnlyTransaction();
 100         tx.merge(datastoreType, path, data, true);
 101         Futures.addCallback(tx.submit(), callback);
 102     }
 103
 104     public static <T extends DataObject> void asyncDelete(LogicalDatastoreType datastoreType,
 105                     InstanceIdentifier<T> path, DataBroker broker, FutureCallback<Void> callback) {
 106         WriteTransaction tx = broker.newWriteOnlyTransaction();
 107         tx.delete(datastoreType, path);
 108         Futures.addCallback(tx.submit(), callback);
 109     }
 110
 111     public static String getInterfaceName(final BigInteger datapathid, final String portName, final Integer vlanId) {
 112         return String.format("%s:%s:%s", datapathid, portName, vlanId);
 113     }
 114
 115     public static BigInteger getDpnIdFromInterfaceName(String interfaceName) {
 116         String[] dpnStr = interfaceName.split(":");
 117         BigInteger dpnId = new BigInteger(dpnStr[0]);
 118         return dpnId;
 119     }
 120
 121     public static String getTrunkInterfaceName(String parentInterfaceName, String localHostName, String remoteHostName) {
 122         String trunkInterfaceName = String.format("%s:%s:%s", parentInterfaceName, localHostName, remoteHostName);
 123         return trunkInterfaceName;
 124     }
 125
 126     public static InetAddress getInetAddressFromIpAddress(IpAddress ip) {
 127         return InetAddresses.forString(ip.getIpv4Address().getValue());
 128     }
 129
 130     public static InstanceIdentifier<DPNTEPsInfo> getDPNTEPInstance(BigInteger dpIdKey) {
 131         InstanceIdentifier.InstanceIdentifierBuilder<DPNTEPsInfo> dpnTepInfoBuilder =
 132                         InstanceIdentifier.builder(Tunnels.class).child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpIdKey));
 133         InstanceIdentifier<DPNTEPsInfo> dpnInfo = dpnTepInfoBuilder.build();
 134         return dpnInfo;
 135     }
 136
 137     public static DPNTEPsInfo createDPNTepInfo(BigInteger dpId, List<TunnelEndPoints> endpoints) {
 138
 139         return new DPNTEPsInfoBuilder().setKey(new DPNTEPsInfoKey(dpId)).setTunnelEndPoints(endpoints).build();
 140     }
 141
 142     public static TunnelEndPoints createTunnelEndPoints(BigInteger dpnId, IpAddress ipAddress, String portName, int vlanId,
 143                     IpPrefix prefix, IpAddress gwAddress, String zoneName, String  tunnel_type) {
 144         // when Interface Mgr provides support to take in Dpn Id
 145         return new TunnelEndPointsBuilder().setKey(new TunnelEndPointsKey(ipAddress, portName, vlanId))
 146                         .setSubnetMask(prefix).setGwIpAddress(gwAddress).setTransportZone(zoneName)
 147                         .setInterfaceName(ItmUtils.getInterfaceName(dpnId, portName, vlanId)).setTunnelType(tunnel_type).build();
 148     }
 149
 150     public static Tunnels createTunnel(List<DPNTEPsInfo> dpnTepInfo) {
 151         return new TunnelsBuilder().setDPNTEPsInfo(dpnTepInfo).build();
 152     }
 153
 154     public static InstanceIdentifier<Interface> buildId(String interfaceName) {
 155         InstanceIdentifierBuilder<Interface> idBuilder =
 156                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName));
 157         InstanceIdentifier<Interface> id = idBuilder.build();
 158         return id;
 159     }
 160
 161     public static Interface buildTunnelInterface(BigInteger dpn, String ifName, String desc, boolean enabled, Class<? extends TunnelTypeBase> tunType,
 162        IpAddress localIp, IpAddress remoteIp, IpAddress gatewayIp) {
 163        InterfaceBuilder builder = new InterfaceBuilder().setKey(new InterfaceKey(ifName)).setName(ifName)
 164        .setDescription(desc).setEnabled(enabled).setType(Tunnel.class);
 165        ParentRefs parentRefs = new ParentRefsBuilder().setDatapathNodeIdentifier(dpn).build();
 166        builder.addAugmentation(ParentRefs.class, parentRefs);
 167        IfTunnel tunnel = new IfTunnelBuilder().setTunnelDestination(remoteIp).setTunnelGateway(gatewayIp).setTunnelSource(localIp)
 168        .setTunnelInterfaceType( tunType).build();
 169        builder.addAugmentation(IfTunnel.class, tunnel);
 170        return builder.build();
 171     }
 172
 173     public static List<DPNTEPsInfo> getTunnelMeshInfo(DataBroker dataBroker) {
 174         List<DPNTEPsInfo> dpnTEPs= null ;
 175
 176         // Read the EndPoint Info from the operational database
 177         InstanceIdentifierBuilder<Tunnels> tnlBuilder = InstanceIdentifier.builder( Tunnels.class) ;
 178         InstanceIdentifier<Tunnels> tnls = tnlBuilder.build() ;
 179         Optional<Tunnels> tunnels = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tnls, dataBroker);
 180         if( tunnels.isPresent()) {
 181            Tunnels tn= tunnels.get() ;
 182            dpnTEPs = tn.getDPNTEPsInfo() ;
 183            LOG.debug( "Read from CONFIGURATION datastore - No. of Dpns " , dpnTEPs.size() );
 184         }else
 185             LOG.debug( "No Dpn information in CONFIGURATION datastore "  );
 186          return dpnTEPs ;
 187     }
 188 }