package org.opendaylight.genius.itm.confighelpers;
import com.google.common.base.Optional;
-import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListenableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.math.BigInteger;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import org.apache.commons.net.util.SubnetUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.tunnel.optional.params.TunnelOptions;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
public class ItmExternalTunnelAddWorker {
private static final Logger LOG = LoggerFactory.getLogger(ItmExternalTunnelAddWorker.class);
- private static Boolean monitorEnabled;
- private static Integer monitorInterval;
- private static Class<? extends TunnelMonitoringTypeBase> monitorProtocol;
+ private final DataBroker dataBroker;
+ private final ItmConfig itmConfig;
+ private final DPNTEPsInfoCache dpnTEPsInfoCache;
- private static final FutureCallback<Void> DEFAULT_CALLBACK =
- new FutureCallback<Void>() {
- @Override
- public void onSuccess(Void result) {
- LOG.debug("Success in Datastore operation");
- }
-
- @Override
- public void onFailure(Throwable error) {
- LOG.error("Error in Datastore operation", error);
- }
-
- };
+ public ItmExternalTunnelAddWorker(DataBroker dataBroker, ItmConfig itmConfig, DPNTEPsInfoCache dpnTEPsInfoCache) {
+ this.dataBroker = dataBroker;
+ this.itmConfig = itmConfig;
+ this.dpnTEPsInfoCache = dpnTEPsInfoCache;
+ }
- public static List<ListenableFuture<Void>> buildTunnelsToExternalEndPoint(DataBroker dataBroker,
- IdManagerService idManagerService,
- List<DPNTEPsInfo> cfgDpnList,
- IpAddress extIp,
- Class<? extends TunnelTypeBase> tunType) {
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
+ public List<ListenableFuture<Void>> buildTunnelsToExternalEndPoint(Collection<DPNTEPsInfo> cfgDpnList,
+ IpAddress extIp, Class<? extends TunnelTypeBase> tunType) {
if (null != cfgDpnList) {
+ WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
for (DPNTEPsInfo teps : cfgDpnList) {
// CHECK -- Assumption -- Only one End Point / Dpn for GRE/Vxlan Tunnels
TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0);
String interfaceName = firstEndPt.getInterfaceName();
String tunTypeStr = tunType.getName();
- String trunkInterfaceName = ItmUtils.getTrunkInterfaceName(idManagerService, interfaceName,
+ String trunkInterfaceName = ItmUtils.getTrunkInterfaceName(interfaceName,
new String(firstEndPt.getIpAddress().getValue()),
new String(extIp.getValue()), tunTypeStr);
char[] subnetMaskArray = firstEndPt.getSubnetMask().getValue();
boolean useOfTunnel = ItmUtils.falseIfNull(firstEndPt.isOptionOfTunnel());
+ List<TunnelOptions> tunOptions = ItmUtils.buildTunnelOptions(firstEndPt, itmConfig);
String subnetMaskStr = String.valueOf(subnetMaskArray);
SubnetUtils utils = new SubnetUtils(subnetMaskStr);
String dcGwyIpStr = String.valueOf(extIp.getValue());
- IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray());
+ IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance("0.0.0.0");
IpAddress gwyIpAddress =
utils.getInfo().isInRange(dcGwyIpStr) ? gatewayIpObj : firstEndPt.getGwIpAddress();
LOG.debug(" Creating Trunk Interface with parameters trunk I/f Name - {}, parent I/f name - {},"
Interface iface = ItmUtils.buildTunnelInterface(teps.getDPNID(), trunkInterfaceName,
String.format("%s %s", ItmUtils.convertTunnelTypetoString(tunType), "Trunk Interface"), true,
tunType, firstEndPt.getIpAddress(), extIp, gwyIpAddress, firstEndPt.getVLANID(), false, false,
- ITMConstants.DEFAULT_MONITOR_PROTOCOL, null, useOfTunnel);
+ ITMConstants.DEFAULT_MONITOR_PROTOCOL, null, useOfTunnel, tunOptions);
LOG.debug(" Trunk Interface builder - {} ", iface);
InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(trunkInterfaceName);
transaction.merge(LogicalDatastoreType.CONFIGURATION, trunkIdentifier, iface, true);
// update external_tunnel_list ds
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
- .child(ExternalTunnel.class, new ExternalTunnelKey(extIp.toString(),
+ .child(ExternalTunnel.class, new ExternalTunnelKey(String.valueOf(extIp.getValue()),
teps.getDPNID().toString(), tunType));
- ExternalTunnel tnl = ItmUtils.buildExternalTunnel(teps.getDPNID().toString(), extIp.toString(),
- tunType, trunkInterfaceName);
+ ExternalTunnel tnl = ItmUtils.buildExternalTunnel(teps.getDPNID().toString(),
+ String.valueOf(extIp.getValue()), tunType, trunkInterfaceName);
transaction.merge(LogicalDatastoreType.CONFIGURATION, path, tnl, true);
}
- futures.add(transaction.submit());
+ return Collections.singletonList(transaction.submit());
}
- return futures;
+ return Collections.emptyList();
}
- public static List<ListenableFuture<Void>> buildTunnelsFromDpnToExternalEndPoint(DataBroker dataBroker,
- IdManagerService idManagerService,
- List<BigInteger> dpnId,
- IpAddress extIp,
- Class<? extends TunnelTypeBase>
- tunType) {
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- List<DPNTEPsInfo> cfgDpnList = dpnId == null ? ItmUtils.getTunnelMeshInfo(dataBroker)
- : ItmUtils.getDpnTepListFromDpnId(dataBroker, dpnId);
- futures = buildTunnelsToExternalEndPoint(dataBroker, idManagerService, cfgDpnList, extIp, tunType);
- return futures;
+ public List<ListenableFuture<Void>> buildTunnelsFromDpnToExternalEndPoint(List<BigInteger> dpnId, IpAddress extIp,
+ Class<? extends TunnelTypeBase> tunType) {
+ Collection<DPNTEPsInfo> cfgDpnList = dpnId == null ? dpnTEPsInfoCache.getAllPresent()
+ : ItmUtils.getDpnTepListFromDpnId(dpnTEPsInfoCache, dpnId);
+ return buildTunnelsToExternalEndPoint(cfgDpnList, extIp, tunType);
}
- public static List<ListenableFuture<Void>> buildHwVtepsTunnels(DataBroker dataBroker,
- IdManagerService idManagerService,
- List<DPNTEPsInfo> cfgdDpnList,
- List<HwVtep> cfgdHwVteps) {
+ public List<ListenableFuture<Void>> buildHwVtepsTunnels(List<DPNTEPsInfo> cfgdDpnList, List<HwVtep> cfgdHwVteps) {
+ Integer monitorInterval = ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL;
+ Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
+
List<ListenableFuture<Void>> futures = new ArrayList<>();
WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
- monitorInterval = ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL;
- monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
- monitorEnabled = ItmUtils.readMonitoringStateFromCache(dataBroker);
if (null != cfgdDpnList && !cfgdDpnList.isEmpty()) {
- LOG.trace("calling tunnels from css {}",cfgdDpnList);
- tunnelsFromCSS(cfgdDpnList, idManagerService , futures, writeTransaction , dataBroker);
+ LOG.trace("calling tunnels from OVS {}",cfgdDpnList);
+ tunnelsFromOVS(cfgdDpnList, writeTransaction, monitorInterval, monitorProtocol);
}
if (null != cfgdHwVteps && !cfgdHwVteps.isEmpty()) {
LOG.trace("calling tunnels from hwTep {}",cfgdHwVteps);
- tunnelsFromhWVtep(cfgdHwVteps, idManagerService, futures, writeTransaction, dataBroker);
+ tunnelsFromhWVtep(cfgdHwVteps, writeTransaction, monitorInterval, monitorProtocol);
}
if (cfgdDpnList != null && !cfgdDpnList.isEmpty() || cfgdHwVteps != null && !cfgdHwVteps.isEmpty()) {
return futures;
}
- private static void tunnelsFromCSS(List<DPNTEPsInfo> cfgdDpnList, IdManagerService idManagerService,
- List<ListenableFuture<Void>> futures, WriteTransaction transaction,
- DataBroker dataBroker) {
- Boolean monitorEnabled = ItmUtils.readMonitoringStateFromCache(dataBroker);
- Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
+ private void tunnelsFromOVS(List<DPNTEPsInfo> cfgdDpnList, WriteTransaction transaction, Integer monitorInterval,
+ Class<? extends TunnelMonitoringTypeBase> monitorProtocol) {
for (DPNTEPsInfo dpn : cfgdDpnList) {
LOG.trace("processing dpn {}" , dpn);
if (dpn.getTunnelEndPoints() != null && !dpn.getTunnelEndPoints().isEmpty()) {
for (TunnelEndPoints tep : dpn.getTunnelEndPoints()) {
for (TzMembership zone: tep.getTzMembership()) {
- createTunnelsFromOVSinTransportZone(zone.getZoneName(), dpn, tep, idManagerService,
- futures, transaction, dataBroker);
+ createTunnelsFromOVSinTransportZone(zone.getZoneName(), dpn, tep,
+ transaction, monitorInterval, monitorProtocol);
}
}
}
}
}
- private static void createTunnelsFromOVSinTransportZone(String zoneName, DPNTEPsInfo dpn, TunnelEndPoints tep,
- IdManagerService idManagerService,
- List<ListenableFuture<Void>> futures,
- WriteTransaction transaction, DataBroker dataBroker) {
+ private void createTunnelsFromOVSinTransportZone(String zoneName, DPNTEPsInfo dpn, TunnelEndPoints tep,
+ WriteTransaction transaction, Integer monitorInterval,
+ Class<? extends TunnelMonitoringTypeBase> monitorProtocol) {
InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zoneName)).build();
Optional<TransportZone> transportZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
if (!wireUp(dpn.getDPNID(), tep.getPortname(), sub.getVlanId(),
tep.getIpAddress(), useOfTunnel, nodeId, hwVtepDS.getIpAddress(),
tep.getSubnetMask(), sub.getGatewayIp(), sub.getPrefix(),
- transportZone.getTunnelType(), false, monitorProtocol, monitorInterval,
- idManagerService, dataBroker, futures, transaction)) {
+ transportZone.getTunnelType(), false, monitorInterval, monitorProtocol,
+ transaction)) {
LOG.error("Unable to build tunnel {} -- {}",
tep.getIpAddress(), hwVtepDS.getIpAddress());
}
LOG.trace("wire up {} and {}", hwVtepDS,tep);
if (!wireUp(hwVtepDS.getTopologyId(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(),
cssID, tep.getIpAddress(), sub.getPrefix(), sub.getGatewayIp(),
- tep.getSubnetMask(), transportZone.getTunnelType(), false, monitorProtocol,
- monitorInterval, idManagerService, dataBroker, futures, transaction)) {
+ tep.getSubnetMask(), transportZone.getTunnelType(), false, monitorInterval,
+ monitorProtocol, transaction)) {
LOG.error("Unable to build tunnel {} -- {}",
hwVtepDS.getIpAddress(), tep.getIpAddress());
}
}
}
- private static void tunnelsFromhWVtep(List<HwVtep> cfgdHwVteps, IdManagerService idManagerService,
- List<ListenableFuture<Void>> futures, WriteTransaction transaction,
- DataBroker dataBroker) {
+ private void tunnelsFromhWVtep(List<HwVtep> cfgdHwVteps, WriteTransaction transaction,
+ Integer monitorInterval, Class<? extends TunnelMonitoringTypeBase> monitorProtocol) {
for (HwVtep hwTep : cfgdHwVteps) {
InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(hwTep.getTransportZone())).build();
Optional<TransportZone> transportZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
tzonePath, dataBroker);
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
- Boolean monitorEnabled = ItmUtils.readMonitoringStateFromCache(dataBroker);
- Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
if (transportZoneOptional.isPresent()) {
TransportZone tzone = transportZoneOptional.get();
//do we need to check tunnel type?
continue;//dont mesh with self
}
LOG.trace("wire up {} and {}",hwTep, hwVtepDS);
- if (!wireUp(hwTep.getTopo_id(), hwTep.getNode_id(), hwTep.getHwIp(),
+ if (!wireUp(hwTep.getTopoId(), hwTep.getNodeId(), hwTep.getHwIp(),
hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(), hwTep.getIpPrefix(),
- hwTep.getGatewayIP(), sub.getPrefix(), tunType,false,monitorProtocol,
- monitorInterval, idManagerService, dataBroker, futures, transaction)) {
+ hwTep.getGatewayIP(), sub.getPrefix(), tunType, false,
+ monitorInterval, monitorProtocol, transaction)) {
LOG.error("Unable to build tunnel {} -- {}",
hwTep.getHwIp(), hwVtepDS.getIpAddress());
}
//TOR2-TOR1
LOG.trace("wire up {} and {}", hwVtepDS,hwTep);
- if (!wireUp(hwTep.getTopo_id(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(),
- hwTep.getNode_id(), hwTep.getHwIp(), sub.getPrefix(), sub.getGatewayIp(),
- hwTep.getIpPrefix(), tunType, false, monitorProtocol, monitorInterval,
- idManagerService, dataBroker, futures, transaction)) {
+ if (!wireUp(hwTep.getTopoId(), hwVtepDS.getNodeId(), hwVtepDS.getIpAddress(),
+ hwTep.getNodeId(), hwTep.getHwIp(), sub.getPrefix(), sub.getGatewayIp(),
+ hwTep.getIpPrefix(), tunType, false, monitorInterval,
+ monitorProtocol, transaction)) {
LOG.error("Unable to build tunnel {} -- {}",
hwVtepDS.getIpAddress(), hwTep.getHwIp());
}
//TOR-OVS
String cssID = vtep.getDpnId().toString();
LOG.trace("wire up {} and {}",hwTep, vtep);
- if (!wireUp(hwTep.getTopo_id(), hwTep.getNode_id(), hwTep.getHwIp(), cssID,
+ if (!wireUp(hwTep.getTopoId(), hwTep.getNodeId(), hwTep.getHwIp(), cssID,
vtep.getIpAddress(), hwTep.getIpPrefix(), hwTep.getGatewayIP(),
- sub.getPrefix(), tunType,false, monitorProtocol, monitorInterval,
- idManagerService, dataBroker, futures, transaction)) {
+ sub.getPrefix(), tunType,false, monitorInterval, monitorProtocol,
+ transaction)) {
LOG.error("Unable to build tunnel {} -- {}",
hwTep.getHwIp(), vtep.getIpAddress());
}
LOG.trace("wire up {} and {}", vtep,hwTep);
boolean useOfTunnel = ItmUtils.falseIfNull(vtep.isOptionOfTunnel());
if (!wireUp(vtep.getDpnId(), vtep.getPortname(), sub.getVlanId(), vtep.getIpAddress(),
- useOfTunnel, hwTep.getNode_id(),hwTep.getHwIp(),sub.getPrefix(),
- sub.getGatewayIp(),hwTep.getIpPrefix(), tunType,false,monitorProtocol,
- monitorInterval, idManagerService, dataBroker, futures, transaction)) {
- //do nothing
+ useOfTunnel, hwTep.getNodeId(),hwTep.getHwIp(),sub.getPrefix(),
+ sub.getGatewayIp(),hwTep.getIpPrefix(), tunType, false,
+ monitorInterval, monitorProtocol, transaction)) {
+ LOG.debug("wireUp returned false");
}
}
}
//for tunnels from TOR device
- private static boolean wireUp(String topoId, String srcNodeid, IpAddress srcIp, String dstNodeId, IpAddress dstIp,
- IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet,
- Class<? extends TunnelTypeBase> tunType,Boolean monitorEnabled,
- Class<? extends TunnelMonitoringTypeBase> monitorProtocol, Integer monitorInterval,
- IdManagerService idManagerService, DataBroker dataBroker,
- List<ListenableFuture<Void>> futures, WriteTransaction transaction) {
- IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray());
+ private boolean wireUp(String topoId, String srcNodeid, IpAddress srcIp, String dstNodeId, IpAddress dstIp,
+ IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet, Class<? extends TunnelTypeBase> tunType,
+ Boolean monitorEnabled, Integer monitorInterval, Class<? extends TunnelMonitoringTypeBase> monitorProtocol,
+ WriteTransaction transaction) {
+ IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance("0.0.0.0");
IpAddress gwyIpAddress = srcSubnet.equals(dstSubnet) ? gatewayIpObj : gwIp;
String parentIf = ItmUtils.getHwParentIf(topoId, srcNodeid);
String tunTypeStr = tunType.getName();
- String tunnelIfName = ItmUtils.getTrunkInterfaceName(idManagerService, parentIf,
+ String tunnelIfName = ItmUtils.getTrunkInterfaceName(parentIf,
new String(srcIp.getValue()), new String(dstIp.getValue()), tunTypeStr);
LOG.debug(" Creating ExternalTrunk Interface with parameters Name - {}, parent I/f name - {}, "
+ "source IP - {}, destination IP - {} gateway IP - {}", tunnelIfName, parentIf, srcIp,
InstanceIdentifier<Interface> ifIID = InstanceIdentifier.builder(Interfaces.class)
.child(Interface.class, new InterfaceKey(tunnelIfName)).build();
LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", ifIID, hwTunnelIf);
- ItmUtils.itmCache.addInterface(hwTunnelIf);
+ ItmUtils.ITM_CACHE.addInterface(hwTunnelIf);
transaction.merge(LogicalDatastoreType.CONFIGURATION, ifIID, hwTunnelIf, true);
// also update itm-state ds?
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
ExternalTunnel tnl = ItmUtils.buildExternalTunnel(getExternalTunnelKey(srcNodeid),
getExternalTunnelKey(dstNodeId), tunType, tunnelIfName);
transaction.merge(LogicalDatastoreType.CONFIGURATION, path, tnl, true);
- ItmUtils.itmCache.addExternalTunnel(tnl);
+ ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
return true;
}
//for tunnels from OVS
- private static boolean wireUp(BigInteger dpnId, String portname, Integer vlanId, IpAddress srcIp,
- Boolean remoteIpFlow, String dstNodeId, IpAddress dstIp, IpPrefix srcSubnet,
- IpAddress gwIp, IpPrefix dstSubnet, Class<? extends TunnelTypeBase> tunType,
- Boolean monitorEnabled, Class<? extends TunnelMonitoringTypeBase> monitorProtocol,
- Integer monitorInterval, IdManagerService idManagerService, DataBroker dataBroker,
- List<ListenableFuture<Void>> futures, WriteTransaction transaction) {
- IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray());
+ private boolean wireUp(BigInteger dpnId, String portname, Integer vlanId, IpAddress srcIp, Boolean remoteIpFlow,
+ String dstNodeId, IpAddress dstIp, IpPrefix srcSubnet, IpAddress gwIp, IpPrefix dstSubnet,
+ Class<? extends TunnelTypeBase> tunType, Boolean monitorEnabled, Integer monitorInterval,
+ Class<? extends TunnelMonitoringTypeBase> monitorProtocol, WriteTransaction transaction) {
+ IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance("0.0.0.0");
IpAddress gwyIpAddress = srcSubnet.equals(dstSubnet) ? gatewayIpObj : gwIp;
String parentIf = ItmUtils.getInterfaceName(dpnId, portname, vlanId);
String tunTypeStr = tunType.getName();
- String tunnelIfName = ItmUtils.getTrunkInterfaceName(idManagerService, parentIf,
+ String tunnelIfName = ItmUtils.getTrunkInterfaceName(parentIf,
new String(srcIp.getValue()), new String(dstIp.getValue()), tunTypeStr);
LOG.debug(" Creating ExternalTrunk Interface with parameters Name - {}, parent I/f name - {}, "
+ "source IP - {}, destination IP - {} gateway IP - {}", tunnelIfName, parentIf, srcIp,
dstIp, gwyIpAddress);
Interface extTunnelIf = ItmUtils.buildTunnelInterface(dpnId, tunnelIfName,
String.format("%s %s", tunType.getName(), "Trunk Interface"), true, tunType, srcIp, dstIp, gwyIpAddress,
- vlanId, false,monitorEnabled, monitorProtocol, monitorInterval, remoteIpFlow);
+ vlanId, false,monitorEnabled, monitorProtocol, monitorInterval, remoteIpFlow, null);
InstanceIdentifier<Interface> ifIID = InstanceIdentifier.builder(Interfaces.class).child(Interface.class,
new InterfaceKey(tunnelIfName)).build();
LOG.trace(" Writing Trunk Interface to Config DS {}, {} ", ifIID, extTunnelIf);
transaction.merge(LogicalDatastoreType.CONFIGURATION, ifIID, extTunnelIf, true);
- ItmUtils.itmCache.addInterface(extTunnelIf);
+ ItmUtils.ITM_CACHE.addInterface(extTunnelIf);
InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(getExternalTunnelKey(dstNodeId),
dpnId.toString(), tunType));
getExternalTunnelKey(dstNodeId),
tunType, tunnelIfName);
transaction.merge(LogicalDatastoreType.CONFIGURATION, path, tnl, true);
- ItmUtils.itmCache.addExternalTunnel(tnl);
+ ItmUtils.ITM_CACHE.addExternalTunnel(tnl);
return true;
}
+ @SuppressFBWarnings("RV_CHECK_FOR_POSITIVE_INDEXOF")
static String getExternalTunnelKey(String nodeid) {
- if (nodeid.indexOf("physicalswitch") > 0) {
- nodeid = nodeid.substring(0, nodeid.indexOf("physicalswitch") - 1);
+ final int index = nodeid.indexOf("physicalswitch");
+ if (index > 0) {
+ nodeid = nodeid.substring(0, index - 1);
}
return nodeid;
}
}
-
Code Review / genius.git / blobdiff