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