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

   1 /*
   2  * Copyright (c) 2016 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.Set;
  19 import java.util.concurrent.ConcurrentHashMap;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  24 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  25 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
  26 import org.opendaylight.genius.itm.confighelpers.HwVtep;
  27 import org.opendaylight.genius.itm.confighelpers.ItmTepAddWorker;
  28 import org.opendaylight.genius.itm.confighelpers.ItmTepRemoveWorker;
  29 import org.opendaylight.genius.itm.impl.ITMManager;
  30 import org.opendaylight.genius.itm.impl.ItmUtils;
  31 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * This class listens for interface creation/removal/update in Configuration DS.
  50  * This is used to handle interfaces for base of-ports.
  51  */
  52 public class TransportZoneListener extends AsyncDataTreeChangeListenerBase<TransportZone, TransportZoneListener>
  53         implements AutoCloseable {
  54     private static final Logger LOG = LoggerFactory.getLogger(TransportZoneListener.class);
  55     private final DataBroker dataBroker;
  56     private final IdManagerService idManagerService;
  57     private IMdsalApiManager mdsalManager;
  58     private ITMManager itmManager;
  59
  60     public TransportZoneListener(final DataBroker dataBroker, final IdManagerService idManagerService) {
  61         super(TransportZone.class, TransportZoneListener.class);
  62         this.dataBroker = dataBroker;
  63         this.idManagerService = idManagerService;
  64         initializeTZNode(dataBroker);
  65     }
  66
  67     public void setItmManager(ITMManager itmManager) {
  68         this.itmManager = itmManager;
  69     }
  70
  71     public void setMdsalManager(IMdsalApiManager mdsalManager) {
  72         this.mdsalManager = mdsalManager;
  73     }
  74
  75     private void initializeTZNode(DataBroker db) {
  76         ReadWriteTransaction transaction = db.newReadWriteTransaction();
  77         InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class);
  78         CheckedFuture<Optional<TransportZones>, ReadFailedException> tzones = transaction
  79                 .read(LogicalDatastoreType.CONFIGURATION, path);
  80         try {
  81             if (!tzones.get().isPresent()) {
  82                 TransportZonesBuilder tzb = new TransportZonesBuilder();
  83                 transaction.put(LogicalDatastoreType.CONFIGURATION, path, tzb.build());
  84                 transaction.submit();
  85             } else {
  86                 transaction.cancel();
  87             }
  88         } catch (Exception e) {
  89             LOG.error("Error initializing TransportZones {}", e);
  90         }
  91     }
  92
  93     @Override
  94     public void close() throws Exception {
  95         LOG.info("tzChangeListener Closed");
  96     }
  97
  98     @Override
  99     protected InstanceIdentifier<TransportZone> getWildCardPath() {
 100         return InstanceIdentifier.create(TransportZones.class).child(TransportZone.class);
 101     }
 102
 103     @Override
 104     protected TransportZoneListener getDataTreeChangeListener() {
 105         return TransportZoneListener.this;
 106     }
 107
 108     @Override
 109     protected void remove(InstanceIdentifier<TransportZone> key, TransportZone tzOld) {
 110         LOG.debug("Received Transport Zone Remove Event: {}, {}", key, tzOld);
 111         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzOld);
 112         List<HwVtep> hwVtepList = createhWVteps(tzOld);
 113         LOG.trace("Delete: Invoking deleteTunnels in ItmManager with DpnList {}", opDpnList);
 114         if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
 115             LOG.trace("Delete: Invoking ItmManager");
 116             LOG.trace("Delete: Invoking ItmManager with hwVtep List {} ", hwVtepList);
 117             DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 118             ItmTepRemoveWorker removeWorker = new ItmTepRemoveWorker(opDpnList, hwVtepList, tzOld, dataBroker,
 119                     idManagerService, mdsalManager);
 120             coordinator.enqueueJob(tzOld.getZoneName(), removeWorker);
 121         }
 122     }
 123
 124     @Override
 125     protected void update(InstanceIdentifier<TransportZone> key, TransportZone tzOld, TransportZone tzNew) {
 126         LOG.debug("Received Transport Zone Update Event: Key - {}, Old - {}, Updated - {}", key, tzOld, tzNew);
 127         List<DPNTEPsInfo> oldDpnTepsList = createDPNTepInfo(tzOld);
 128         List<DPNTEPsInfo> newDpnTepsList = createDPNTepInfo(tzNew);
 129         List<DPNTEPsInfo> oldDpnTepsListcopy = new ArrayList<>();
 130         oldDpnTepsListcopy.addAll(oldDpnTepsList);
 131         LOG.trace("oldcopy0" + oldDpnTepsListcopy);
 132         List<DPNTEPsInfo> newDpnTepsListcopy = new ArrayList<>();
 133         newDpnTepsListcopy.addAll(newDpnTepsList);
 134         LOG.trace("newcopy0" + newDpnTepsListcopy);
 135         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 136
 137         oldDpnTepsList.removeAll(newDpnTepsListcopy);
 138         newDpnTepsList.removeAll(oldDpnTepsListcopy);
 139
 140         LOG.trace("oldDpnTepsList" + oldDpnTepsList);
 141         LOG.trace("newDpnTepsList" + newDpnTepsList);
 142         LOG.trace("oldcopy" + oldDpnTepsListcopy);
 143         LOG.trace("newcopy" + newDpnTepsListcopy);
 144         LOG.trace("oldcopy Size " + oldDpnTepsList.size());
 145         LOG.trace("newcopy Size " + newDpnTepsList.size());
 146         if (!newDpnTepsList.isEmpty()) {
 147             LOG.trace("Adding TEPs ");
 148             ItmTepAddWorker addWorker = new ItmTepAddWorker(newDpnTepsList, Collections.<HwVtep>emptyList(), dataBroker,
 149                     idManagerService, mdsalManager);
 150             coordinator.enqueueJob(tzNew.getZoneName(), addWorker);
 151         }
 152         if (!oldDpnTepsList.isEmpty()) {
 153             LOG.trace("Removing TEPs ");
 154             ItmTepRemoveWorker removeWorker = new ItmTepRemoveWorker(oldDpnTepsList, Collections.<HwVtep>emptyList(),
 155                     tzOld, dataBroker, idManagerService, mdsalManager);
 156             coordinator.enqueueJob(tzNew.getZoneName(), removeWorker);
 157         }
 158         List<HwVtep> oldHwList = createhWVteps(tzOld);
 159         List<HwVtep> newHwList = createhWVteps(tzNew);
 160         List<HwVtep> oldHwListcopy = new ArrayList<>();
 161         oldHwListcopy.addAll(oldHwList);
 162         LOG.trace("oldHwListcopy0" + oldHwListcopy);
 163         List<HwVtep> newHwListcopy = new ArrayList<>();
 164         newHwListcopy.addAll(newHwList);
 165         LOG.trace("newHwListcopy0" + newHwListcopy);
 166
 167         oldHwList.removeAll(newHwListcopy);
 168         newHwList.removeAll(oldHwListcopy);
 169         LOG.trace("oldHwList" + oldHwList);
 170         LOG.trace("newHwList" + newHwList);
 171         LOG.trace("oldHwListcopy" + oldHwListcopy);
 172         LOG.trace("newHwListcopy" + newHwListcopy);
 173         if (!newHwList.isEmpty()) {
 174             LOG.trace("Adding HW TEPs ");
 175             ItmTepAddWorker addWorker = new ItmTepAddWorker(Collections.<DPNTEPsInfo>emptyList(), newHwList, dataBroker,
 176                     idManagerService, mdsalManager);
 177             coordinator.enqueueJob(tzNew.getZoneName(), addWorker);
 178         }
 179         if (!oldHwList.isEmpty()) {
 180             LOG.trace("Removing HW TEPs ");
 181             ItmTepRemoveWorker removeWorker = new ItmTepRemoveWorker(Collections.<DPNTEPsInfo>emptyList(), oldHwList,
 182                     tzOld, dataBroker, idManagerService, mdsalManager);
 183             coordinator.enqueueJob(tzNew.getZoneName(), removeWorker);
 184         }
 185     }
 186
 187     @Override
 188     protected void add(InstanceIdentifier<TransportZone> key, TransportZone tzNew) {
 189         LOG.debug("Received Transport Zone Add Event: {}, {}", key, tzNew);
 190         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzNew);
 191         List<HwVtep> hwVtepList = createhWVteps(tzNew);
 192         LOG.trace("Add: Operational dpnTepInfo - Before invoking ItmManager {}", opDpnList);
 193         if (!opDpnList.isEmpty() || !hwVtepList.isEmpty()) {
 194             LOG.trace("Add: Invoking ItmManager with DPN List {} ", opDpnList);
 195             LOG.trace("Add: Invoking ItmManager with hwVtep List {} ", hwVtepList);
 196             DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 197             ItmTepAddWorker addWorker = new ItmTepAddWorker(opDpnList, hwVtepList, dataBroker, idManagerService,
 198                     mdsalManager);
 199             coordinator.enqueueJob(tzNew.getZoneName(), addWorker);
 200         }
 201     }
 202
 203     private List<DPNTEPsInfo> createDPNTepInfo(TransportZone transportZone) {
 204         Map<BigInteger, List<TunnelEndPoints>> mapDPNToTunnelEndpt = new ConcurrentHashMap<>();
 205         List<DPNTEPsInfo> dpnTepInfo = new ArrayList<>();
 206         String zoneName = transportZone.getZoneName();
 207         Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
 208         LOG.trace("Transport Zone_name: {}", zoneName);
 209         List<Subnets> subnetsList = transportZone.getSubnets();
 210         if (subnetsList != null) {
 211             for (Subnets subnet : subnetsList) {
 212                 IpPrefix ipPrefix = subnet.getPrefix();
 213                 IpAddress gatewayIP = subnet.getGatewayIp();
 214                 int vlanID = subnet.getVlanId();
 215                 LOG.trace("IpPrefix: {}, gatewayIP: {}, vlanID: {} ", ipPrefix, gatewayIP, vlanID);
 216                 List<Vteps> vtepsList = subnet.getVteps();
 217                 if (vtepsList != null && !vtepsList.isEmpty()) {
 218                     for (Vteps vteps : vtepsList) {
 219                         BigInteger dpnID = vteps.getDpnId();
 220                         String port = vteps.getPortname();
 221                         IpAddress ipAddress = vteps.getIpAddress();
 222                         LOG.trace("DpnID: {}, port: {}, ipAddress: {}", dpnID, port, ipAddress);
 223                         TunnelEndPoints tunnelEndPoints = ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port, vlanID,
 224                                 ipPrefix, gatewayIP, zoneName, tunnelType);
 225                         List<TunnelEndPoints> tunnelEndPointsList = mapDPNToTunnelEndpt.get(dpnID);
 226                         if (tunnelEndPointsList != null) {
 227                             LOG.trace("Existing DPN info list in the Map: {} ", dpnID);
 228                             tunnelEndPointsList.add(tunnelEndPoints);
 229                         } else {
 230                             LOG.trace("Adding new DPN info list to the Map: {} ", dpnID);
 231                             tunnelEndPointsList = new ArrayList<>();
 232                             tunnelEndPointsList.add(tunnelEndPoints);
 233                             mapDPNToTunnelEndpt.put(dpnID, tunnelEndPointsList);
 234                         }
 235                     }
 236                 }
 237             }
 238         }
 239
 240         if (!mapDPNToTunnelEndpt.isEmpty()) {
 241             Set<BigInteger> keys = mapDPNToTunnelEndpt.keySet();
 242             LOG.trace("List of dpns in the Map: {} ", keys);
 243             for (BigInteger key : keys) {
 244                 DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(key, mapDPNToTunnelEndpt.get(key));
 245                 dpnTepInfo.add(newDpnTepsInfo);
 246             }
 247         }
 248         return dpnTepInfo;
 249     }
 250
 251     private List<HwVtep> createhWVteps(TransportZone transportZone) {
 252         List<HwVtep> hwVtepsList = new ArrayList<>();
 253
 254         String zoneName = transportZone.getZoneName();
 255         Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
 256         LOG.trace("Transport Zone_name: {}", zoneName);
 257         List<Subnets> subnetsList = transportZone.getSubnets();
 258         if (subnetsList != null) {
 259             for (Subnets subnet : subnetsList) {
 260                 IpPrefix ipPrefix = subnet.getPrefix();
 261                 IpAddress gatewayIP = subnet.getGatewayIp();
 262                 int vlanID = subnet.getVlanId();
 263                 LOG.trace("IpPrefix: {}, gatewayIP: {}, vlanID: {} ", ipPrefix, gatewayIP, vlanID);
 264                 List<DeviceVteps> deviceVtepsList = subnet.getDeviceVteps();
 265                 if (deviceVtepsList != null) {
 266                     for (DeviceVteps vteps : deviceVtepsList) {
 267                         String topologyId = vteps.getTopologyId();
 268                         String nodeId = vteps.getNodeId();
 269                         IpAddress ipAddress = vteps.getIpAddress();
 270                         LOG.trace("topo-id: {}, node-id: {}, ipAddress: {}", topologyId, nodeId, ipAddress);
 271                         HwVtep hwVtep = ItmUtils.createHwVtepObject(topologyId, nodeId, ipAddress, ipPrefix, gatewayIP,
 272                                 vlanID, tunnelType, transportZone);
 273
 274                         if (hwVtepsList != null) {
 275                             LOG.trace("Existing hwVteps");
 276                             hwVtepsList.add(hwVtep);
 277                         } else {
 278                             LOG.trace("Adding new HwVtep {} info ", hwVtep.getHwIp());
 279                             hwVtepsList.add(hwVtep);
 280                         }
 281                     }
 282                 }
 283             }
 284         }
 285         LOG.trace("returning hwvteplist {}", hwVtepsList);
 286         return hwVtepsList;
 287     }
 288 }