import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.Set;
+import java.util.Map.Entry;
+import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
+import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
+import org.opendaylight.genius.itm.cache.DpnTepStateCache;
+import org.opendaylight.genius.itm.cache.OvsBridgeEntryCache;
+import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
+import org.opendaylight.genius.itm.cache.TunnelStateCache;
import org.opendaylight.genius.itm.confighelpers.HwVtep;
+import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker;
import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelAddWorker;
import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelDeleteWorker;
import org.opendaylight.genius.itm.confighelpers.ItmTepAddWorker;
import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedMoveWorker;
import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedRemoveWorker;
import org.opendaylight.genius.itm.globals.ITMConstants;
-import org.opendaylight.genius.itm.impl.ITMManager;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.itm.recovery.impl.ItmServiceRecoveryHandler;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.serviceutils.srm.RecoverableListener;
+import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
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.opendaylight.genius.idmanager.rev160406.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
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.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.NotHostedTransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TepsNotHostedInTransportZone;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TepsNotHostedInTransportZoneKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZone;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZoneKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.tepsnothostedintransportzone.UnknownVteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
* This is used to handle interfaces for base of-ports.
*/
@Singleton
-public class TransportZoneListener extends AsyncDataTreeChangeListenerBase<TransportZone, TransportZoneListener>
- implements AutoCloseable {
+public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<TransportZone>
+ implements RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(TransportZoneListener.class);
private final DataBroker dataBroker;
private final JobCoordinator jobCoordinator;
- private final IdManagerService idManagerService;
private final IMdsalApiManager mdsalManager;
- private final ITMManager itmManager;
private final ItmConfig itmConfig;
private final ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker;
private final ItmInternalTunnelAddWorker itmInternalTunnelAddWorker;
+ private final ItmExternalTunnelAddWorker externalTunnelAddWorker;
+ private final DPNTEPsInfoCache dpnTEPsInfoCache;
@Inject
- public TransportZoneListener(final DataBroker dataBroker, final IdManagerService idManagerService,
- final IMdsalApiManager mdsalManager,final ITMManager itmManager,
- final ItmConfig itmConfig, JobCoordinator jobCoordinator) {
- super(TransportZone.class, TransportZoneListener.class);
+ public TransportZoneListener(final DataBroker dataBroker,
+ final IMdsalApiManager mdsalManager,
+ final ItmConfig itmConfig, final JobCoordinator jobCoordinator,
+ final TunnelMonitoringConfig tunnelMonitoringConfig,
+ final DPNTEPsInfoCache dpnTEPsInfoCache,
+ final TunnelStateCache tunnelStateCache,
+ final DirectTunnelUtils directTunnelUtils,
+ final DpnTepStateCache dpnTepStateCache, final OvsBridgeEntryCache ovsBridgeEntryCache,
+ final OvsBridgeRefEntryCache ovsBridgeRefEntryCache,
+ final IInterfaceManager interfaceManager,
+ final ServiceRecoveryRegistry serviceRecoveryRegistry) {
+ super(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(TransportZones.class).child(TransportZone.class));
this.dataBroker = dataBroker;
this.jobCoordinator = jobCoordinator;
- this.idManagerService = idManagerService;
initializeTZNode(dataBroker);
- this.itmManager = itmManager;
this.mdsalManager = mdsalManager;
this.itmConfig = itmConfig;
- this.itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator);
- this.itmInternalTunnelAddWorker = new ItmInternalTunnelAddWorker(dataBroker, jobCoordinator);
+ this.dpnTEPsInfoCache = dpnTEPsInfoCache;
+ this.itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator,
+ tunnelMonitoringConfig, interfaceManager, dpnTepStateCache, ovsBridgeEntryCache,
+ ovsBridgeRefEntryCache, tunnelStateCache, directTunnelUtils);
+ this.itmInternalTunnelAddWorker = new ItmInternalTunnelAddWorker(dataBroker, jobCoordinator,
+ tunnelMonitoringConfig, itmConfig, directTunnelUtils, interfaceManager, ovsBridgeRefEntryCache);
+ this.externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig, dpnTEPsInfoCache);
+ serviceRecoveryRegistry.addRecoverableListener(ItmServiceRecoveryHandler.getServiceRegistryKey(), this);
}
- @PostConstruct
- public void start() {
- registerListener(LogicalDatastoreType.CONFIGURATION, this.dataBroker);
- LOG.info("tzChangeListener Started");
+ @Override
+ public void registerListener() {
+ register();
}
@Override
- @PreDestroy
- public void close() {
- LOG.info("tzChangeListener Closed");
+ public void deregisterListener() {
+ close();
}
@SuppressWarnings("checkstyle:IllegalCatch")
}
@Override
- protected InstanceIdentifier<TransportZone> getWildCardPath() {
- return InstanceIdentifier.create(TransportZones.class).child(TransportZone.class);
- }
-
- @Override
- protected TransportZoneListener getDataTreeChangeListener() {
- return TransportZoneListener.this;
- }
-
- @Override
- protected void remove(InstanceIdentifier<TransportZone> key, TransportZone tzOld) {
- LOG.debug("Received Transport Zone Remove Event: {}, {}", key, tzOld);
-
- boolean allowTunnelDeletion = false;
+ public void remove(@Nonnull InstanceIdentifier<TransportZone> instanceIdentifier,
+ @Nonnull TransportZone transportZone) {
+ LOG.debug("Received Transport Zone Remove Event: {}", transportZone);
+ boolean allowTunnelDeletion;
// check if TZ received for removal is default-transport-zone,
// if yes, then check if it is received from northbound, then
// do not entertain request and skip tunnels remove operation
// if def-tz removal request is due to def-tz-enabled flag is disabled or
// due to change in def-tz-tunnel-type, then allow def-tz tunnels deletion
- if (tzOld.getZoneName().equalsIgnoreCase(ITMConstants.DEFAULT_TRANSPORT_ZONE)) {
+ if (ITMConstants.DEFAULT_TRANSPORT_ZONE.equalsIgnoreCase(transportZone.getZoneName())) {
// Get TunnelTypeBase object for tunnel-type configured in config file
Class<? extends TunnelTypeBase> tunType = ItmUtils.getTunnelType(itmConfig.getDefTzTunnelType());
- if (!itmConfig.isDefTzEnabled() || !tzOld.getTunnelType().equals(tunType)) {
+ if (!itmConfig.isDefTzEnabled() || !Objects.equals(transportZone.getTunnelType(), tunType)) {
allowTunnelDeletion = true;
} else {
// this is case when def-tz removal request is from Northbound.
if (allowTunnelDeletion) {
//TODO : DPList code can be refactor with new specific class
// which implement TransportZoneValidator
- List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzOld);
- List<HwVtep> hwVtepList = createhWVteps(tzOld);
+ List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
+ List<HwVtep> hwVtepList = createhWVteps(transportZone);
LOG.trace("Delete: Invoking deleteTunnels in ItmManager with DpnList {}", opDpnList);
if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
LOG.trace("Delete: Invoking ItmManager with hwVtep List {} ", hwVtepList);
- jobCoordinator.enqueueJob(tzOld.getZoneName(),
- new ItmTepRemoveWorker(opDpnList, hwVtepList, tzOld, dataBroker,
- idManagerService, mdsalManager,
- itmInternalTunnelDeleteWorker));
+ jobCoordinator.enqueueJob(transportZone.getZoneName(),
+ new ItmTepRemoveWorker(opDpnList, hwVtepList, transportZone, dataBroker, mdsalManager,
+ itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
}
}
}
@Override
- protected void update(InstanceIdentifier<TransportZone> key, TransportZone tzOld, TransportZone tzNew) {
- LOG.debug("Received Transport Zone Update Event: Key - {}, Old - {}, Updated - {}", key, tzOld, tzNew);
- List<DPNTEPsInfo> oldDpnTepsList = createDPNTepInfo(tzOld);
- List<DPNTEPsInfo> newDpnTepsList = createDPNTepInfo(tzNew);
+ public void update(@Nonnull InstanceIdentifier<TransportZone> instanceIdentifier,
+ @Nonnull TransportZone originalTransportZone, @Nonnull TransportZone updatedTransportZone) {
+ LOG.debug("Received Transport Zone Update Event: Old - {}, Updated - {}", originalTransportZone,
+ updatedTransportZone);
+ List<DPNTEPsInfo> oldDpnTepsList = createDPNTepInfo(originalTransportZone);
+ List<DPNTEPsInfo> newDpnTepsList = createDPNTepInfo(updatedTransportZone);
List<DPNTEPsInfo> oldDpnTepsListcopy = new ArrayList<>();
oldDpnTepsListcopy.addAll(oldDpnTepsList);
LOG.trace("oldcopy0 {}", oldDpnTepsListcopy);
LOG.trace("newcopy Size {}", newDpnTepsList.size());
if (!newDpnTepsList.isEmpty()) {
LOG.trace("Adding TEPs ");
- jobCoordinator.enqueueJob(tzNew.getZoneName(),
- new ItmTepAddWorker(newDpnTepsList, Collections.emptyList(), dataBroker,
- idManagerService, mdsalManager, itmConfig,
- itmInternalTunnelAddWorker));
+ jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(),
+ new ItmTepAddWorker(newDpnTepsList, Collections.emptyList(), dataBroker, mdsalManager, itmConfig,
+ itmInternalTunnelAddWorker, externalTunnelAddWorker, dpnTEPsInfoCache));
}
if (!oldDpnTepsList.isEmpty()) {
LOG.trace("Removing TEPs ");
- jobCoordinator.enqueueJob(tzNew.getZoneName(),
- new ItmTepRemoveWorker(oldDpnTepsList, Collections.emptyList(), tzOld, dataBroker,
- idManagerService, mdsalManager,
- itmInternalTunnelDeleteWorker));
+ jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(),
+ new ItmTepRemoveWorker(oldDpnTepsList, Collections.emptyList(), originalTransportZone, dataBroker,
+ mdsalManager, itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
}
- List<HwVtep> oldHwList = createhWVteps(tzOld);
- List<HwVtep> newHwList = createhWVteps(tzNew);
+ List<HwVtep> oldHwList = createhWVteps(originalTransportZone);
+ List<HwVtep> newHwList = createhWVteps(updatedTransportZone);
List<HwVtep> oldHwListcopy = new ArrayList<>();
oldHwListcopy.addAll(oldHwList);
LOG.trace("oldHwListcopy0 {}", oldHwListcopy);
LOG.trace("newHwListcopy {}", newHwListcopy);
if (!newHwList.isEmpty()) {
LOG.trace("Adding HW TEPs ");
- jobCoordinator.enqueueJob(tzNew.getZoneName(),
- new ItmTepAddWorker(Collections.emptyList(), newHwList, dataBroker,
- idManagerService, mdsalManager, itmConfig,
- itmInternalTunnelAddWorker));
+ jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(), new ItmTepAddWorker(Collections.emptyList(),
+ newHwList, dataBroker, mdsalManager, itmConfig, itmInternalTunnelAddWorker, externalTunnelAddWorker,
+ dpnTEPsInfoCache));
}
if (!oldHwList.isEmpty()) {
LOG.trace("Removing HW TEPs ");
- jobCoordinator.enqueueJob(tzNew.getZoneName(),
- new ItmTepRemoveWorker(Collections.emptyList(), oldHwList, tzOld, dataBroker,
- idManagerService, mdsalManager,
- itmInternalTunnelDeleteWorker));
+ jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(), new ItmTepRemoveWorker(
+ Collections.emptyList(), oldHwList, originalTransportZone, dataBroker, mdsalManager,
+ itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
}
}
@Override
- protected void add(InstanceIdentifier<TransportZone> key, TransportZone tzNew) {
- LOG.debug("Received Transport Zone Add Event: {}, {}", key, tzNew);
- List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzNew);
- List<HwVtep> hwVtepList = createhWVteps(tzNew);
- opDpnList.addAll(getDPNTepInfoFromNotHosted(tzNew));
+ public void add(@Nonnull TransportZone transportZone) {
+ LOG.debug("Received Transport Zone Add Event: {}", transportZone);
+ List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
+ List<HwVtep> hwVtepList = createhWVteps(transportZone);
+ opDpnList.addAll(getDPNTepInfoFromNotHosted(transportZone));
LOG.trace("Add: Operational dpnTepInfo - Before invoking ItmManager {}", opDpnList);
if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
LOG.trace("Add: Invoking ItmManager with DPN List {} ", opDpnList);
LOG.trace("Add: Invoking ItmManager with hwVtep List {} ", hwVtepList);
- jobCoordinator.enqueueJob(tzNew.getZoneName(),
- new ItmTepAddWorker(opDpnList, hwVtepList, dataBroker, idManagerService,
- mdsalManager, itmConfig, itmInternalTunnelAddWorker));
+ jobCoordinator.enqueueJob(transportZone.getZoneName(),
+ new ItmTepAddWorker(opDpnList, hwVtepList, dataBroker, mdsalManager, itmConfig,
+ itmInternalTunnelAddWorker, externalTunnelAddWorker, dpnTEPsInfoCache));
}
}
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(newZoneName);
Class<? extends TunnelTypeBase> tunnelType = tzNew.getTunnelType();
- TepsNotHostedInTransportZone tepNotHostedTransportZone = getNotHostedTransportZone(newZoneName).get();
- if (tepNotHostedTransportZone == null) {
+ TepsInNotHostedTransportZone tepsInNotHostedTransportZone = getNotHostedTransportZone(newZoneName).get();
+ if (tepsInNotHostedTransportZone == null) {
return notHostedDpnTepInfo;
}
- List<UnknownVteps> unVtepsLst = tepNotHostedTransportZone.getUnknownVteps();
+ List<UnknownVteps> unVtepsLst = tepsInNotHostedTransportZone.getUnknownVteps();
List<Vteps> vtepsList = new ArrayList<>();
if (unVtepsLst != null && !unVtepsLst.isEmpty()) {
for (UnknownVteps vteps : unVtepsLst) {
BigInteger dpnID = vteps.getDpnId();
String port = ITMConstants.DUMMY_PORT;
int vlanID = ITMConstants.DUMMY_VLANID;
- IpPrefix ipPrefix = new IpPrefix(ITMConstants.DUMMY_PREFIX.toCharArray());
- IpAddress gatewayIP = new IpAddress(ITMConstants.DUMMY_GATEWAY_IP.toCharArray());
+ IpPrefix ipPrefix = IpPrefixBuilder.getDefaultInstance(ITMConstants.DUMMY_PREFIX);
+ IpAddress gatewayIP = IpAddressBuilder.getDefaultInstance(ITMConstants.DUMMY_GATEWAY_IP);
IpAddress ipAddress = vteps.getIpAddress();
boolean useOfTunnel = ItmUtils.falseIfNull(vteps.isOfTunnel());
String tos = vteps.getOptionTunnelTos();
jobCoordinator.enqueueJob(newZoneName, moveWorker);
if (mapNotHostedDPNToTunnelEndpt.size() > 0) {
- Set<BigInteger> keys = mapNotHostedDPNToTunnelEndpt.keySet();
- for (BigInteger key: keys) {
- DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(key, mapNotHostedDPNToTunnelEndpt.get(key));
+ for (Entry<BigInteger, List<TunnelEndPoints>> entry: mapNotHostedDPNToTunnelEndpt.entrySet()) {
+ DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
notHostedDpnTepInfo.add(newDpnTepsInfo);
}
}
private Vteps createVtepFromUnKnownVteps(BigInteger dpnID, IpAddress ipAddress, String port) {
VtepsKey vtepkey = new VtepsKey(dpnID, port);
- Vteps vtepObj = new VtepsBuilder().setDpnId(dpnID).setIpAddress(ipAddress).setKey(vtepkey)
+ Vteps vtepObj = new VtepsBuilder().setDpnId(dpnID).setIpAddress(ipAddress).withKey(vtepkey)
.setPortname(port).build();
return vtepObj;
}
return isPresent;
}
- public Optional<TepsNotHostedInTransportZone> getNotHostedTransportZone(String transportZoneName) {
- InstanceIdentifier<TepsNotHostedInTransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
- .child(TepsNotHostedInTransportZone.class,
- new TepsNotHostedInTransportZoneKey(transportZoneName)).build();
- Optional<TepsNotHostedInTransportZone> tzNotHostedOptional =
- ItmUtils.read(LogicalDatastoreType.CONFIGURATION, tzonePath, dataBroker);
- return tzNotHostedOptional;
+ public Optional<TepsInNotHostedTransportZone> getNotHostedTransportZone(String transportZoneName) {
+ InstanceIdentifier<TepsInNotHostedTransportZone> notHostedTzPath = InstanceIdentifier
+ .builder(NotHostedTransportZones.class).child(TepsInNotHostedTransportZone.class,
+ new TepsInNotHostedTransportZoneKey(transportZoneName)).build();
+ Optional<TepsInNotHostedTransportZone> tepsInNotHostedTransportZoneOptional =
+ ItmUtils.read(LogicalDatastoreType.OPERATIONAL, notHostedTzPath, dataBroker);
+ return tepsInNotHostedTransportZoneOptional;
}
private List<DPNTEPsInfo> createDPNTepInfo(TransportZone transportZone) {
}
if (!mapDPNToTunnelEndpt.isEmpty()) {
- Set<BigInteger> keys = mapDPNToTunnelEndpt.keySet();
- LOG.trace("List of dpns in the Map: {} ", keys);
- for (BigInteger key : keys) {
- DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(key, mapDPNToTunnelEndpt.get(key));
+ LOG.trace("List of dpns in the Map: {} ", mapDPNToTunnelEndpt.keySet());
+ for (Entry<BigInteger, List<TunnelEndPoints>> entry : mapDPNToTunnelEndpt.entrySet()) {
+ DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
dpnTepInfo.add(newDpnTepsInfo);
}
}
HwVtep hwVtep = ItmUtils.createHwVtepObject(topologyId, nodeId, ipAddress, ipPrefix, gatewayIP,
vlanID, tunnelType, transportZone);
- if (hwVtepsList != null) {
- LOG.trace("Existing hwVteps");
- hwVtepsList.add(hwVtep);
- } else {
- LOG.trace("Adding new HwVtep {} info ", hwVtep.getHwIp());
- hwVtepsList.add(hwVtep);
- }
+ LOG.trace("Adding new HwVtep {} info ", hwVtep.getHwIp());
+ hwVtepsList.add(hwVtep);
}
}
}
Code Review / genius.git / blobdiff