2 * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
8 package org.opendaylight.genius.interfacemanager.renderer.ovs.utilities;
10 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
11 import java.util.ArrayList;
12 import java.util.HashMap;
13 import java.util.List;
14 import java.util.Locale;
16 import java.util.UUID;
17 import javax.inject.Inject;
18 import javax.inject.Singleton;
19 import org.apache.aries.blueprint.annotation.service.Reference;
20 import org.apache.commons.lang3.BooleanUtils;
21 import org.eclipse.jdt.annotation.Nullable;
22 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
23 import org.opendaylight.genius.infra.Datastore.Configuration;
24 import org.opendaylight.genius.infra.TypedWriteTransaction;
25 import org.opendaylight.genius.interfacemanager.InterfacemgrProvider;
26 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
27 import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
28 import org.opendaylight.infrautils.caches.Cache;
29 import org.opendaylight.infrautils.caches.CacheConfigBuilder;
30 import org.opendaylight.infrautils.caches.CachePolicyBuilder;
31 import org.opendaylight.infrautils.caches.CacheProvider;
32 import org.opendaylight.mdsal.binding.api.DataBroker;
33 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
34 import org.opendaylight.mdsal.common.api.ReadFailedException;
35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntry;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlanGpe;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptions;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
75 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
76 import org.opendaylight.yangtools.yang.common.Uint64;
77 import org.slf4j.Logger;
78 import org.slf4j.LoggerFactory;
81 public class SouthboundUtils {
82 private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
83 private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
85 private static final String BFD_PARAM_ENABLE = "enable";
86 private static final String BFD_PARAM_MIN_TX = "min_tx";
87 private static final String BFD_PARAM_FORWARDING_IF_RX = "forwarding_if_rx";
90 public static final String BFD_ENABLE_KEY = "enable";
91 public static final String BFD_ENABLE_VALUE = "true";
92 public static final String BFD_OP_STATE = "state";
93 public static final String BFD_STATE_UP = "up";
94 private static final String BFD_MIN_TX_VAL = "100";
95 private static final String BFD_FORWARDING_IF_RX_VAL = "true";
98 private static final String TUNNEL_OPTIONS_KEY = "key";
99 private static final String TUNNEL_OPTIONS_LOCAL_IP = "local_ip";
100 private static final String TUNNEL_OPTIONS_REMOTE_IP = "remote_ip";
101 private static final String TUNNEL_OPTIONS_DESTINATION_PORT = "dst_port";
103 // Option values for VxLAN-GPE + NSH tunnels
104 private static final String TUNNEL_OPTIONS_EXTS = "exts";
105 private static final String TUNNEL_OPTIONS_NSI = "nsi";
106 private static final String TUNNEL_OPTIONS_NSP = "nsp";
107 private static final String TUNNEL_OPTIONS_NSHC1 = "nshc1";
108 private static final String TUNNEL_OPTIONS_NSHC2 = "nshc2";
109 private static final String TUNNEL_OPTIONS_NSHC3 = "nshc3";
110 private static final String TUNNEL_OPTIONS_NSHC4 = "nshc4";
112 // Tunnel options for MPLS-GRE tunnels [requires OVS 2.8+)
113 private static final String TUNNEL_OPTIONS_PKT_TYPE = "packet_type";
115 // Option values for VxLAN-GPE + NSH tunnels
116 private static final String TUNNEL_OPTIONS_VALUE_FLOW = "flow";
117 private static final String TUNNEL_OPTIONS_VALUE_GPE = "gpe";
118 // UDP port for VxLAN-GPE Tunnels
119 private static final String TUNNEL_OPTIONS_VALUE_GPE_DESTINATION_PORT = "4880";
121 // Tunnel option values for MPLS-GRE tunnels [requires OVS 2.8+)
122 private static final String TUNNEL_OPTIONS_VALUE_LEGACY_L3 = "legacy_l3";
124 // To keep the mapping between Tunnel Types and Tunnel Interfaces
125 private static final Map<Class<? extends TunnelTypeBase>, Class<? extends InterfaceTypeBase>>
126 TUNNEL_TYPE_MAP = new HashMap<>() {
128 put(TunnelTypeGre.class, InterfaceTypeGre.class);
129 put(TunnelTypeMplsOverGre.class, InterfaceTypeGre.class);
130 put(TunnelTypeVxlan.class, InterfaceTypeVxlan.class);
131 put(TunnelTypeVxlanGpe.class, InterfaceTypeVxlan.class);
135 // OVS Detection statics
136 private static final String DEFAULT_OVS_VERSION = "2.8.0";
137 private static final String MIN_GRE_VERSION = "2.8.0";
138 private static final long MAX_CACHE_SIZE = 1024;
140 private final SingleTransactionDataBroker singleTxDB;
142 private final BatchingUtils batchingUtils;
143 private final InterfacemgrProvider interfacemgrProvider;
144 private final Cache<String, String> ovsVersionCache;
147 public SouthboundUtils(@Reference final DataBroker dataBroker,
148 final BatchingUtils batchingUtils, InterfacemgrProvider interfacemgrProvider,
149 @Reference final CacheProvider cacheProvider) {
150 this.batchingUtils = batchingUtils;
151 this.interfacemgrProvider = interfacemgrProvider;
152 this.singleTxDB = new SingleTransactionDataBroker(dataBroker);
153 ovsVersionCache = cacheProvider.newCache(
154 new CacheConfigBuilder<String, String>()
156 .id("ovsVersionCache")
157 .cacheFunction(key -> getVersionForBridgeNodeId(key))
158 .description("BridgeNodeId to OVS Version cache")
160 new CachePolicyBuilder().maxEntries(MAX_CACHE_SIZE).build());
163 public void addPortToBridge(InstanceIdentifier<?> bridgeIid, Interface iface, String portName) {
164 IfTunnel ifTunnel = iface.augmentation(IfTunnel.class);
165 if (ifTunnel != null) {
166 addTunnelPortToBridge(ifTunnel, bridgeIid, iface, portName);
171 * Add all tunnels ports corresponding to the bridge to the topology config DS.
173 public void addAllPortsToBridge(BridgeEntry bridgeEntry, InterfaceManagerCommonUtils interfaceManagerCommonUtils,
174 InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid,
175 OvsdbBridgeAugmentation bridgeNew) {
176 String bridgeName = bridgeNew.getBridgeName().getValue();
177 LOG.debug("adding all ports to bridge: {}", bridgeName);
178 @Nullable Map<BridgeInterfaceEntryKey, BridgeInterfaceEntry> bridgeInterfaceEntries =
179 bridgeEntry.getBridgeInterfaceEntry();
180 if (bridgeInterfaceEntries != null) {
181 for (BridgeInterfaceEntry bridgeInterfaceEntry : bridgeInterfaceEntries.values()) {
182 String portName = bridgeInterfaceEntry.getInterfaceName();
183 InterfaceKey interfaceKey = new InterfaceKey(portName);
184 Interface iface = interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey);
186 IfTunnel ifTunnel = iface.augmentation(IfTunnel.class);
187 if (ifTunnel != null) {
188 if (!(interfacemgrProvider.isItmDirectTunnelsEnabled() && ifTunnel.isInternal())) {
189 addTunnelPortToBridge(ifTunnel, bridgeIid, iface, portName);
191 if (isOfTunnel(ifTunnel)) {
192 LOG.debug("Using OFTunnel. Only one tunnel port will be added");
197 LOG.debug("Interface {} not found in config DS", portName);
203 private void addTunnelPortToBridge(IfTunnel ifTunnel, InstanceIdentifier<?> bridgeIid, Interface iface,
205 LOG.debug("adding tunnel port {} to bridge {}", portName, bridgeIid);
206 EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,ADD Tunnelport {} Bridgeid {}", portName, bridgeIid);
207 Class<? extends InterfaceTypeBase> type = TUNNEL_TYPE_MAP.get(ifTunnel.getTunnelInterfaceType());
210 LOG.warn("Unknown Tunnel Type obtained while creating interface: {}", iface);
215 IfL2vlan ifL2vlan = iface.augmentation(IfL2vlan.class);
216 if (ifL2vlan != null && ifL2vlan.getVlanId() != null) {
217 vlanId = ifL2vlan.getVlanId().getValue().toJava();
220 Map<String, String> options = new HashMap<>();
222 // Options common to any kind of tunnel
223 if (BooleanUtils.isTrue(ifTunnel.isTunnelSourceIpFlow())) {
224 options.put(TUNNEL_OPTIONS_LOCAL_IP, TUNNEL_OPTIONS_VALUE_FLOW);
226 IpAddress localIp = ifTunnel.getTunnelSource();
227 options.put(TUNNEL_OPTIONS_LOCAL_IP, localIp.stringValue());
229 if (BooleanUtils.isTrue(ifTunnel.isTunnelRemoteIpFlow())) {
230 options.put(TUNNEL_OPTIONS_REMOTE_IP, TUNNEL_OPTIONS_VALUE_FLOW);
232 IpAddress remoteIp = ifTunnel.getTunnelDestination();
233 options.put(TUNNEL_OPTIONS_REMOTE_IP, remoteIp.stringValue());
235 // Specific options for each type of tunnel
236 if (TunnelTypeMplsOverGre.class.equals(ifTunnel.getTunnelInterfaceType())) {
237 String switchVersion = getSwitchVersion((InstanceIdentifier<Node>) bridgeIid);
238 LOG.debug("Switch OVS Version: {}", switchVersion);
239 if (org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils.compareDbVersionToMinVersion(
240 switchVersion, MIN_GRE_VERSION)) {
241 options.put(TUNNEL_OPTIONS_PKT_TYPE, TUNNEL_OPTIONS_VALUE_LEGACY_L3);
243 LOG.warn("{} OVS version {} less than {} required for MplsOverGre",
244 bridgeIid.firstKeyOf(Node.class).getNodeId().getValue(),
245 switchVersion, MIN_GRE_VERSION);
249 options.put(TUNNEL_OPTIONS_KEY, TUNNEL_OPTIONS_VALUE_FLOW);
251 if (ifTunnel.getTunnelInterfaceType().equals(TunnelTypeVxlanGpe.class)) {
252 options.put(TUNNEL_OPTIONS_EXTS, TUNNEL_OPTIONS_VALUE_GPE);
253 options.put(TUNNEL_OPTIONS_NSI, TUNNEL_OPTIONS_VALUE_FLOW);
254 options.put(TUNNEL_OPTIONS_NSP, TUNNEL_OPTIONS_VALUE_FLOW);
255 options.put(TUNNEL_OPTIONS_NSHC1, TUNNEL_OPTIONS_VALUE_FLOW);
256 options.put(TUNNEL_OPTIONS_NSHC2, TUNNEL_OPTIONS_VALUE_FLOW);
257 options.put(TUNNEL_OPTIONS_NSHC3, TUNNEL_OPTIONS_VALUE_FLOW);
258 options.put(TUNNEL_OPTIONS_NSHC4, TUNNEL_OPTIONS_VALUE_FLOW);
259 // VxLAN-GPE interfaces will not use the default UDP port to avoid
260 // problems with other meshes
261 options.put(TUNNEL_OPTIONS_DESTINATION_PORT, TUNNEL_OPTIONS_VALUE_GPE_DESTINATION_PORT);
264 if (ifTunnel.getTunnelOptions() != null) {
265 for (TunnelOptions tunOpt : ifTunnel.getTunnelOptions().values()) {
266 options.putIfAbsent(tunOpt.getTunnelOption(), tunOpt.getValue());
270 addTerminationPoint(bridgeIid, portName, vlanId, type, options, ifTunnel);
273 // Update is allowed only for tunnel monitoring attributes
274 public static void updateBfdParamtersForTerminationPoint(InstanceIdentifier<?> bridgeIid, IfTunnel ifTunnel,
275 String portName, TypedWriteTransaction<Configuration> transaction) {
276 InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
277 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), portName);
278 if (isOfTunnel(ifTunnel)) {
279 LOG.warn("BFD monitoring not supported for OFTunnels. Skipping BFD parameters for {}", portName);
282 LOG.debug("update bfd parameters for interface {}", tpIid);
283 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
284 List<InterfaceBfd> bfdParams = getBfdParams(ifTunnel);
285 tpAugmentationBuilder.setInterfaceBfd(bfdParams);
287 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
288 tpBuilder.withKey(InstanceIdentifier.keyOf(tpIid));
289 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
291 transaction.mergeParentStructureMerge(tpIid, tpBuilder.build());
294 private void addTerminationPoint(InstanceIdentifier<?> bridgeIid, String portName, int vlanId,
295 Class<? extends InterfaceTypeBase> type, Map<String, String> options, IfTunnel ifTunnel) {
296 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
298 tpAugmentationBuilder.setName(portName);
301 tpAugmentationBuilder.setInterfaceType(type);
304 if (options != null) {
305 List<Options> optionsList = new ArrayList<>();
306 for (Map.Entry<String, String> entry : options.entrySet()) {
307 OptionsBuilder optionsBuilder = new OptionsBuilder();
308 optionsBuilder.withKey(new OptionsKey(entry.getKey()));
309 optionsBuilder.setOption(entry.getKey());
310 optionsBuilder.setValue(entry.getValue());
311 optionsList.add(optionsBuilder.build());
313 tpAugmentationBuilder.setOptions(optionsList);
317 tpAugmentationBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
318 tpAugmentationBuilder.setVlanTag(new VlanId(vlanId));
320 if (isOfTunnel(ifTunnel)) {
321 LOG.warn("BFD Monitoring not supported for OFTunnels");
323 List<InterfaceBfd> bfdParams = getBfdParams(ifTunnel);
324 tpAugmentationBuilder.setInterfaceBfd(bfdParams);
326 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
327 InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
328 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), portName);
329 tpBuilder.withKey(InstanceIdentifier.keyOf(tpIid));
330 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
332 batchingUtils.write(tpIid, tpBuilder.build(), BatchingUtils.EntityType.TOPOLOGY_CONFIG);
335 private static List<InterfaceBfd> getBfdParams(IfTunnel ifTunnel) {
336 List<InterfaceBfd> bfdParams = new ArrayList<>();
338 getIfBfdObj(BFD_PARAM_ENABLE, ifTunnel != null ? ifTunnel.isMonitorEnabled().toString() : "false"));
339 bfdParams.add(getIfBfdObj(BFD_PARAM_MIN_TX,
340 ifTunnel != null && ifTunnel.getMonitorInterval() != null ? ifTunnel.getMonitorInterval().toString()
342 bfdParams.add(getIfBfdObj(BFD_PARAM_FORWARDING_IF_RX, BFD_FORWARDING_IF_RX_VAL));
346 private static InterfaceBfd getIfBfdObj(String key, String value) {
347 InterfaceBfdBuilder bfdBuilder = new InterfaceBfdBuilder();
348 bfdBuilder.setBfdKey(key).withKey(new InterfaceBfdKey(key)).setBfdValue(value);
349 return bfdBuilder.build();
352 private String getSwitchVersion(InstanceIdentifier<Node> bridgeIid) {
353 String ovsNodeId = bridgeIid.firstKeyOf(Node.class).getNodeId().getValue().split("/bridge")[0];
354 return ovsVersionCache.get(ovsNodeId);
357 private String getVersionForBridgeNodeId(String ovsNodeId) {
358 InstanceIdentifier<Node> ovsNodeIid = InstanceIdentifier.create(NetworkTopology.class)
359 .child(Topology.class, new TopologyKey(IfmConstants.OVSDB_TOPOLOGY_ID))
360 .child(Node.class, new NodeKey(new NodeId(ovsNodeId)));
361 String ovsVersion = DEFAULT_OVS_VERSION;
363 Node ovsNode = singleTxDB.syncRead(LogicalDatastoreType.OPERATIONAL, ovsNodeIid);
364 ovsVersion = ovsNode.augmentation(OvsdbNodeAugmentation.class).getOvsVersion()
365 .toLowerCase(Locale.ROOT);
366 } catch (ReadFailedException e) {
367 LOG.error("OVS Node {} not present", ovsNodeId);
372 public static InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(NodeKey nodekey,
374 InstanceIdentifier<TerminationPoint> terminationPointPath = InstanceIdentifier.create(NetworkTopology.class)
375 .child(Topology.class, new TopologyKey(IfmConstants.OVSDB_TOPOLOGY_ID)).child(Node.class, nodekey)
376 .child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
378 LOG.debug("Termination point InstanceIdentifier generated : {}", terminationPointPath);
379 return terminationPointPath;
382 public void removeTerminationEndPoint(InstanceIdentifier<?> bridgeIid, String interfaceName) {
383 LOG.debug("removing termination point for {}", interfaceName);
384 InstanceIdentifier<TerminationPoint> tpIid = SouthboundUtils.createTerminationPointInstanceIdentifier(
385 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), interfaceName);
386 batchingUtils.delete(tpIid, BatchingUtils.EntityType.TOPOLOGY_CONFIG);
389 public static boolean ifBfdStatusNotEqual(OvsdbTerminationPointAugmentation tpOld,
390 OvsdbTerminationPointAugmentation tpNew) {
391 return tpNew.getInterfaceBfdStatus() != null
392 && (tpOld == null || !tpNew.getInterfaceBfdStatus().equals(tpOld.getInterfaceBfdStatus()));
395 public static boolean changeInBfdMonitoringDetected(OvsdbTerminationPointAugmentation tpOld,
396 OvsdbTerminationPointAugmentation tpNew) {
398 return org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils
399 .bfdMonitoringEnabled(tpNew.getInterfaceBfd())
400 != org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.SouthboundUtils
401 .bfdMonitoringEnabled(tpOld.getInterfaceBfd());
406 public static boolean bfdMonitoringEnabled(IfTunnel ifTunnel) {
407 return ifTunnel.isMonitorEnabled()
408 && TunnelMonitoringTypeBfd.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
411 public static boolean bfdMonitoringEnabled(Map<InterfaceBfdKey, InterfaceBfd> interfaceBfds) {
412 if (interfaceBfds == null) {
415 for (InterfaceBfd interfaceBfd : interfaceBfds.values()) {
416 if (SouthboundUtils.BFD_ENABLE_KEY.equalsIgnoreCase(interfaceBfd.getBfdKey())) {
417 return SouthboundUtils.BFD_ENABLE_VALUE.equalsIgnoreCase(interfaceBfd.getBfdValue());//checkBfdEnabled
423 public static boolean isMonitorProtocolBfd(IfTunnel ifTunnel) {
424 return TunnelMonitoringTypeBfd.class.isAssignableFrom(ifTunnel.getMonitorProtocol());
427 @SuppressFBWarnings("DM_DEFAULT_ENCODING")
428 public static String generateOfTunnelName(Uint64 dpId, IfTunnel ifTunnel) {
429 final String sourceKey;
430 if (ifTunnel.isTunnelSourceIpFlow() != null) {
433 sourceKey = ifTunnel.getTunnelSource().stringValue();
435 final String remoteKey;
436 if (ifTunnel.isTunnelRemoteIpFlow() != null) {
439 remoteKey = ifTunnel.getTunnelDestination().stringValue();
441 String tunnelNameKey = dpId.toString() + sourceKey + remoteKey;
442 String uuidStr = UUID.nameUUIDFromBytes(tunnelNameKey.getBytes()).toString().substring(0, 12).replace("-", "");
443 return "tun" + uuidStr;
446 public static boolean isOfTunnel(IfTunnel ifTunnel) {
447 return Boolean.TRUE.equals(ifTunnel.isTunnelRemoteIpFlow())
448 || Boolean.TRUE.equals(ifTunnel.isTunnelSourceIpFlow());
451 public static boolean isInterfaceTypeTunnel(Class<? extends InterfaceTypeBase> interfaceType) {
452 return InterfaceTypeGre.class.equals(interfaceType) || InterfaceTypeVxlan.class.equals(interfaceType);