itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java

   1 /*
   2  * Copyright (c) 2018 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 package org.opendaylight.genius.itm.cache;
   9
  10 import com.google.common.base.Optional;
  11 import java.math.BigInteger;
  12 import java.util.Collection;
  13 import java.util.Collections;
  14 import java.util.List;
  15 import java.util.concurrent.ConcurrentHashMap;
  16 import java.util.concurrent.ConcurrentMap;
  17 import javax.inject.Inject;
  18 import javax.inject.Singleton;
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  22 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  23 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  24 import org.opendaylight.genius.itm.impl.ItmUtils;
  25 import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
  26 import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfoBuilder;
  27 import org.opendaylight.genius.itm.utils.TunnelEndPointInfo;
  28 import org.opendaylight.genius.itm.utils.TunnelEndPointInfoBuilder;
  29 import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
  30 import org.opendaylight.infrautils.caches.CacheProvider;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTepsKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsKey;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 @Singleton
  44 public class DpnTepStateCache extends DataObjectCache<BigInteger, DpnsTeps> {
  45
  46     private static final Logger LOG = LoggerFactory.getLogger(DpnTepStateCache.class);
  47
  48     private final DataBroker dataBroker;
  49     private final DPNTEPsInfoCache dpnTepsInfoCache;
  50     private final ConcurrentMap<String, DpnTepInterfaceInfo> dpnTepInterfaceMap = new ConcurrentHashMap<>();
  51     private final ConcurrentMap<String, TunnelEndPointInfo> tunnelEndpointMap = new ConcurrentHashMap<>();
  52
  53     @Inject
  54     public DpnTepStateCache(DataBroker dataBroker, CacheProvider cacheProvider, DPNTEPsInfoCache dpnTepsInfoCache) {
  55         super(DpnsTeps.class, dataBroker, LogicalDatastoreType.CONFIGURATION,
  56             InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class).build(), cacheProvider,
  57             (iid, dpnsTeps) -> dpnsTeps.getSourceDpnId(),
  58             sourceDpnId -> InstanceIdentifier.builder(DpnTepsState.class)
  59                     .child(DpnsTeps.class, new DpnsTepsKey(sourceDpnId)).build());
  60         this.dataBroker = dataBroker;
  61         this.dpnTepsInfoCache = dpnTepsInfoCache;
  62     }
  63
  64     @Override
  65     protected void added(InstanceIdentifier<DpnsTeps> path, DpnsTeps dpnsTeps) {
  66         for (RemoteDpns remoteDpns : dpnsTeps.getRemoteDpns()) {
  67             final String dpn = getDpnId(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
  68             DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder()
  69                     .setTunnelName(remoteDpns.getTunnelName())
  70                     .setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled())
  71                     .setIsInternal(remoteDpns.isInternal())
  72                     .setTunnelType(dpnsTeps.getTunnelType()).build();
  73             dpnTepInterfaceMap.put(dpn, value);
  74             addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(),
  75                     dpnsTeps.getSourceDpnId().toString(), remoteDpns.getDestinationDpnId().toString());
  76         }
  77     }
  78
  79     @Override
  80     protected void removed(InstanceIdentifier<DpnsTeps> path, DpnsTeps dpnsTeps) {
  81         for (RemoteDpns remoteDpns : dpnsTeps.getRemoteDpns()) {
  82             dpnTepInterfaceMap.remove(getDpnId(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId()));
  83             tunnelEndpointMap.remove(remoteDpns.getTunnelName());
  84         }
  85     }
  86
  87     private DpnTepInterfaceInfo getDpnTepInterface(String srcDpnId, String dstDpnId) {
  88         return getDpnTepInterface(new BigInteger(srcDpnId), new BigInteger(dstDpnId));
  89     }
  90
  91     public DpnTepInterfaceInfo getDpnTepInterface(BigInteger srcDpnId, BigInteger dstDpnId) {
  92         DpnTepInterfaceInfo  dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
  93         if (dpnTepInterfaceInfo == null) {
  94             try {
  95                 Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
  96                 if (dpnsTeps.isPresent()) {
  97                     DpnsTeps teps = dpnsTeps.get();
  98                     teps.getRemoteDpns().forEach(remoteDpns -> {
  99                         DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder()
 100                                 .setTunnelName(remoteDpns.getTunnelName())
 101                                 .setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled())
 102                                 .setIsInternal(remoteDpns.isInternal())
 103                                 .setTunnelType(teps.getTunnelType()).build();
 104                         dpnTepInterfaceMap.putIfAbsent(getDpnId(srcDpnId, remoteDpns.getDestinationDpnId()), value);
 105                         addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(),
 106                                 teps.getSourceDpnId().toString(), remoteDpns.getDestinationDpnId().toString());
 107                         }
 108                     );
 109                 }
 110             } catch (ReadFailedException e) {
 111                 LOG.error("cache read for dpnID {} in DpnTepStateCache failed ", srcDpnId, e);
 112             }
 113         }
 114         return dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
 115     }
 116
 117     public void removeTepFromDpnTepInterfaceConfigDS(BigInteger srcDpnId) throws TransactionCommitFailedException {
 118         Collection<DpnsTeps> dpnsTeps = this.getAllPresent();
 119         for (DpnsTeps dpnTep : dpnsTeps) {
 120             if (!dpnTep.getSourceDpnId().equals(srcDpnId)) {
 121                 List<RemoteDpns> remoteDpns = dpnTep.getRemoteDpns();
 122                 for (RemoteDpns remoteDpn : remoteDpns) {
 123                     if (remoteDpn.getDestinationDpnId().equals(srcDpnId)) {
 124                         // Remote the SrcDpnId from the remote List. Remove it from COnfig DS. 4
 125                         // This will be reflected in cache by the ClusteredDTCN. Not removing it here !
 126                         //Caution :- Batching Delete !!
 127                         InstanceIdentifier<RemoteDpns> remoteDpnII =
 128                                 buildRemoteDpnsInstanceIdentifier(dpnTep.getSourceDpnId(),
 129                                         remoteDpn.getDestinationDpnId());
 130                         SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
 131                                 remoteDpnII);
 132                         break;
 133                     }
 134                 }
 135             } else {
 136                 // The source DPn id is the one to be removed
 137                 InstanceIdentifier<DpnsTeps> dpnsTepsII = buildDpnsTepsInstanceIdentifier(dpnTep.getSourceDpnId());
 138                 SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, dpnsTepsII);
 139             }
 140         }
 141     }
 142
 143     private InstanceIdentifier<DpnsTeps> buildDpnsTepsInstanceIdentifier(BigInteger srcDpnId) {
 144         return InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class, new DpnsTepsKey(srcDpnId)).build();
 145     }
 146
 147     private InstanceIdentifier<RemoteDpns> buildRemoteDpnsInstanceIdentifier(BigInteger srcDpnId, BigInteger dstDpnId) {
 148         DpnsTepsKey dpnsTepsKey = new DpnsTepsKey(srcDpnId);
 149         RemoteDpnsKey remoteDpnsKey = new RemoteDpnsKey(dstDpnId);
 150         return InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class, dpnsTepsKey)
 151                 .child(RemoteDpns.class, remoteDpnsKey).build();
 152     }
 153
 154     // Given the tunnel name find out if its internal or external
 155     public boolean isInternal(String tunnelName) {
 156         TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
 157         if (endPointInfo != null) {
 158             DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(endPointInfo.getSrcEndPointInfo(),
 159                     endPointInfo.getDstEndPointInfo());
 160             return dpnTepInfo != null && dpnTepInfo.isInternal();
 161         }
 162         return false;
 163     }
 164
 165     public boolean isConfigAvailable(String tunnelName) {
 166         TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
 167         if (endPointInfo != null) {
 168             DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(endPointInfo.getSrcEndPointInfo(),
 169                     endPointInfo.getDstEndPointInfo());
 170             return dpnTepInfo != null;
 171         }
 172         return false;
 173     }
 174
 175     public DpnTepInterfaceInfo getTunnelFromCache(String tunnelName) {
 176         TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
 177         return getDpnTepInterface(endPointInfo.getSrcEndPointInfo(), endPointInfo.getDstEndPointInfo());
 178     }
 179
 180     private String getDpnId(BigInteger src, BigInteger dst) {
 181         return src + ":" + dst;
 182     }
 183
 184     public Interface getInterfaceFromCache(String tunnelName) {
 185         TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
 186         BigInteger srcDpnId = new BigInteger(endPointInfo.getSrcEndPointInfo());
 187         BigInteger dstDpnId = new BigInteger(endPointInfo.getDstEndPointInfo());
 188         Interface iface = null ;
 189         int monitoringInt = 1000;
 190         DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(srcDpnId, dstDpnId);
 191         if (dpnTepInfo != null) {
 192             List<DPNTEPsInfo> srcDpnTEPsInfo = dpnTepsInfoCache
 193                     .getDPNTepListFromDPNId(Collections.singletonList(srcDpnId));
 194             List<DPNTEPsInfo> dstDpnTEPsInfo = dpnTepsInfoCache
 195                     .getDPNTepListFromDPNId(Collections.singletonList(dstDpnId));
 196             iface = ItmUtils.buildTunnelInterface(srcDpnId, tunnelName,
 197                     String.format("%s %s", ItmUtils.convertTunnelTypetoString(dpnTepInfo.getTunnelType()),
 198                             "Trunk Interface"), true, dpnTepInfo.getTunnelType(),
 199                     srcDpnTEPsInfo.get(0).getTunnelEndPoints().get(0).getIpAddress(),
 200                     dstDpnTEPsInfo.get(0).getTunnelEndPoints().get(0).getIpAddress(),
 201                     srcDpnTEPsInfo.get(0).getTunnelEndPoints().get(0).getGwIpAddress(),
 202                     srcDpnTEPsInfo.get(0).getTunnelEndPoints().get(0).getVLANID(), true,
 203                     dpnTepInfo.isMonitoringEnabled(), TunnelMonitoringTypeBfd.class,
 204                     monitoringInt, true, null);
 205         }
 206         return iface;
 207     }
 208
 209     //Start: TunnelEndPoint Cache accessors
 210     private void addTunnelEndPointInfoToCache(String tunnelName, String srcEndPtInfo, String dstEndPtInfo) {
 211         TunnelEndPointInfo tunnelEndPointInfo = new TunnelEndPointInfoBuilder().setSrcEndPointInfo(srcEndPtInfo)
 212                 .setDstEndPointInfo(dstEndPtInfo).build();
 213         tunnelEndpointMap.put(tunnelName, tunnelEndPointInfo);
 214     }
 215
 216     public TunnelEndPointInfo getTunnelEndPointInfoFromCache(String tunnelName) {
 217         return tunnelEndpointMap.get(tunnelName);
 218     }
 219 }