interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/utilities/SouthboundUtils.java

   1 /*
   2  * Copyright (c) 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 package org.opendaylight.genius.interfacemanager.renderer.ovs.utilities;
   9
  10 import com.google.common.collect.Maps;
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import java.math.BigInteger;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.UUID;
  18 import org.apache.commons.lang3.BooleanUtils;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
  23 import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlanGpe;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptions;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  57 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  58 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.slf4j.Logger;
  65 import org.slf4j.LoggerFactory;
  66
  67 public class SouthboundUtils {
  68     private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
  69
  70     public static final String BFD_PARAM_ENABLE = "enable";
  71     static final String BFD_PARAM_MIN_TX = "min_tx";
  72     static final String BFD_PARAM_MIN_RX = "min_rx";
  73     static final String BFD_PARAM_DECAY_MIN_RX = "decay_min_rx";
  74     static final String BFD_PARAM_FORWARDING_IF_RX = "forwarding_if_rx";
  75     static final String BFD_PARAM_CPATH_DOWN = "cpath_down";
  76     static final String BFD_PARAM_CHECK_TNL_KEY = "check_tnl_key";
  77
  78     // BFD parameters
  79     public static final String BFD_OP_STATE = "state";
  80     public static final String BFD_STATE_UP = "up";
  81     private static final String BFD_MIN_RX_VAL = "1000";
  82     private static final String BFD_MIN_TX_VAL = "100";
  83     private static final String BFD_DECAY_MIN_RX_VAL = "200";
  84     private static final String BFD_FORWARDING_IF_RX_VAL = "true";
  85     private static final String BFD_CPATH_DOWN_VAL = "false";
  86     private static final String BFD_CHECK_TNL_KEY_VAL = "false";
  87
  88     // Tunnel options
  89     private static final String TUNNEL_OPTIONS_KEY = "key";
  90     private static final String TUNNEL_OPTIONS_LOCAL_IP = "local_ip";
  91     private static final String TUNNEL_OPTIONS_REMOTE_IP = "remote_ip";
  92     private static final String TUNNEL_OPTIONS_DESTINATION_PORT = "dst_port";
  93
  94     // Option values for VxLAN-GPE + NSH tunnels
  95     private static final String TUNNEL_OPTIONS_EXTS = "exts";
  96     private static final String TUNNEL_OPTIONS_NSI = "nsi";
  97     private static final String TUNNEL_OPTIONS_NSP = "nsp";
  98     private static final String TUNNEL_OPTIONS_NSHC1 = "nshc1";
  99     private static final String TUNNEL_OPTIONS_NSHC2 = "nshc2";
 100     private static final String TUNNEL_OPTIONS_NSHC3 = "nshc3";
 101     private static final String TUNNEL_OPTIONS_NSHC4 = "nshc4";
 102
 103     // Option values for VxLAN-GPE + NSH tunnels
 104     private static final String TUNNEL_OPTIONS_VALUE_FLOW = "flow";
 105     private static final String TUNNEL_OPTIONS_VALUE_GPE = "gpe";
 106     // UDP port for VxLAN-GPE Tunnels
 107     private static final String TUNNEL_OPTIONS_VALUE_GPE_DESTINATION_PORT = "4880";
 108
 109     // To keep the mapping between Tunnel Types and Tunnel Interfaces
 110     private static final Map<Class<? extends TunnelTypeBase>, Class<? extends InterfaceTypeBase>> TUNNEL_TYPE_MAP =
 111             new HashMap<Class<? extends TunnelTypeBase>, Class<? extends InterfaceTypeBase>>() {
 112                 {
 113                     put(TunnelTypeGre.class, InterfaceTypeGre.class);
 114                     put(TunnelTypeVxlan.class, InterfaceTypeVxlan.class);
 115                     put(TunnelTypeVxlanGpe.class, InterfaceTypeVxlan.class);
 116                 }
 117             };
 118
 119     public static void addPortToBridge(InstanceIdentifier<?> bridgeIid, Interface iface, String portName,
 120             DataBroker dataBroker, List<ListenableFuture<Void>> futures) {
 121         IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
 122         if (ifTunnel != null) {
 123             addTunnelPortToBridge(ifTunnel, bridgeIid, iface, portName, dataBroker);
 124         }
 125     }
 126
 127     /*
 128      * Add all tunnels ports corresponding to the bridge to the topology config
 129      * DS
 130      */
 131     public static void addAllPortsToBridge(BridgeEntry bridgeEntry, DataBroker dataBroker,
 132             InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid, OvsdbBridgeAugmentation bridgeNew,
 133             List<ListenableFuture<Void>> futures) {
 134         String bridgeName = bridgeNew.getBridgeName().getValue();
 135         LOG.debug("adding all ports to bridge: {}", bridgeName);
 136         List<BridgeInterfaceEntry> bridgeInterfaceEntries = bridgeEntry.getBridgeInterfaceEntry();
 137         if (bridgeInterfaceEntries != null) {
 138             for (BridgeInterfaceEntry bridgeInterfaceEntry : bridgeInterfaceEntries) {
 139                 String portName = bridgeInterfaceEntry.getInterfaceName();
 140                 InterfaceKey interfaceKey = new InterfaceKey(portName);
 141                 Interface iface = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 142                 if (iface != null) {
 143                     IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
 144                     if (ifTunnel != null) {
 145                         addTunnelPortToBridge(ifTunnel, bridgeIid, iface, portName, dataBroker);
 146                     }
 147                     if (SouthboundUtils.isOfTunnel(ifTunnel)) {
 148                         LOG.debug("Using OFTunnel. Only one tunnel port will be added");
 149                         return;
 150                     }
 151                 } else {
 152                     LOG.debug("Interface {} not found in config DS", portName);
 153                 }
 154             }
 155         }
 156     }
 157
 158     /*
 159      * delete all tunnels ports corresponding to the bridge to the topology config
 160      * DS
 161      *
 162      * FIXME: This is not being called from anywhere.
 163      */
 164     public static void removeAllPortsFromBridge(BridgeEntry bridgeEntry, DataBroker dataBroker,
 165             InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid, OvsdbBridgeAugmentation bridgeNew) {
 166         WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 167         String bridgeName = bridgeNew.getBridgeName().getValue();
 168         LOG.debug("removing all ports from bridge: {}", bridgeName);
 169         List<BridgeInterfaceEntry> bridgeInterfaceEntries = bridgeEntry.getBridgeInterfaceEntry();
 170         if (bridgeInterfaceEntries != null) {
 171             for (BridgeInterfaceEntry bridgeInterfaceEntry : bridgeInterfaceEntries) {
 172                 String portName = bridgeInterfaceEntry.getInterfaceName();
 173                 InterfaceKey interfaceKey = new InterfaceKey(portName);
 174                 Interface iface = InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 175                 if (iface != null) {
 176                     IfTunnel ifTunnel = iface.getAugmentation(IfTunnel.class);
 177                     if (ifTunnel != null) {
 178                         removeTerminationEndPoint(dataBroker, bridgeIid, iface.getName());
 179                     }
 180                     if (SouthboundUtils.isOfTunnel(ifTunnel)) {
 181                         LOG.debug("Using OFTunnel. Only one tunnel port to be removed");
 182                         return;
 183                     }
 184                 } else {
 185                     LOG.debug("Interface {} not found in config DS", portName);
 186                 }
 187             }
 188         }
 189     }
 190
 191     private static void addVlanPortToBridge(InstanceIdentifier<?> bridgeIid, IfL2vlan ifL2vlan, IfTunnel ifTunnel,
 192             OvsdbBridgeAugmentation bridgeAugmentation, String bridgeName, String portName, DataBroker dataBroker,
 193             WriteTransaction tx) {
 194         if (ifL2vlan.getVlanId() != null) {
 195             addTerminationPoint(bridgeIid, portName, ifL2vlan.getVlanId().getValue(), null, null, ifTunnel);
 196         }
 197     }
 198
 199     private static void addTunnelPortToBridge(IfTunnel ifTunnel, InstanceIdentifier<?> bridgeIid, Interface iface,
 200             String portName, DataBroker dataBroker) {
 201         LOG.debug("adding tunnel port {} to bridge {}", portName, bridgeIid);
 202
 203         Class<? extends InterfaceTypeBase> type = TUNNEL_TYPE_MAP.get(ifTunnel.getTunnelInterfaceType());
 204
 205         if (type == null) {
 206             LOG.warn("Unknown Tunnel Type obtained while creating interface: {}", iface);
 207             return;
 208         }
 209
 210         int vlanId = 0;
 211         IfL2vlan ifL2vlan = iface.getAugmentation(IfL2vlan.class);
 212         if (ifL2vlan != null && ifL2vlan.getVlanId() != null) {
 213             vlanId = ifL2vlan.getVlanId().getValue();
 214         }
 215
 216         Map<String, String> options = Maps.newHashMap();
 217
 218         // Options common to any kind of tunnel
 219         if (BooleanUtils.isTrue(ifTunnel.isTunnelSourceIpFlow())) {
 220             options.put(TUNNEL_OPTIONS_LOCAL_IP, TUNNEL_OPTIONS_VALUE_FLOW);
 221         } else {
 222             IpAddress localIp = ifTunnel.getTunnelSource();
 223             options.put(TUNNEL_OPTIONS_LOCAL_IP, String.valueOf(localIp.getValue()));
 224         }
 225         if (BooleanUtils.isTrue(ifTunnel.isTunnelRemoteIpFlow())) {
 226             options.put(TUNNEL_OPTIONS_REMOTE_IP, TUNNEL_OPTIONS_VALUE_FLOW);
 227         } else {
 228             IpAddress remoteIp = ifTunnel.getTunnelDestination();
 229             options.put(TUNNEL_OPTIONS_REMOTE_IP, String.valueOf(remoteIp.getValue()));
 230         }
 231
 232         // Specific options for each type of tunnel
 233         if (!ifTunnel.getTunnelInterfaceType().equals(TunnelTypeMplsOverGre.class)) {
 234             options.put(TUNNEL_OPTIONS_KEY, TUNNEL_OPTIONS_VALUE_FLOW);
 235         }
 236         if (ifTunnel.getTunnelInterfaceType().equals(TunnelTypeVxlanGpe.class)) {
 237             options.put(TUNNEL_OPTIONS_EXTS, TUNNEL_OPTIONS_VALUE_GPE);
 238             options.put(TUNNEL_OPTIONS_NSI, TUNNEL_OPTIONS_VALUE_FLOW);
 239             options.put(TUNNEL_OPTIONS_NSP, TUNNEL_OPTIONS_VALUE_FLOW);
 240             options.put(TUNNEL_OPTIONS_NSHC1, TUNNEL_OPTIONS_VALUE_FLOW);
 241             options.put(TUNNEL_OPTIONS_NSHC2, TUNNEL_OPTIONS_VALUE_FLOW);
 242             options.put(TUNNEL_OPTIONS_NSHC3, TUNNEL_OPTIONS_VALUE_FLOW);
 243             options.put(TUNNEL_OPTIONS_NSHC4, TUNNEL_OPTIONS_VALUE_FLOW);
 244             // VxLAN-GPE interfaces will not use the default UDP port to avoid
 245             // problems with other meshes
 246             options.put(TUNNEL_OPTIONS_DESTINATION_PORT, TUNNEL_OPTIONS_VALUE_GPE_DESTINATION_PORT);
 247         }
 248
 249         if (ifTunnel.getTunnelOptions() != null) {
 250             for (TunnelOptions tunOpt : ifTunnel.getTunnelOptions()) {
 251                 options.putIfAbsent(tunOpt.getTunnelOption(), tunOpt.getValue());
 252             }
 253         }
 254
 255         addTerminationPoint(bridgeIid, portName, vlanId, type, options, ifTunnel);
 256     }
 257
 258     // Update is allowed only for tunnel monitoring attributes
 259     public static void updateBfdParamtersForTerminationPoint(InstanceIdentifier<?> bridgeIid, IfTunnel ifTunnel,
 260             String portName, WriteTransaction transaction) {
 261         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
 262                 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), portName);
 263         if (isOfTunnel(ifTunnel)) {
 264             LOG.warn("BFD monitoring not supported for OFTunnels. Skipping BFD parameters for {}", portName);
 265             return;
 266         }
 267         LOG.debug("update bfd parameters for interface {}", tpIid);
 268         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 269         List<InterfaceBfd> bfdParams = getBfdParams(ifTunnel);
 270         tpAugmentationBuilder.setInterfaceBfd(bfdParams);
 271
 272         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 273         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 274         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 275
 276         transaction.merge(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build(), true);
 277     }
 278
 279     private static void addTerminationPoint(InstanceIdentifier<?> bridgeIid, String portName, int vlanId,
 280             Class<? extends InterfaceTypeBase> type, Map<String, String> options, IfTunnel ifTunnel) {
 281         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
 282                 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), portName);
 283         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 284
 285         tpAugmentationBuilder.setName(portName);
 286
 287         if (type != null) {
 288             tpAugmentationBuilder.setInterfaceType(type);
 289         }
 290
 291         if (options != null) {
 292             List<Options> optionsList = new ArrayList<>();
 293             for (Map.Entry<String, String> entry : options.entrySet()) {
 294                 OptionsBuilder optionsBuilder = new OptionsBuilder();
 295                 optionsBuilder.setKey(new OptionsKey(entry.getKey()));
 296                 optionsBuilder.setOption(entry.getKey());
 297                 optionsBuilder.setValue(entry.getValue());
 298                 optionsList.add(optionsBuilder.build());
 299             }
 300             tpAugmentationBuilder.setOptions(optionsList);
 301         }
 302
 303         if (vlanId != 0) {
 304             tpAugmentationBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
 305             tpAugmentationBuilder.setVlanTag(new VlanId(vlanId));
 306         }
 307
 308         if (bfdMonitoringEnabled(ifTunnel)) {
 309             if (isOfTunnel(ifTunnel)) {
 310                 LOG.warn("BFD Monitoring not supported for OFTunnels");
 311             } else {
 312                 List<InterfaceBfd> bfdParams = getBfdParams(ifTunnel);
 313                 tpAugmentationBuilder.setInterfaceBfd(bfdParams);
 314             }
 315         }
 316
 317         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 318         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 319         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 320
 321         BatchingUtils.write(tpIid, tpBuilder.build(), BatchingUtils.EntityType.TOPOLOGY_CONFIG);
 322
 323     }
 324
 325     private static List<InterfaceBfd> getBfdParams(IfTunnel ifTunnel) {
 326         List<InterfaceBfd> bfdParams = new ArrayList<>();
 327         bfdParams.add(
 328                 getIfBfdObj(BFD_PARAM_ENABLE, ifTunnel != null ? ifTunnel.isMonitorEnabled().toString() : "false"));
 329         bfdParams.add(getIfBfdObj(BFD_PARAM_MIN_TX, ifTunnel != null && ifTunnel.getMonitorInterval() != null
 330                 ? ifTunnel.getMonitorInterval().toString() : BFD_MIN_TX_VAL));
 331         bfdParams.add(getIfBfdObj(BFD_FORWARDING_IF_RX_VAL, "true"));
 332         return bfdParams;
 333     }
 334
 335     private static InterfaceBfd getIfBfdObj(String key, String value) {
 336         InterfaceBfdBuilder bfdBuilder = new InterfaceBfdBuilder();
 337         bfdBuilder.setBfdKey(key).setKey(new InterfaceBfdKey(key)).setBfdValue(value);
 338         return bfdBuilder.build();
 339     }
 340
 341     public static InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(NodeKey nodekey,
 342             String portName) {
 343         InstanceIdentifier<TerminationPoint> terminationPointPath = InstanceIdentifier.create(NetworkTopology.class)
 344                 .child(Topology.class, new TopologyKey(IfmConstants.OVSDB_TOPOLOGY_ID)).child(Node.class, nodekey)
 345                 .child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
 346
 347         LOG.debug("Termination point InstanceIdentifier generated : {}", terminationPointPath);
 348         return terminationPointPath;
 349     }
 350
 351     public static void removeTerminationEndPoint(DataBroker dataBroker,
 352             InstanceIdentifier<?> bridgeIid, String interfaceName) {
 353         LOG.debug("removing termination point for {}", interfaceName);
 354         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 355         InstanceIdentifier<TerminationPoint> tpIid = SouthboundUtils.createTerminationPointInstanceIdentifier(
 356                 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), interfaceName);
 357         BatchingUtils.delete(tpIid, BatchingUtils.EntityType.TOPOLOGY_CONFIG);
 358     }
 359
 360     public static boolean bfdMonitoringEnabled(IfTunnel ifTunnel) {
 361         return ifTunnel.isMonitorEnabled()
 362                 && TunnelMonitoringTypeBfd.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
 363     }
 364
 365     public static boolean isMonitorProtocolBfd(IfTunnel ifTunnel) {
 366         return TunnelMonitoringTypeBfd.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
 367     }
 368
 369     public static String generateOfTunnelName(BigInteger dpId, IfTunnel ifTunnel) {
 370         String sourceKey = ifTunnel.getTunnelSource().getIpv4Address().getValue();
 371         String remoteKey = ifTunnel.getTunnelDestination().getIpv4Address().getValue();
 372         if (ifTunnel.isTunnelSourceIpFlow() != null) {
 373             sourceKey = "flow";
 374         }
 375         if (ifTunnel.isTunnelRemoteIpFlow() != null) {
 376             remoteKey = "flow";
 377         }
 378         String tunnelNameKey = dpId.toString() + sourceKey + remoteKey;
 379         String uuidStr = UUID.nameUUIDFromBytes(tunnelNameKey.getBytes()).toString().substring(0, 12).replace("-", "");
 380         return String.format("%s%s", "tun", uuidStr);
 381     }
 382
 383     public static boolean isOfTunnel(IfTunnel ifTunnel) {
 384         if (BooleanUtils.isTrue(ifTunnel.isTunnelRemoteIpFlow())
 385                 || BooleanUtils.isTrue(ifTunnel.isTunnelSourceIpFlow())) {
 386             return true;
 387         }
 388         return false;
 389     }
 390
 391 }