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