netvirt/src/main/java/org/opendaylight/unimgr/mef/netvirt/NetvirtUtils.java

   1 /*
   2  * Copyright (c) 2016 Hewlett Packard Enterprise, Co. 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.unimgr.mef.netvirt;
  10
  11 import java.math.BigInteger;
  12 import java.util.concurrent.ExecutionException;
  13 import java.util.concurrent.Future;
  14
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.SplitHorizon;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.SplitHorizonBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstanceBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterface.EtreeInterfaceType;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInterfaceBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
  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.ElanInstanceBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVxlan;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  50 import org.opendaylight.yangtools.yang.common.RpcResult;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 import com.google.common.base.Optional;
  55
  56 public class NetvirtUtils {
  57
  58     private static final Logger logger = LoggerFactory.getLogger(NetvirtUtils.class);
  59     private static final long DEFAULT_MAC_TIMEOUT = 300;
  60
  61     public static void createElanInstance(DataBroker dataBroker, String instanceName, boolean isEtree, Long segmentationId) {
  62         createElanInstance(dataBroker, instanceName, isEtree, segmentationId, DEFAULT_MAC_TIMEOUT);
  63     }
  64
  65     public static void createElanInstance(DataBroker dataBroker, String instanceName, boolean isEtree, Long segmentationId, Long macTimeout) {
  66         ElanInstanceBuilder einstBuilder = createElanInstanceBuilder(instanceName, segmentationId, macTimeout);
  67
  68         if (isEtree) {
  69             EtreeInstance etreeInstance = new EtreeInstanceBuilder().build();
  70             einstBuilder.addAugmentation(EtreeInstance.class, etreeInstance).build();
  71         }
  72
  73         MdsalUtils.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
  74                 getElanInstanceInstanceIdentifier(instanceName), einstBuilder.build());
  75     }
  76
  77     public static void updateElanInstance(DataBroker dataBroker, String instanceName) {
  78         WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
  79         updateElanInstance(instanceName, tx);
  80         MdsalUtils.commitTransaction(tx);
  81     }
  82
  83     public static void updateElanInstance(String instanceName, WriteTransaction tx) {
  84         ElanInstanceBuilder einstBuilder = createElanInstanceBuilder(instanceName);
  85         saveElanInstance(instanceName, tx, einstBuilder);
  86     }
  87
  88     public static void updateElanInstance(String instanceName, WriteTransaction tx, Long segmentationId) {
  89         ElanInstanceBuilder einstBuilder = createElanInstanceBuilder(instanceName, segmentationId);
  90         saveElanInstance(instanceName, tx, einstBuilder);
  91     }
  92
  93     public static void updateElanInstance(String instanceName, WriteTransaction tx, Long segmentationId, Long macTimeout) {
  94         ElanInstanceBuilder einstBuilder = createElanInstanceBuilder(instanceName, segmentationId, macTimeout);
  95         saveElanInstance(instanceName, tx, einstBuilder);
  96     }
  97
  98     private static void saveElanInstance(String instanceName, WriteTransaction tx, ElanInstanceBuilder einstBuilder) {
  99         tx.merge(LogicalDatastoreType.CONFIGURATION, getElanInstanceInstanceIdentifier(instanceName),
 100                 einstBuilder.build());
 101     }
 102
 103     public static void updateElanInterface(DataBroker dataBroker, String instanceName, String interfaceName) {
 104         ElanInterfaceBuilder einterfaceBuilder = createElanInterface(instanceName, interfaceName);
 105
 106         MdsalUtils.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
 107                 getElanInterfaceInstanceIdentifier(interfaceName), einterfaceBuilder.build());
 108     }
 109
 110     public static void deleteElanInstance(DataBroker dataBroker, String instanceName) {
 111         MdsalUtils.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
 112                 getElanInstanceInstanceIdentifier(instanceName));
 113     }
 114
 115     public static void deleteElanInstance(String instanceName, WriteTransaction tx) {
 116         tx.delete(LogicalDatastoreType.CONFIGURATION, getElanInstanceInstanceIdentifier(instanceName));
 117     }
 118
 119     public static void deleteElanInterface(DataBroker dataBroker, String interfaceName) {
 120         WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
 121         deleteElanInterface(interfaceName, tx);
 122         MdsalUtils.commitTransaction(tx);
 123     }
 124
 125     public static void deleteElanInterface(String interfaceName, WriteTransaction tx) {
 126         tx.delete(LogicalDatastoreType.CONFIGURATION, getElanInterfaceInstanceIdentifier(interfaceName));
 127     }
 128
 129     public static Interface createTrunkInterface(String interfaceName, String parentIfaceName) {
 130         IfL2vlanBuilder ifL2vlanBuilder = new IfL2vlanBuilder();
 131         ifL2vlanBuilder.setL2vlanMode(IfL2vlan.L2vlanMode.Trunk);
 132         return createInterface(interfaceName, parentIfaceName, ifL2vlanBuilder.build());
 133     }
 134
 135     public static Interface createTrunkMemberInterface(String interfaceName, String parentIfaceName, int vlanId) {
 136         IfL2vlanBuilder ifL2vlanBuilder = new IfL2vlanBuilder();
 137         ifL2vlanBuilder.setL2vlanMode(IfL2vlan.L2vlanMode.TrunkMember).setVlanId(new VlanId(vlanId));
 138         return createInterface(interfaceName, parentIfaceName, ifL2vlanBuilder.build());
 139     }
 140
 141     private static Interface createInterface(String interfaceName, String parentIfaceName, IfL2vlan ifL2vlan) {
 142         InterfaceBuilder interfaceBuilder = new InterfaceBuilder();
 143         SplitHorizon sh = new SplitHorizonBuilder().setOverrideSplitHorizonProtection(true).build();
 144         ParentRefsBuilder parentRefsBuilder = new ParentRefsBuilder().setParentInterface(parentIfaceName);
 145         interfaceBuilder.setEnabled(true).setName(interfaceName).setType(L2vlan.class)
 146                 .addAugmentation(SplitHorizon.class, sh)
 147                 .addAugmentation(IfL2vlan.class, ifL2vlan).addAugmentation(ParentRefs.class, parentRefsBuilder.build());
 148         return interfaceBuilder.build();
 149     }
 150
 151     private static ElanInstanceBuilder createElanInstanceBuilder(String instanceName) {
 152         return createElanInstanceBuilder(instanceName, Long.valueOf(Math.abs((short) instanceName.hashCode())));
 153     }
 154
 155     private static ElanInstanceBuilder createElanInstanceBuilder(String instanceName, Long segmentationId) {
 156         return createElanInstanceBuilder(instanceName, segmentationId, DEFAULT_MAC_TIMEOUT);
 157     }
 158
 159     private static ElanInstanceBuilder createElanInstanceBuilder(String instanceName, Long segmentationId, Long macTimeout) {
 160         if (segmentationId == null) {
 161             segmentationId = Long.valueOf(Math.abs((short) instanceName.hashCode()));
 162         }
 163         ElanInstanceBuilder einstBuilder = new ElanInstanceBuilder();
 164         einstBuilder.setElanInstanceName(instanceName);
 165         einstBuilder.setKey(new ElanInstanceKey(instanceName));
 166         einstBuilder.setMacTimeout(macTimeout);
 167         einstBuilder.setSegmentationId(segmentationId);
 168         einstBuilder.setSegmentType(SegmentTypeVxlan.class);
 169         return einstBuilder;
 170     }
 171
 172     private static ElanInterfaceBuilder createElanInterface(String instanceName, String interfaceName) {
 173         ElanInterfaceBuilder einterfaceBuilder = new ElanInterfaceBuilder();
 174         einterfaceBuilder.setElanInstanceName(instanceName);
 175         einterfaceBuilder.setName(interfaceName);
 176         return einterfaceBuilder;
 177     }
 178
 179     private static ElanInterfaceBuilder createEtreeInterface(String instanceName, String interfaceName,
 180             EtreeInterfaceType interfaceType) {
 181         ElanInterfaceBuilder einterfaceBuilder = new ElanInterfaceBuilder();
 182         einterfaceBuilder.setElanInstanceName(instanceName);
 183         einterfaceBuilder.setName(interfaceName);
 184         EtreeInterface etreeInterface = new EtreeInterfaceBuilder().setEtreeInterfaceType(interfaceType).build();
 185         einterfaceBuilder.addAugmentation(EtreeInterface.class, etreeInterface);
 186         return einterfaceBuilder;
 187     }
 188
 189     public static InstanceIdentifier<ElanInstance> getElanInstanceInstanceIdentifier() {
 190         return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class).build();
 191     }
 192
 193     public static InstanceIdentifier<ElanInterfaces> getElanInterfacesInstanceIdentifier() {
 194         return InstanceIdentifier.builder(ElanInterfaces.class).build();
 195     }
 196
 197     public static InstanceIdentifier<ElanInstance> getElanInstanceInstanceIdentifier(String instanceName) {
 198         return InstanceIdentifier.builder(ElanInstances.class)
 199                 .child(ElanInstance.class, new ElanInstanceKey(instanceName)).build();
 200     }
 201
 202     private static InstanceIdentifier<ElanInterface> getElanInterfaceInstanceIdentifier(String interfaceName) {
 203         return InstanceIdentifier.builder(ElanInterfaces.class)
 204                 .child(ElanInterface.class, new ElanInterfaceKey(interfaceName)).build();
 205     }
 206
 207     public static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 208         InstanceIdentifierBuilder<Interface> idBuilder = InstanceIdentifier.builder(Interfaces.class)
 209                 .child(Interface.class, new InterfaceKey(interfaceName));
 210         InstanceIdentifier<Interface> id = idBuilder.build();
 211         return id;
 212     }
 213
 214     public static Optional<Interface> getIetfInterface(DataBroker dataBroker, String interfaceName) {
 215         return MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, getInterfaceIdentifier(interfaceName));
 216     }
 217
 218     public static void writeInterface(Interface iface, WriteTransaction tx) {
 219         String interfaceName = iface.getName();
 220         InstanceIdentifier<Interface> interfaceIdentifier = createInterfaceIdentifier(interfaceName);
 221         tx.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface, true);
 222     }
 223
 224     public static void deleteInterface(String interfaceName, WriteTransaction tx) {
 225         InstanceIdentifier<Interface> interfaceIdentifier = createInterfaceIdentifier(interfaceName);
 226         tx.delete(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier);
 227     }
 228
 229     private static InstanceIdentifier<Interface> createInterfaceIdentifier(String interfaceName) {
 230         return InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName))
 231                 .build();
 232     }
 233
 234     public static void createElanInterface(DataBroker dataBroker, String instanceName, String interfaceName,
 235             EtreeInterfaceType etreeInterfaceType, boolean isEtree) {
 236         WriteTransaction tx = MdsalUtils.createTransaction(dataBroker);
 237         createElanInterface(instanceName, interfaceName, etreeInterfaceType, isEtree, tx);
 238         MdsalUtils.commitTransaction(tx);
 239     }
 240
 241     public static void createElanInterface(String instanceName, String interfaceName,
 242             EtreeInterfaceType etreeInterfaceType, boolean isEtree, WriteTransaction tx) {
 243         logger.info("Adding {} interface: {}", isEtree ? "etree" : "elan", interfaceName);
 244
 245         if (isEtree) {
 246             NetvirtUtils.createEtreeInterface(instanceName, interfaceName, etreeInterfaceType, tx);
 247         } else {
 248             NetvirtUtils.createElanInterface(instanceName, interfaceName, tx);
 249         }
 250     }
 251
 252     private static void createEtreeInterface(String instanceName, String interfaceName, EtreeInterfaceType type,
 253             WriteTransaction tx) {
 254         ElanInterfaceBuilder einterfaceBuilder = createEtreeInterface(instanceName, interfaceName, type);
 255
 256         tx.put(LogicalDatastoreType.CONFIGURATION, getElanInterfaceInstanceIdentifier(interfaceName),
 257                 einterfaceBuilder.build());
 258     }
 259
 260     private static void createElanInterface(String instanceName, String interfaceName, WriteTransaction tx) {
 261         ElanInterfaceBuilder einterfaceBuilder = createElanInterface(instanceName, interfaceName);
 262
 263         tx.put(LogicalDatastoreType.CONFIGURATION, getElanInterfaceInstanceIdentifier(interfaceName),
 264                 einterfaceBuilder.build());
 265     }
 266
 267     public static BigInteger getDpnForInterface(OdlInterfaceRpcService interfaceManagerRpcService, String ifName) {
 268         BigInteger nodeId = BigInteger.ZERO;
 269         try {
 270             GetDpidFromInterfaceInput dpIdInput = new GetDpidFromInterfaceInputBuilder().setIntfName(ifName).build();
 271             Future<RpcResult<GetDpidFromInterfaceOutput>> dpIdOutput = interfaceManagerRpcService
 272                     .getDpidFromInterface(dpIdInput);
 273             RpcResult<GetDpidFromInterfaceOutput> dpIdResult = dpIdOutput.get();
 274             if (dpIdResult.isSuccessful()) {
 275                 nodeId = dpIdResult.getResult().getDpid();
 276             } else {
 277                 logger.error("Could not retrieve DPN Id for interface {}", ifName);
 278             }
 279         } catch (NullPointerException | InterruptedException | ExecutionException e) {
 280             logger.error("Exception when getting dpn for interface {}", ifName, e);
 281         }
 282         return nodeId;
 283     }
 284
 285     public static void safeSleep() {
 286         try {
 287             Thread.yield();
 288             Thread.sleep(1000);
 289         } catch (InterruptedException e) {
 290         }
 291     }
 292     public static void safeSleep(short sec) {
 293         try {
 294             Thread.yield();
 295             Thread.sleep(1000*sec);
 296         } catch (InterruptedException e) {
 297         }
 298     }
 299
 300
 301 }