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