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.itm.confighelpers;
10 import static java.util.Collections.singletonList;
11 import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
13 import com.google.common.util.concurrent.ListenableFuture;
14 import java.time.Duration;
15 import java.util.ArrayList;
16 import java.util.Collection;
17 import java.util.Collections;
18 import java.util.List;
19 import java.util.Objects;
20 import java.util.Optional;
21 import java.util.concurrent.Callable;
22 import java.util.concurrent.ExecutionException;
23 import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
24 import org.opendaylight.genius.infra.Datastore.Configuration;
25 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
26 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
27 import org.opendaylight.genius.infra.TypedReadWriteTransaction;
28 import org.opendaylight.genius.infra.TypedWriteTransaction;
29 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
30 import org.opendaylight.genius.itm.cache.OfEndPointCache;
31 import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
32 import org.opendaylight.genius.itm.globals.ITMConstants;
33 import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
34 import org.opendaylight.genius.itm.impl.ItmUtils;
35 import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig;
36 import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
37 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
38 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
39 import org.opendaylight.mdsal.binding.api.DataBroker;
40 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
41 import org.opendaylight.mdsal.common.api.ReadFailedException;
42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeLldp;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeLogicalGroup;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptions;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.OvsBridgeRefInfo;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntry;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntryKey;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpointsBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsStateBuilder;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTepsBuilder;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTepsKey;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsBuilder;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsKey;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
74 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
75 import org.opendaylight.yangtools.yang.common.OperationFailedException;
76 import org.opendaylight.yangtools.yang.common.Uint64;
77 import org.slf4j.Logger;
78 import org.slf4j.LoggerFactory;
80 public final class ItmInternalTunnelAddWorker {
82 private static final Logger LOG = LoggerFactory.getLogger(ItmInternalTunnelAddWorker.class) ;
84 private final ItmConfig itmCfg;
85 private final Integer monitorInterval;
86 private final boolean isTunnelMonitoringEnabled;
87 private final Class<? extends TunnelMonitoringTypeBase> monitorProtocol;
89 private final DataBroker dataBroker;
90 private final ManagedNewTransactionRunner txRunner;
91 private final JobCoordinator jobCoordinator;
92 private final DirectTunnelUtils directTunnelUtils;
93 private final IInterfaceManager interfaceManager;
94 private final OvsBridgeRefEntryCache ovsBridgeRefEntryCache;
95 private final OfEndPointCache ofEndPointCache;
96 private final DataTreeEventCallbackRegistrar eventCallbacks;
98 public ItmInternalTunnelAddWorker(DataBroker dataBroker, JobCoordinator jobCoordinator,
99 TunnelMonitoringConfig tunnelMonitoringConfig, ItmConfig itmCfg,
100 DirectTunnelUtils directTunnelUtil,
101 IInterfaceManager interfaceManager,
102 OvsBridgeRefEntryCache ovsBridgeRefEntryCache,
103 OfEndPointCache ofEndPointCache,
104 DataTreeEventCallbackRegistrar eventCallbacks) {
105 this.dataBroker = dataBroker;
106 this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
107 this.jobCoordinator = jobCoordinator;
108 this.itmCfg = itmCfg;
109 this.directTunnelUtils = directTunnelUtil;
110 this.interfaceManager = interfaceManager;
111 this.ovsBridgeRefEntryCache = ovsBridgeRefEntryCache;
112 this.ofEndPointCache = ofEndPointCache;
113 this.eventCallbacks = eventCallbacks;
115 isTunnelMonitoringEnabled = tunnelMonitoringConfig.isTunnelMonitoringEnabled();
116 monitorProtocol = tunnelMonitoringConfig.getMonitorProtocol();
117 monitorInterval = tunnelMonitoringConfig.getMonitorInterval();
120 public List<ListenableFuture<Void>> buildAllTunnels(IMdsalApiManager mdsalManager, List<DPNTEPsInfo> cfgdDpnList,
121 Collection<DPNTEPsInfo> meshedDpnList) {
122 LOG.trace("Building tunnels with DPN List {} " , cfgdDpnList);
123 if (null == cfgdDpnList || cfgdDpnList.isEmpty()) {
124 LOG.error(" Build Tunnels was invoked with empty list");
125 return Collections.emptyList();
128 return Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
129 for (DPNTEPsInfo dpn : cfgdDpnList) {
130 //#####if dpn is not in meshedDpnList
131 buildTunnelFrom(tx, dpn, meshedDpnList, mdsalManager);
132 if (meshedDpnList != null) {
133 meshedDpnList.add(dpn);
135 // Update the config datastore -- FIXME -- Error Handling
136 updateDpnTepInfoToConfig(tx, dpn, directTunnelUtils);
141 private static void updateDpnTepInfoToConfig(TypedWriteTransaction<Configuration> tx, DPNTEPsInfo dpn,
142 DirectTunnelUtils directTunnelUtils) throws ExecutionException, InterruptedException, OperationFailedException {
143 LOG.debug("Updating CONFIGURATION datastore with DPN {} ", dpn);
144 InstanceIdentifier<DpnEndpoints> dep = InstanceIdentifier.create(DpnEndpoints.class) ;
145 List<DPNTEPsInfo> dpnList = new ArrayList<>() ;
146 dpnList.add(new DPNTEPsInfoBuilder(dpn)
147 .setDstId(directTunnelUtils.allocateId(ITMConstants.ITM_IDPOOL_NAME, dpn.getDPNID().toString())).build());
148 DpnEndpoints tnlBuilder = new DpnEndpointsBuilder().setDPNTEPsInfo(dpnList).build() ;
149 tx.merge(dep, tnlBuilder);
152 private void buildTunnelFrom(TypedReadWriteTransaction<Configuration> tx, DPNTEPsInfo srcDpn,
153 Collection<DPNTEPsInfo> meshedDpnList, IMdsalApiManager mdsalManager)
154 throws ExecutionException, InterruptedException, OperationFailedException {
155 LOG.trace("Building tunnels from DPN {} " , srcDpn);
156 if (null == meshedDpnList || meshedDpnList.isEmpty()) {
157 LOG.debug("No DPN in the mesh ");
160 for (DPNTEPsInfo dstDpn: meshedDpnList) {
161 if (!srcDpn.equals(dstDpn)) {
162 wireUpWithinTransportZone(tx, srcDpn, dstDpn, mdsalManager);
168 private void wireUpWithinTransportZone(TypedReadWriteTransaction<Configuration> tx, DPNTEPsInfo srcDpn,
169 DPNTEPsInfo dstDpn, IMdsalApiManager mdsalManager)
170 throws ExecutionException, InterruptedException, OperationFailedException {
171 LOG.trace("Wiring up within Transport Zone for Dpns {}, {} " , srcDpn, dstDpn);
172 List<TunnelEndPoints> srcEndPts = srcDpn.nonnullTunnelEndPoints();
173 List<TunnelEndPoints> dstEndPts = dstDpn.nonnullTunnelEndPoints();
175 for (TunnelEndPoints srcte : srcEndPts) {
176 for (TunnelEndPoints dstte : dstEndPts) {
177 // Compare the Transport zones
178 if (!Objects.equals(srcDpn.getDPNID(), dstDpn.getDPNID())) {
179 if (!ItmUtils.getIntersection(srcte.nonnullTzMembership(),
180 dstte.nonnullTzMembership()).isEmpty()) {
182 wireUpBidirectionalTunnel(tx, srcte, dstte, srcDpn.getDPNID(), dstDpn.getDPNID(), mdsalManager);
183 if (!ItmTunnelAggregationHelper.isTunnelAggregationEnabled()) {
184 // CHECK THIS -- Assumption -- One end point per Dpn per transport zone
193 private void wireUpBidirectionalTunnel(TypedReadWriteTransaction<Configuration> tx, TunnelEndPoints srcte,
194 TunnelEndPoints dstte, Uint64 srcDpnId, Uint64 dstDpnId, IMdsalApiManager mdsalManager)
195 throws ExecutionException, InterruptedException, OperationFailedException {
196 // Setup the flow for LLDP monitoring -- PUNT TO CONTROLLER
198 if (monitorProtocol.isAssignableFrom(TunnelMonitoringTypeLldp.class)) {
199 ItmUtils.addTerminatingServiceTable(tx, srcDpnId, mdsalManager);
200 ItmUtils.addTerminatingServiceTable(tx, dstDpnId, mdsalManager);
202 // Create the forward direction tunnel
203 if (!wireUp(tx, srcte, dstte, srcDpnId, dstDpnId)) {
204 LOG.error("Could not build tunnel between end points {}, {} " , srcte, dstte);
207 // CHECK IF FORWARD IS NOT BUILT , REVERSE CAN BE BUILT
208 // Create the tunnel for the reverse direction
209 if (!wireUp(tx, dstte, srcte, dstDpnId, srcDpnId)) {
210 LOG.error("Could not build tunnel between end points {}, {} " , dstte, srcte);
214 private boolean wireUp(TypedWriteTransaction<Configuration> tx, TunnelEndPoints srcte, TunnelEndPoints dstte,
215 Uint64 srcDpnId, Uint64 dstDpnId)
216 throws ExecutionException, InterruptedException, OperationFailedException {
218 LOG.trace("Wiring between source tunnel end points {}, destination tunnel end points {}", srcte, dstte);
219 String interfaceName = srcte.getInterfaceName();
220 Class<? extends TunnelTypeBase> tunType = srcte.getTunnelType();
221 String tunTypeStr = srcte.getTunnelType().getName();
222 // Form the trunk Interface Name
224 String trunkInterfaceName = ItmUtils.getTrunkInterfaceName(interfaceName,
225 srcte.getIpAddress().stringValue(), dstte.getIpAddress().stringValue(), tunTypeStr);
227 String parentInterfaceName = null;
228 if (tunType.isAssignableFrom(TunnelTypeVxlan.class)) {
229 parentInterfaceName = createLogicalGroupTunnel(srcDpnId, dstDpnId);
231 if (interfaceManager.isItmDirectTunnelsEnabled()) {
232 createInternalDirectTunnels(srcte, dstte, srcDpnId, dstDpnId, tunType, trunkInterfaceName,
233 parentInterfaceName);
235 createTunnelInterface(srcte, dstte, srcDpnId, tunType, trunkInterfaceName, parentInterfaceName);
236 // also update itm-state ds?
237 createInternalTunnel(tx, srcDpnId, dstDpnId, tunType, trunkInterfaceName);
242 private void createTunnelInterface(TunnelEndPoints srcte, TunnelEndPoints dstte, Uint64 srcDpnId,
243 Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName, String parentInterfaceName) {
244 String gateway = srcte.getIpAddress().getIpv4Address() != null ? "0.0.0.0" : "::";
245 IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance(gateway);
246 IpAddress gwyIpAddress = gatewayIpObj;
247 LOG.debug(" Creating Trunk Interface with parameters trunk I/f Name - {}, parent I/f name - {}, "
248 + "source IP - {}, destination IP - {} gateway IP - {}",
249 trunkInterfaceName, srcte.getInterfaceName(), srcte.getIpAddress(), dstte.getIpAddress(), gwyIpAddress);
250 boolean useOfTunnel = ItmUtils.falseIfNull(srcte.isOptionOfTunnel());
252 List<TunnelOptions> tunOptions = ItmUtils.buildTunnelOptions(srcte, itmCfg);
253 Boolean isMonitorEnabled = !tunType.isAssignableFrom(TunnelTypeLogicalGroup.class) && isTunnelMonitoringEnabled;
254 Interface iface = ItmUtils.buildTunnelInterface(srcDpnId, trunkInterfaceName,
255 trunkInterfaceDecription(ItmUtils.convertTunnelTypetoString(tunType)),
256 true, tunType, srcte.getIpAddress(), dstte.getIpAddress(), true,
257 isMonitorEnabled, monitorProtocol, monitorInterval, useOfTunnel, parentInterfaceName, tunOptions);
258 LOG.debug(" Trunk Interface builder - {} ", iface);
259 InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(trunkInterfaceName);
260 LOG.debug(" Trunk Interface Identifier - {} ", trunkIdentifier);
261 LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", trunkIdentifier, iface);
262 ITMBatchingUtils.update(trunkIdentifier, iface, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
263 ItmUtils.ITM_CACHE.addInterface(iface);
266 private static String trunkInterfaceDecription(String type) {
267 return type + " Trunk Interface";
270 private static void createInternalTunnel(TypedWriteTransaction<Configuration> tx, Uint64 srcDpnId,
271 Uint64 dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName) {
272 InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(TunnelList.class)
273 .child(InternalTunnel.class, new InternalTunnelKey(dstDpnId, srcDpnId, tunType));
274 InternalTunnel tnl = ItmUtils.buildInternalTunnel(srcDpnId, dstDpnId, tunType, trunkInterfaceName);
275 // Switching to individual transaction submit as batching latencies is causing ELAN failures.
276 // Will revert when ELAN can handle this.
277 // ITMBatchingUtils.update(path, tnl, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
278 tx.mergeParentStructureMerge(path, tnl);
279 ItmUtils.ITM_CACHE.addInternalTunnel(tnl);
282 private String createLogicalGroupTunnel(Uint64 srcDpnId, Uint64 dstDpnId) {
283 boolean tunnelAggregationEnabled = ItmTunnelAggregationHelper.isTunnelAggregationEnabled();
284 if (!tunnelAggregationEnabled) {
287 String logicTunnelGroupName = ItmUtils.getLogicalTunnelGroupName(srcDpnId, dstDpnId);
288 ItmTunnelAggregationWorker addWorker =
289 new ItmTunnelAggregationWorker(logicTunnelGroupName, srcDpnId, dstDpnId, dataBroker);
290 jobCoordinator.enqueueJob(logicTunnelGroupName, addWorker);
291 return logicTunnelGroupName;
294 private static class ItmTunnelAggregationWorker implements Callable<List<? extends ListenableFuture<?>>> {
296 private final String logicTunnelGroupName;
297 private final Uint64 srcDpnId;
298 private final Uint64 dstDpnId;
299 private final ManagedNewTransactionRunner txRunner;
301 ItmTunnelAggregationWorker(String logicGroupName, Uint64 srcDpnId, Uint64 dstDpnId, DataBroker broker) {
302 this.logicTunnelGroupName = logicGroupName;
303 this.srcDpnId = srcDpnId;
304 this.dstDpnId = dstDpnId;
305 this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
309 public List<ListenableFuture<Void>> call() {
310 return singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
311 //The logical tunnel interface be created only when the first tunnel interface on each OVS is created
312 InternalTunnel tunnel = ItmUtils.ITM_CACHE.getInternalTunnel(logicTunnelGroupName);
313 if (tunnel == null) {
314 LOG.info("MULTIPLE_VxLAN_TUNNELS: add the logical tunnel group {} because a first tunnel"
315 + " interface on srcDpnId {} dstDpnId {} is created", logicTunnelGroupName, srcDpnId, dstDpnId);
316 createLogicalTunnelInterface(srcDpnId, TunnelTypeLogicalGroup.class, logicTunnelGroupName);
317 createInternalTunnel(tx, srcDpnId, dstDpnId, TunnelTypeLogicalGroup.class, logicTunnelGroupName);
319 LOG.debug("MULTIPLE_VxLAN_TUNNELS: not first tunnel on srcDpnId {} dstDpnId {}", srcDpnId,
325 private static void createLogicalTunnelInterface(Uint64 srcDpnId,
326 Class<? extends TunnelTypeBase> tunType, String interfaceName) {
327 Interface iface = ItmUtils.buildLogicalTunnelInterface(srcDpnId, interfaceName,
328 String.format("%s %s",ItmUtils.convertTunnelTypetoString(tunType), "Interface"), true);
329 InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(interfaceName);
330 ITMBatchingUtils.update(trunkIdentifier, iface, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
331 ItmUtils.ITM_CACHE.addInterface(iface);
335 private void createInternalDirectTunnels(TunnelEndPoints srcte, TunnelEndPoints dstte, Uint64 srcDpnId,
336 Uint64 dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName,
337 String parentInterfaceName) throws OperationFailedException {
338 IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance("0.0.0.0");
339 IpAddress gwyIpAddress = gatewayIpObj;
340 LOG.debug("Creating Trunk Interface with parameters trunk I/f Name - {}, parent I/f name - {}, source IP - {},"
341 + " destination IP - {} gateway IP - {}", trunkInterfaceName, parentInterfaceName,
342 srcte.getIpAddress(), dstte.getIpAddress(), gwyIpAddress) ;
344 boolean useOfTunnel = itmCfg.isUseOfTunnels();
346 List<TunnelOptions> tunOptions = ItmUtils.buildTunnelOptions(srcte, itmCfg);
347 Boolean isMonitorEnabled = !tunType.isAssignableFrom(TunnelTypeLogicalGroup.class) && isTunnelMonitoringEnabled;
348 Interface iface = ItmUtils.buildTunnelInterface(srcDpnId, trunkInterfaceName,
349 trunkInterfaceDecription(ItmUtils.convertTunnelTypetoString(srcte.getTunnelType())),
350 true, tunType, srcte.getIpAddress(), dstte.getIpAddress(), true,
351 isMonitorEnabled, monitorProtocol, monitorInterval, useOfTunnel, parentInterfaceName, tunOptions);
352 LOG.debug("Trunk Interface builder - {} ", iface);
354 final DpnTepsStateBuilder dpnTepsStateBuilder = new DpnTepsStateBuilder();
355 final DpnsTepsBuilder dpnsTepsBuilder = new DpnsTepsBuilder();
356 final List<DpnsTeps> dpnTeps = new ArrayList<>();
357 final List<RemoteDpns> remoteDpns = new ArrayList<>();
358 String ofTunnelPortName = null;
359 dpnsTepsBuilder.withKey(new DpnsTepsKey(srcDpnId));
360 dpnsTepsBuilder.setTunnelType(srcte.getTunnelType());
361 dpnsTepsBuilder.setSourceDpnId(srcDpnId);
363 String tunnelType = ItmUtils.convertTunnelTypetoString(srcte.getTunnelType());
364 ofTunnelPortName = DirectTunnelUtils.generateOfPortName(srcDpnId, tunnelType);
365 dpnsTepsBuilder.setOfTunnel(ofTunnelPortName);
367 RemoteDpnsBuilder remoteDpn = new RemoteDpnsBuilder();
368 remoteDpn.withKey(new RemoteDpnsKey(dstDpnId));
369 remoteDpn.setDestinationDpnId(dstDpnId);
370 remoteDpn.setTunnelName(trunkInterfaceName);
371 remoteDpn.setMonitoringEnabled(isTunnelMonitoringEnabled);
372 remoteDpn.setMonitoringInterval(monitorInterval);
373 remoteDpn.setInternal(true);
374 remoteDpns.add(remoteDpn.build());
375 dpnsTepsBuilder.setRemoteDpns(remoteDpns);
376 dpnTeps.add(dpnsTepsBuilder.build());
377 dpnTepsStateBuilder.setDpnsTeps(dpnTeps);
378 updateDpnTepInterfaceInfoToConfig(dpnTepsStateBuilder.build());
379 addTunnelConfiguration(iface, ofTunnelPortName);
382 private static void updateDpnTepInterfaceInfoToConfig(DpnTepsState dpnTeps) {
383 LOG.debug("Updating CONFIGURATION datastore with DPN-Teps {} ", dpnTeps);
384 InstanceIdentifier<DpnTepsState> dpnTepsII = InstanceIdentifier.create(DpnTepsState.class);
385 ITMBatchingUtils.updateContainer(dpnTepsII, dpnTeps, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
388 private void addTunnelConfiguration(Interface iface, String ofTunnelPortName)
389 throws ReadFailedException {
390 // ITM Direct Tunnels This transaction is not being used -- CHECK
391 ParentRefs parentRefs = iface.augmentation(ParentRefs.class);
392 if (parentRefs == null) {
393 LOG.warn("ParentRefs for interface: {} Not Found. Creation of Tunnel OF-Port not supported"
394 + " when dpid not provided.", iface.getName());
398 Uint64 dpId = parentRefs.getDatapathNodeIdentifier();
400 LOG.warn("dpid for interface: {} Not Found. No DPID provided. Creation of OF-Port not supported.",
404 String tunnelName = ofTunnelPortName != null ? ofTunnelPortName : iface.getName();
405 // create bridge on switch, if switch is connected
406 Optional<OvsBridgeRefEntry> ovsBridgeRefEntry = ovsBridgeRefEntryCache.get(dpId);
407 LOG.info("adding tunnel port configuration for tunnelName: {}", tunnelName);
408 if (createTunnelPort(dpId)) {
409 LOG.debug("creating dpn tunnel mapping for dpn: {} tunnelName: {}", dpId, tunnelName);
410 DirectTunnelUtils.createBridgeTunnelEntryInConfigDS(dpId, iface.getName());
411 if (ofTunnelPortName != null) {
412 ofEndPointCache.add(dpId, tunnelName);
414 if (ovsBridgeRefEntry.isPresent()) {
415 LOG.debug("creating bridge interface on dpn {}", dpId);
416 InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
417 (InstanceIdentifier<OvsdbBridgeAugmentation>) ovsBridgeRefEntry.get()
418 .getOvsBridgeReference().getValue();
419 LOG.debug("adding port to the bridge:{} tunnelName: {}", bridgeIid, tunnelName);
420 addPortToBridge(bridgeIid, iface, tunnelName);
422 LOG.debug("Bridge not found. Registering Eventcallback for dpid {}", dpId);
424 InstanceIdentifier<OvsBridgeRefEntry> bridgeRefEntryFromDS =
425 InstanceIdentifier.builder(OvsBridgeRefInfo.class)
426 .child(OvsBridgeRefEntry.class, new OvsBridgeRefEntryKey(dpId)).build();
428 eventCallbacks.onAdd(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryFromDS, (refEntryIid) -> {
429 addPortToBridgeOnCallback(iface, tunnelName, refEntryIid);
430 return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
431 }, Duration.ofMillis(5000), (id) -> {
433 Optional<OvsBridgeRefEntry> ovsBridgeRefEntryOnCallback = ovsBridgeRefEntryCache.get(dpId);
434 InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIidOnCallback =
435 (InstanceIdentifier<OvsdbBridgeAugmentation>) ovsBridgeRefEntryOnCallback.get()
436 .getOvsBridgeReference().getValue();
437 addPortToBridge(bridgeIidOnCallback, iface, tunnelName);
438 } catch (ReadFailedException e) {
439 LOG.error("Bridge not found in DS/cache for dpId {}", dpId);
446 private void addPortToBridge(InstanceIdentifier<?> bridgeIid, Interface iface, String portName) {
447 IfTunnel ifTunnel = iface.augmentation(IfTunnel.class);
448 if (ifTunnel != null) {
449 directTunnelUtils.addTunnelPortToBridge(ifTunnel, bridgeIid, iface, portName);
453 private boolean createTunnelPort(Uint64 dpId) {
454 if (!itmCfg.isUseOfTunnels()) {
457 return ofEndPointCache.get(dpId) == null;
460 private void addPortToBridgeOnCallback(Interface iface, String portName, OvsBridgeRefEntry bridgeRefEntry) {
461 InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
462 (InstanceIdentifier<OvsdbBridgeAugmentation>) bridgeRefEntry.getOvsBridgeReference().getValue();
463 addPortToBridge(bridgeIid, iface, portName);