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