itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java

   1 /*
   2  * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.genius.itm.listeners;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import java.math.BigInteger;
  14 import java.util.ArrayList;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Map.Entry;
  19 import java.util.concurrent.ConcurrentHashMap;
  20 import javax.annotation.Nonnull;
  21 import javax.inject.Inject;
  22 import javax.inject.Singleton;
  23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  27 import org.opendaylight.genius.datastoreutils.listeners.AbstractSyncDataTreeChangeListener;
  28 import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
  29 import org.opendaylight.genius.itm.confighelpers.HwVtep;
  30 import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker;
  31 import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelAddWorker;
  32 import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelDeleteWorker;
  33 import org.opendaylight.genius.itm.confighelpers.ItmTepAddWorker;
  34 import org.opendaylight.genius.itm.confighelpers.ItmTepRemoveWorker;
  35 import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedMoveWorker;
  36 import org.opendaylight.genius.itm.confighelpers.ItmTepsNotHostedRemoveWorker;
  37 import org.opendaylight.genius.itm.globals.ITMConstants;
  38 import org.opendaylight.genius.itm.impl.ItmUtils;
  39 import org.opendaylight.genius.itm.impl.TunnelMonitoringConfig;
  40 import org.opendaylight.genius.itm.recovery.impl.ItmServiceRecoveryHandler;
  41 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  42 import org.opendaylight.genius.srm.RecoverableListener;
  43 import org.opendaylight.genius.srm.ServiceRecoveryRegistry;
  44 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.NotHostedTransportZones;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZone;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZoneKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.tepsinnothostedtransportzone.UnknownVteps;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.VtepsBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.VtepsKey;
  66 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69
  70 /**
  71  * This class listens for interface creation/removal/update in Configuration DS.
  72  * This is used to handle interfaces for base of-ports.
  73  */
  74 @Singleton
  75 public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<TransportZone>
  76         implements RecoverableListener {
  77
  78     private static final Logger LOG = LoggerFactory.getLogger(TransportZoneListener.class);
  79
  80     private final DataBroker dataBroker;
  81     private final JobCoordinator jobCoordinator;
  82     private final IMdsalApiManager mdsalManager;
  83     private final ItmConfig itmConfig;
  84     private final ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker;
  85     private final ItmInternalTunnelAddWorker itmInternalTunnelAddWorker;
  86     private final ItmExternalTunnelAddWorker externalTunnelAddWorker;
  87     private final DPNTEPsInfoCache dpnTEPsInfoCache;
  88
  89     @Inject
  90     public TransportZoneListener(final DataBroker dataBroker,
  91                                  final IMdsalApiManager mdsalManager,
  92                                  final ItmConfig itmConfig, final JobCoordinator jobCoordinator,
  93                                  final TunnelMonitoringConfig tunnelMonitoringConfig,
  94                                  final DPNTEPsInfoCache dpnTEPsInfoCache,
  95                                  final ItmServiceRecoveryHandler itmServiceRecoveryHandler,
  96                                  final ServiceRecoveryRegistry serviceRecoveryRegistry) {
  97         super(dataBroker, LogicalDatastoreType.CONFIGURATION,
  98               InstanceIdentifier.create(TransportZones.class).child(TransportZone.class));
  99         this.dataBroker = dataBroker;
 100         this.jobCoordinator = jobCoordinator;
 101         initializeTZNode(dataBroker);
 102         this.mdsalManager = mdsalManager;
 103         this.itmConfig = itmConfig;
 104         this.dpnTEPsInfoCache = dpnTEPsInfoCache;
 105         this.itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator,
 106                 tunnelMonitoringConfig);
 107         this.itmInternalTunnelAddWorker = new ItmInternalTunnelAddWorker(dataBroker, jobCoordinator,
 108                 tunnelMonitoringConfig, itmConfig);
 109         this.externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig, dpnTEPsInfoCache);
 110         serviceRecoveryRegistry.addRecoverableListener(itmServiceRecoveryHandler.getServiceRegistryKey(), this);
 111     }
 112
 113     @Override
 114     public void registerListener() {
 115         register();
 116     }
 117
 118     @Override
 119     public void deregisterListener() {
 120         close();
 121     }
 122
 123     @SuppressWarnings("checkstyle:IllegalCatch")
 124     private void initializeTZNode(DataBroker db) {
 125         ReadWriteTransaction transaction = db.newReadWriteTransaction();
 126         InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class);
 127         CheckedFuture<Optional<TransportZones>, ReadFailedException> tzones = transaction
 128                 .read(LogicalDatastoreType.CONFIGURATION, path);
 129         try {
 130             if (!tzones.get().isPresent()) {
 131                 TransportZonesBuilder tzb = new TransportZonesBuilder();
 132                 transaction.put(LogicalDatastoreType.CONFIGURATION, path, tzb.build());
 133                 transaction.submit();
 134             } else {
 135                 transaction.cancel();
 136             }
 137         } catch (Exception e) {
 138             LOG.error("Error initializing TransportZones {}", e);
 139         }
 140     }
 141
 142     @Override
 143     public void remove(@Nonnull InstanceIdentifier<TransportZone> instanceIdentifier,
 144                        @Nonnull TransportZone transportZone) {
 145         LOG.debug("Received Transport Zone Remove Event: {}", transportZone);
 146
 147         boolean allowTunnelDeletion;
 148
 149         // check if TZ received for removal is default-transport-zone,
 150         // if yes, then check if it is received from northbound, then
 151         // do not entertain request and skip tunnels remove operation
 152         // if def-tz removal request is due to def-tz-enabled flag is disabled or
 153         // due to change in def-tz-tunnel-type, then allow def-tz tunnels deletion
 154         if (transportZone.getZoneName().equalsIgnoreCase(ITMConstants.DEFAULT_TRANSPORT_ZONE)) {
 155             // Get TunnelTypeBase object for tunnel-type configured in config file
 156             Class<? extends TunnelTypeBase> tunType = ItmUtils.getTunnelType(itmConfig.getDefTzTunnelType());
 157
 158             if (!itmConfig.isDefTzEnabled() || !transportZone.getTunnelType().equals(tunType)) {
 159                 allowTunnelDeletion = true;
 160             } else {
 161                 // this is case when def-tz removal request is from Northbound.
 162                 allowTunnelDeletion = false;
 163                 LOG.error("Deletion of {} is an incorrect usage",ITMConstants.DEFAULT_TRANSPORT_ZONE);
 164             }
 165         } else {
 166             allowTunnelDeletion = true;
 167         }
 168
 169         if (allowTunnelDeletion) {
 170             //TODO : DPList code can be refactor with new specific class
 171             // which implement TransportZoneValidator
 172             List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
 173             List<HwVtep> hwVtepList = createhWVteps(transportZone);
 174             LOG.trace("Delete: Invoking deleteTunnels in ItmManager with DpnList {}", opDpnList);
 175             if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
 176                 LOG.trace("Delete: Invoking ItmManager with hwVtep List {} ", hwVtepList);
 177                 jobCoordinator.enqueueJob(transportZone.getZoneName(),
 178                         new ItmTepRemoveWorker(opDpnList, hwVtepList, transportZone, dataBroker, mdsalManager,
 179                                 itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
 180             }
 181         }
 182     }
 183
 184     @Override
 185     public void update(@Nonnull InstanceIdentifier<TransportZone> instanceIdentifier,
 186                        @Nonnull TransportZone originalTransportZone, @Nonnull TransportZone updatedTransportZone) {
 187         LOG.debug("Received Transport Zone Update Event: Old - {}, Updated - {}", originalTransportZone,
 188                   updatedTransportZone);
 189         List<DPNTEPsInfo> oldDpnTepsList = createDPNTepInfo(originalTransportZone);
 190         List<DPNTEPsInfo> newDpnTepsList = createDPNTepInfo(updatedTransportZone);
 191         List<DPNTEPsInfo> oldDpnTepsListcopy = new ArrayList<>();
 192         oldDpnTepsListcopy.addAll(oldDpnTepsList);
 193         LOG.trace("oldcopy0 {}", oldDpnTepsListcopy);
 194         List<DPNTEPsInfo> newDpnTepsListcopy = new ArrayList<>();
 195         newDpnTepsListcopy.addAll(newDpnTepsList);
 196         LOG.trace("newcopy0 {}", newDpnTepsListcopy);
 197
 198         oldDpnTepsList.removeAll(newDpnTepsListcopy);
 199         newDpnTepsList.removeAll(oldDpnTepsListcopy);
 200
 201         LOG.trace("oldDpnTepsList {}", oldDpnTepsList);
 202         LOG.trace("newDpnTepsList {}", newDpnTepsList);
 203         LOG.trace("oldcopy {}", oldDpnTepsListcopy);
 204         LOG.trace("newcopy {}", newDpnTepsListcopy);
 205         LOG.trace("oldcopy Size {}", oldDpnTepsList.size());
 206         LOG.trace("newcopy Size {}", newDpnTepsList.size());
 207         if (!newDpnTepsList.isEmpty()) {
 208             LOG.trace("Adding TEPs ");
 209             jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(),
 210                     new ItmTepAddWorker(newDpnTepsList, Collections.emptyList(), dataBroker, mdsalManager, itmConfig,
 211                             itmInternalTunnelAddWorker, externalTunnelAddWorker, dpnTEPsInfoCache));
 212         }
 213         if (!oldDpnTepsList.isEmpty()) {
 214             LOG.trace("Removing TEPs ");
 215             jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(),
 216                     new ItmTepRemoveWorker(oldDpnTepsList, Collections.emptyList(), originalTransportZone, dataBroker,
 217                             mdsalManager, itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
 218         }
 219         List<HwVtep> oldHwList = createhWVteps(originalTransportZone);
 220         List<HwVtep> newHwList = createhWVteps(updatedTransportZone);
 221         List<HwVtep> oldHwListcopy = new ArrayList<>();
 222         oldHwListcopy.addAll(oldHwList);
 223         LOG.trace("oldHwListcopy0 {}", oldHwListcopy);
 224         List<HwVtep> newHwListcopy = new ArrayList<>();
 225         newHwListcopy.addAll(newHwList);
 226         LOG.trace("newHwListcopy0 {}", newHwListcopy);
 227
 228         oldHwList.removeAll(newHwListcopy);
 229         newHwList.removeAll(oldHwListcopy);
 230         LOG.trace("oldHwList {}", oldHwList);
 231         LOG.trace("newHwList {}", newHwList);
 232         LOG.trace("oldHwListcopy {}", oldHwListcopy);
 233         LOG.trace("newHwListcopy {}", newHwListcopy);
 234         if (!newHwList.isEmpty()) {
 235             LOG.trace("Adding HW TEPs ");
 236             jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(), new ItmTepAddWorker(Collections.emptyList(),
 237                     newHwList, dataBroker, mdsalManager, itmConfig, itmInternalTunnelAddWorker, externalTunnelAddWorker,
 238                     dpnTEPsInfoCache));
 239         }
 240         if (!oldHwList.isEmpty()) {
 241             LOG.trace("Removing HW TEPs ");
 242             jobCoordinator.enqueueJob(updatedTransportZone.getZoneName(), new ItmTepRemoveWorker(
 243                     Collections.emptyList(), oldHwList, originalTransportZone, dataBroker, mdsalManager,
 244                     itmInternalTunnelDeleteWorker, dpnTEPsInfoCache));
 245         }
 246     }
 247
 248     @Override
 249     public void add(@Nonnull TransportZone transportZone) {
 250         LOG.debug("Received Transport Zone Add Event: {}", transportZone);
 251         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
 252         List<HwVtep> hwVtepList = createhWVteps(transportZone);
 253         opDpnList.addAll(getDPNTepInfoFromNotHosted(transportZone));
 254         LOG.trace("Add: Operational dpnTepInfo - Before invoking ItmManager {}", opDpnList);
 255         if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
 256             LOG.trace("Add: Invoking ItmManager with DPN List {} ", opDpnList);
 257             LOG.trace("Add: Invoking ItmManager with hwVtep List {} ", hwVtepList);
 258             jobCoordinator.enqueueJob(transportZone.getZoneName(),
 259                     new ItmTepAddWorker(opDpnList, hwVtepList, dataBroker, mdsalManager, itmConfig,
 260                             itmInternalTunnelAddWorker, externalTunnelAddWorker, dpnTEPsInfoCache));
 261         }
 262     }
 263
 264     private List<DPNTEPsInfo> getDPNTepInfoFromNotHosted(TransportZone tzNew) {
 265         List<DPNTEPsInfo> notHostedOpDpnList = new ArrayList<>();
 266         if (isNewTZExistInNotHostedTZ(tzNew)) {
 267             notHostedOpDpnList = createDPNTepInfoFromNotHosted(tzNew);
 268         }
 269         return notHostedOpDpnList;
 270     }
 271
 272     private List<DPNTEPsInfo> createDPNTepInfoFromNotHosted(TransportZone tzNew) {
 273         Map<BigInteger, List<TunnelEndPoints>> mapNotHostedDPNToTunnelEndpt = new ConcurrentHashMap<>();
 274         List<DPNTEPsInfo> notHostedDpnTepInfo = new ArrayList<>();
 275         String newZoneName = tzNew.getZoneName();
 276         List<TzMembership> zones = ItmUtils.createTransportZoneMembership(newZoneName);
 277         Class<? extends TunnelTypeBase> tunnelType  = tzNew.getTunnelType();
 278
 279         TepsInNotHostedTransportZone tepsInNotHostedTransportZone = getNotHostedTransportZone(newZoneName).get();
 280         if (tepsInNotHostedTransportZone == null) {
 281             return notHostedDpnTepInfo;
 282         }
 283         List<UnknownVteps> unVtepsLst = tepsInNotHostedTransportZone.getUnknownVteps();
 284         List<Vteps> vtepsList = new ArrayList<>();
 285         if (unVtepsLst != null && !unVtepsLst.isEmpty()) {
 286             for (UnknownVteps vteps : unVtepsLst) {
 287                 BigInteger dpnID = vteps.getDpnId();
 288                 String port = ITMConstants.DUMMY_PORT;
 289                 int vlanID = ITMConstants.DUMMY_VLANID;
 290                 IpPrefix ipPrefix = IpPrefixBuilder.getDefaultInstance(ITMConstants.DUMMY_PREFIX);
 291                 IpAddress gatewayIP = IpAddressBuilder.getDefaultInstance(ITMConstants.DUMMY_GATEWAY_IP);
 292                 IpAddress ipAddress = vteps.getIpAddress();
 293                 boolean useOfTunnel = ItmUtils.falseIfNull(vteps.isOfTunnel());
 294                 String tos = vteps.getOptionTunnelTos();
 295                 if (tos == null) {
 296                     tos = itmConfig.getDefaultTunnelTos();
 297                 }
 298                 TunnelEndPoints tunnelEndPoints =
 299                         ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port, useOfTunnel,vlanID, ipPrefix,
 300                                 gatewayIP, zones, tunnelType, tos);
 301                 List<TunnelEndPoints> tunnelEndPointsList = mapNotHostedDPNToTunnelEndpt.get(dpnID);
 302                 if (tunnelEndPointsList != null) {
 303                     tunnelEndPointsList.add(tunnelEndPoints);
 304                 } else {
 305                     tunnelEndPointsList = new ArrayList<>();
 306                     tunnelEndPointsList.add(tunnelEndPoints);
 307                     mapNotHostedDPNToTunnelEndpt.put(dpnID, tunnelEndPointsList);
 308                 }
 309                 Vteps newVtep = createVtepFromUnKnownVteps(dpnID,ipAddress,ITMConstants.DUMMY_PORT);
 310                 vtepsList.add(newVtep);
 311
 312                 // Enqueue 'remove TEP from TepsNotHosted list' operation
 313                 // into DataStoreJobCoordinator
 314                 ItmTepsNotHostedRemoveWorker
 315                     removeWorker = new ItmTepsNotHostedRemoveWorker(newZoneName, ipAddress, dpnID, dataBroker);
 316                 jobCoordinator.enqueueJob(newZoneName, removeWorker);
 317             }
 318         }
 319
 320         // Enqueue 'add TEP received from southbound OVSDB into ITM config DS' operation
 321         // into DataStoreJobCoordinator
 322         ItmTepsNotHostedMoveWorker
 323             moveWorker = new ItmTepsNotHostedMoveWorker(vtepsList, newZoneName, dataBroker);
 324         jobCoordinator.enqueueJob(newZoneName, moveWorker);
 325
 326         if (mapNotHostedDPNToTunnelEndpt.size() > 0) {
 327             for (Entry<BigInteger, List<TunnelEndPoints>> entry: mapNotHostedDPNToTunnelEndpt.entrySet()) {
 328                 DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
 329                 notHostedDpnTepInfo.add(newDpnTepsInfo);
 330             }
 331         }
 332         return notHostedDpnTepInfo;
 333
 334     }
 335
 336     private Vteps createVtepFromUnKnownVteps(BigInteger dpnID, IpAddress ipAddress, String port) {
 337         VtepsKey vtepkey = new VtepsKey(dpnID, port);
 338         Vteps vtepObj = new VtepsBuilder().setDpnId(dpnID).setIpAddress(ipAddress).setKey(vtepkey)
 339                 .setPortname(port).build();
 340         return vtepObj;
 341     }
 342
 343     private boolean isNewTZExistInNotHostedTZ(TransportZone tzNew) {
 344         boolean isPresent = false;
 345         if (getNotHostedTransportZone(tzNew.getZoneName()).isPresent()) {
 346             isPresent = true;
 347         }
 348         return isPresent;
 349     }
 350
 351     public  Optional<TepsInNotHostedTransportZone> getNotHostedTransportZone(String transportZoneName) {
 352         InstanceIdentifier<TepsInNotHostedTransportZone> notHostedTzPath = InstanceIdentifier
 353                 .builder(NotHostedTransportZones.class).child(TepsInNotHostedTransportZone.class,
 354                         new TepsInNotHostedTransportZoneKey(transportZoneName)).build();
 355         Optional<TepsInNotHostedTransportZone> tepsInNotHostedTransportZoneOptional =
 356                 ItmUtils.read(LogicalDatastoreType.OPERATIONAL, notHostedTzPath, dataBroker);
 357         return tepsInNotHostedTransportZoneOptional;
 358     }
 359
 360     private List<DPNTEPsInfo> createDPNTepInfo(TransportZone transportZone) {
 361
 362         Map<BigInteger, List<TunnelEndPoints>> mapDPNToTunnelEndpt = new ConcurrentHashMap<>();
 363         List<DPNTEPsInfo> dpnTepInfo = new ArrayList<>();
 364         List<TzMembership> zones = ItmUtils.createTransportZoneMembership(transportZone.getZoneName());
 365         Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
 366         LOG.trace("Transport Zone_name: {}", transportZone.getZoneName());
 367         List<Subnets> subnetsList = transportZone.getSubnets();
 368         if (subnetsList != null) {
 369             for (Subnets subnet : subnetsList) {
 370                 IpPrefix ipPrefix = subnet.getPrefix();
 371                 IpAddress gatewayIP = subnet.getGatewayIp();
 372                 int vlanID = subnet.getVlanId();
 373                 LOG.trace("IpPrefix: {}, gatewayIP: {}, vlanID: {} ", ipPrefix, gatewayIP, vlanID);
 374                 List<Vteps> vtepsList = subnet.getVteps();
 375                 if (vtepsList != null && !vtepsList.isEmpty()) {
 376                     for (Vteps vteps : vtepsList) {
 377                         BigInteger dpnID = vteps.getDpnId();
 378                         String port = vteps.getPortname();
 379                         IpAddress ipAddress = vteps.getIpAddress();
 380                         boolean useOfTunnel = ItmUtils.falseIfNull(vteps.isOptionOfTunnel());
 381                         String tos = vteps.getOptionTunnelTos();
 382                         if (tos == null) {
 383                             tos = itmConfig.getDefaultTunnelTos();
 384                         }
 385                         LOG.trace("DpnID: {}, port: {}, ipAddress: {}", dpnID, port, ipAddress);
 386                         TunnelEndPoints tunnelEndPoints = ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port,
 387                             useOfTunnel, vlanID,  ipPrefix, gatewayIP, zones, tunnelType, tos);
 388                         List<TunnelEndPoints> tunnelEndPointsList = mapDPNToTunnelEndpt.get(dpnID);
 389                         if (tunnelEndPointsList != null) {
 390                             LOG.trace("Existing DPN info list in the Map: {} ", dpnID);
 391                             tunnelEndPointsList.add(tunnelEndPoints);
 392                         } else {
 393                             LOG.trace("Adding new DPN info list to the Map: {} ", dpnID);
 394                             tunnelEndPointsList = new ArrayList<>();
 395                             tunnelEndPointsList.add(tunnelEndPoints);
 396                             mapDPNToTunnelEndpt.put(dpnID, tunnelEndPointsList);
 397                         }
 398                     }
 399                 }
 400             }
 401         }
 402
 403         if (!mapDPNToTunnelEndpt.isEmpty()) {
 404             LOG.trace("List of dpns in the Map: {} ", mapDPNToTunnelEndpt.keySet());
 405             for (Entry<BigInteger, List<TunnelEndPoints>> entry : mapDPNToTunnelEndpt.entrySet()) {
 406                 DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
 407                 dpnTepInfo.add(newDpnTepsInfo);
 408             }
 409         }
 410         return dpnTepInfo;
 411     }
 412
 413     private List<HwVtep> createhWVteps(TransportZone transportZone) {
 414         List<HwVtep> hwVtepsList = new ArrayList<>();
 415
 416         String zoneName = transportZone.getZoneName();
 417         Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
 418         LOG.trace("Transport Zone_name: {}", zoneName);
 419         List<Subnets> subnetsList = transportZone.getSubnets();
 420         if (subnetsList != null) {
 421             for (Subnets subnet : subnetsList) {
 422                 IpPrefix ipPrefix = subnet.getPrefix();
 423                 IpAddress gatewayIP = subnet.getGatewayIp();
 424                 int vlanID = subnet.getVlanId();
 425                 LOG.trace("IpPrefix: {}, gatewayIP: {}, vlanID: {} ", ipPrefix, gatewayIP, vlanID);
 426                 List<DeviceVteps> deviceVtepsList = subnet.getDeviceVteps();
 427                 if (deviceVtepsList != null) {
 428                     for (DeviceVteps vteps : deviceVtepsList) {
 429                         String topologyId = vteps.getTopologyId();
 430                         String nodeId = vteps.getNodeId();
 431                         IpAddress ipAddress = vteps.getIpAddress();
 432                         LOG.trace("topo-id: {}, node-id: {}, ipAddress: {}", topologyId, nodeId, ipAddress);
 433                         HwVtep hwVtep = ItmUtils.createHwVtepObject(topologyId, nodeId, ipAddress, ipPrefix, gatewayIP,
 434                                 vlanID, tunnelType, transportZone);
 435
 436                         LOG.trace("Adding new HwVtep {} info ", hwVtep.getHwIp());
 437                         hwVtepsList.add(hwVtep);
 438                     }
 439                 }
 440             }
 441         }
 442         LOG.trace("returning hwvteplist {}", hwVtepsList);
 443         return hwVtepsList;
 444     }
 445 }