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

   1 /*
   2  * Copyright (c) 2015 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.vpnservice.itm.listeners;
  10
  11 import java.math.BigInteger;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.concurrent.ConcurrentHashMap;
  17
  18 import com.google.common.base.Optional;
  19 import com.google.common.util.concurrent.CheckedFuture;
  20 import com.google.common.util.concurrent.ListenableFuture;
  21
  22 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeBase;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfo;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rev150701.TransportZones;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rev150701.TransportZonesBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rev150701.transport.zones.TransportZone;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rev150701.transport.zones.transport.zone.Subnets;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rev150701.transport.zones.transport.zone.subnets.Vteps;
  36 import org.opendaylight.vpnservice.datastoreutils.AsyncDataTreeChangeListenerBase;
  37 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  38 import org.opendaylight.vpnservice.itm.impl.ITMManager;
  39 import org.opendaylight.vpnservice.itm.impl.ItmUtils;
  40 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42 import org.opendaylight.vpnservice.itm.confighelpers.ItmTepAddWorker ;
  43 import org.opendaylight.vpnservice.itm.confighelpers.ItmTepRemoveWorker;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 /**
  48  * This class listens for interface creation/removal/update in Configuration DS.
  49  * This is used to handle interfaces for base of-ports.
  50  */
  51 public class TransportZoneListener extends AsyncDataTreeChangeListenerBase<TransportZone, TransportZoneListener> implements AutoCloseable{
  52     private static final Logger LOG = LoggerFactory.getLogger(TransportZoneListener.class);
  53     private DataBroker dataBroker;
  54     private IdManagerService idManagerService;
  55     private ITMManager itmManager;
  56
  57     public TransportZoneListener(final DataBroker dataBroker, final IdManagerService idManagerService) {
  58         super(TransportZone.class, TransportZoneListener.class);
  59         this.dataBroker = dataBroker;
  60         this.idManagerService = idManagerService;
  61         initializeTZNode(dataBroker);
  62     }
  63
  64     public void setItmManager(ITMManager itmManager) {
  65         this.itmManager = itmManager;
  66     }
  67
  68     private void initializeTZNode(DataBroker db) {
  69         ReadWriteTransaction transaction = db.newReadWriteTransaction();
  70         InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class);
  71         CheckedFuture<Optional<TransportZones>, ReadFailedException> tzones =
  72                         transaction.read(LogicalDatastoreType.CONFIGURATION,path);
  73         try {
  74             if (!tzones.get().isPresent()) {
  75                 TransportZonesBuilder tzb = new TransportZonesBuilder();
  76                 transaction.put(LogicalDatastoreType.CONFIGURATION,path,tzb.build());
  77                 transaction.submit();
  78             } else {
  79                 transaction.cancel();
  80             }
  81         } catch (Exception e) {
  82             LOG.error("Error initializing TransportZones {}",e);
  83         }
  84     }
  85
  86     @Override
  87     public void close() throws Exception {
  88         LOG.info("tzChangeListener Closed");
  89     }
  90     @Override
  91     protected InstanceIdentifier<TransportZone> getWildCardPath() {
  92         return InstanceIdentifier.create(TransportZones.class).child(TransportZone.class);
  93     }
  94
  95     @Override
  96     protected TransportZoneListener getDataTreeChangeListener() {
  97         return TransportZoneListener.this;
  98     }
  99
 100     @Override
 101     protected void remove(InstanceIdentifier<TransportZone> key, TransportZone tzOld) {
 102         LOG.debug("Received Transport Zone Remove Event: {}, {}", key, tzOld);
 103         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzOld);
 104         LOG.trace("Delete: Invoking deleteTunnels in ItmManager with DpnList {}", opDpnList);
 105         if(opDpnList.size()>0) {
 106             LOG.trace("Delete: Invoking ItmManager");
 107            // itmManager.deleteTunnels(opDpnList);
 108             DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 109             ItmTepRemoveWorker removeWorker = new ItmTepRemoveWorker(opDpnList, dataBroker, idManagerService);
 110             coordinator.enqueueJob(tzOld.getZoneName(), removeWorker);
 111         }
 112     }
 113
 114     @Override
 115     protected void update(InstanceIdentifier<TransportZone> key, TransportZone tzOld, TransportZone tzNew) {
 116         LOG.debug("Received Transport Zone Update Event: {}, {}, {}", key, tzOld, tzNew);
 117         if( !(tzOld.equals(tzNew))) {
 118            add(key, tzNew);
 119         }
 120     }
 121
 122     @Override
 123     protected void add(InstanceIdentifier<TransportZone> key, TransportZone tzNew) {
 124         LOG.debug("Received Transport Zone Add Event: {}, {}", key, tzNew);
 125         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(tzNew);
 126         LOG.trace("Add: Operational dpnTepInfo - Before invoking ItmManager {}", opDpnList);
 127         if(opDpnList.size()>0) {
 128           LOG.trace("Add: Invoking ItmManager with DPN List {} " , opDpnList);
 129           //itmManager.build_all_tunnels(opDpnList);
 130           DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 131           ItmTepAddWorker addWorker = new ItmTepAddWorker(opDpnList,dataBroker, idManagerService);
 132           coordinator.enqueueJob(tzNew.getZoneName(), addWorker);
 133       }
 134     }
 135
 136     private List<DPNTEPsInfo> createDPNTepInfo(TransportZone transportZone){
 137
 138         Map<BigInteger, List<TunnelEndPoints>> mapDPNToTunnelEndpt = new ConcurrentHashMap<>();
 139         List<DPNTEPsInfo> dpnTepInfo = new ArrayList<DPNTEPsInfo>();
 140        // List<TransportZone> transportZoneList = transportZones.getTransportZone();
 141        // for(TransportZone transportZone : transportZoneList) {
 142             String zone_name = transportZone.getZoneName();
 143             Class<? extends TunnelTypeBase> tunnel_type = transportZone.getTunnelType();
 144             LOG.trace("Transport Zone_name: {}", zone_name);
 145             List<Subnets> subnetsList = transportZone.getSubnets();
 146             if(subnetsList!=null){
 147                 for (Subnets subnet : subnetsList) {
 148                     IpPrefix ipPrefix = subnet.getPrefix();
 149                     IpAddress gatewayIP = subnet.getGatewayIp();
 150                     int vlanID = subnet.getVlanId();
 151                     LOG.trace("IpPrefix: {}, gatewayIP: {}, vlanID: {} ", ipPrefix, gatewayIP, vlanID);
 152                     List<Vteps> vtepsList = subnet.getVteps();
 153                     for (Vteps vteps : vtepsList) {
 154                         BigInteger dpnID = vteps.getDpnId();
 155                         String port = vteps.getPortname();
 156                         IpAddress ipAddress = vteps.getIpAddress();
 157                         LOG.trace("DpnID: {}, port: {}, ipAddress: {}", dpnID, port, ipAddress);
 158                     TunnelEndPoints tunnelEndPoints = ItmUtils.createTunnelEndPoints(dpnID, ipAddress, port, vlanID, ipPrefix, gatewayIP, zone_name, tunnel_type);
 159                         List<TunnelEndPoints> tunnelEndPointsList = mapDPNToTunnelEndpt.get(dpnID);
 160                         if (tunnelEndPointsList != null) {
 161                             LOG.trace("Existing DPN info list in the Map: {} ", dpnID);
 162                             tunnelEndPointsList.add(tunnelEndPoints);
 163                         } else {
 164                             LOG.trace("Adding new DPN info list to the Map: {} ", dpnID);
 165                             tunnelEndPointsList = new ArrayList<TunnelEndPoints>();
 166                             tunnelEndPointsList.add(tunnelEndPoints);
 167                             mapDPNToTunnelEndpt.put(dpnID, tunnelEndPointsList);
 168                         }
 169                     }
 170                 }
 171             }
 172         //}
 173         if(mapDPNToTunnelEndpt.size()>0){
 174             Set<BigInteger> keys = mapDPNToTunnelEndpt.keySet();
 175             LOG.trace("List of dpns in the Map: {} ", keys);
 176             for(BigInteger key: keys){
 177                 DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(key, mapDPNToTunnelEndpt.get(key));
 178                 dpnTepInfo.add(newDpnTepsInfo);
 179             }
 180         }
 181         return dpnTepInfo;
 182     }
 183 }