vpnmanager/api/src/main/java/org/opendaylight/netvirt/vpnmanager/api/VpnExtraRouteHelper.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 package org.opendaylight.netvirt.vpnmanager.api;
   9
  10 import static java.util.stream.Collectors.toList;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collections;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Optional;
  17 import java.util.concurrent.ExecutionException;
  18 import java.util.concurrent.Future;
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  21 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  22 import org.opendaylight.mdsal.binding.api.DataBroker;
  23 import org.opendaylight.mdsal.binding.util.Datastore;
  24 import org.opendaylight.mdsal.binding.util.TypedReadTransaction;
  25 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeInputBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelTypeOutput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.ExtrarouteRdsMap;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.ExtrarouteRds;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.ExtrarouteRdsKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.DestPrefixes;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.DestPrefixesKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.dest.prefixes.AllocatedRds;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.dest.prefixes.AllocatedRdsKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnToExtraroutes;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.VpnKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.ExtraRoutes;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.ExtraRoutesKey;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.RoutesKey;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.opendaylight.yangtools.yang.common.RpcResult;
  46 import org.opendaylight.yangtools.yang.common.Uint32;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 public final class VpnExtraRouteHelper {
  51     private static final Logger LOG = LoggerFactory.getLogger(VpnExtraRouteHelper.class);
  52
  53     private VpnExtraRouteHelper() {
  54
  55     }
  56
  57     public static Optional<Routes> getVpnExtraroutes(DataBroker broker, String vpnName,
  58                                                      String vpnRd, String destPrefix) {
  59         InstanceIdentifier<Routes> vpnExtraRoutesId = getVpnToExtrarouteVrfIdIdentifier(vpnName, vpnRd, destPrefix);
  60         Optional<Routes> extraRouteOptional = Optional.empty();
  61         try {
  62             extraRouteOptional = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.OPERATIONAL,
  63                     vpnExtraRoutesId);
  64         } catch (ExecutionException | InterruptedException e) {
  65             LOG.error("getVpnExtraroutes: failed to read VpnToExtraRoutes for vpn {} rd {} destprefix {} due "
  66                     + "to exception", vpnName, vpnRd, destPrefix, e);
  67         }
  68         return extraRouteOptional;
  69     }
  70
  71     public static Optional<Routes> getVpnExtraroutes(TypedReadTransaction<Datastore.Operational> operTx,
  72                                                      String vpnName, String vpnRd, String destPrefix)
  73             throws ExecutionException, InterruptedException {
  74         return operTx.read(getVpnToExtrarouteVrfIdIdentifier(vpnName, vpnRd, destPrefix)).get();
  75     }
  76
  77     public static  InstanceIdentifier<Routes> getVpnToExtrarouteVrfIdIdentifier(String vpnName, String vrfId,
  78             String ipPrefix) {
  79         return InstanceIdentifier.builder(VpnToExtraroutes.class)
  80                 .child(Vpn.class, new VpnKey(vpnName)).child(ExtraRoutes.class,
  81                         new ExtraRoutesKey(vrfId)).child(Routes.class, new RoutesKey(ipPrefix)).build();
  82     }
  83
  84     public static  InstanceIdentifier<Vpn> getVpnToExtrarouteVpnIdentifier(String vpnName) {
  85         return InstanceIdentifier.builder(VpnToExtraroutes.class)
  86                 .child(Vpn.class, new VpnKey(vpnName)).build();
  87     }
  88
  89     public static List<Routes> getAllVpnExtraRoutes(DataBroker dataBroker, String vpnName,
  90             List<String> usedRds, String destPrefix) {
  91         List<Routes> routes = new ArrayList<>();
  92         for (String rd : usedRds) {
  93             try {
  94                 Optional<Routes> extraRouteInfo = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
  95                                 getVpnToExtrarouteVrfIdIdentifier(vpnName, rd, destPrefix));
  96                 extraRouteInfo.ifPresent(routes::add);
  97             } catch (ExecutionException | InterruptedException e) {
  98                 LOG.error("getAllVpnExtraRoutes: failed to read VpnToExtraRouteVrf for vpn {} rd {} destprefix {} due "
  99                        + "to exception", vpnName, rd, destPrefix, e);
 100             }
 101         }
 102         return routes;
 103     }
 104
 105     public static  List<String> getUsedRds(DataBroker broker, Uint32 vpnId, String destPrefix) {
 106         InstanceIdentifier<DestPrefixes> usedRdsId = getUsedRdsIdentifier(vpnId, destPrefix);
 107         Optional<DestPrefixes> usedRds = Optional.empty();
 108         try {
 109             usedRds = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId);
 110         } catch (ExecutionException | InterruptedException e) {
 111             LOG.error("getUsedRds: failed to read Used Rds for vpn {} destprefix {} due to exception", vpnId,
 112                     destPrefix, e);
 113         }
 114         return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null
 115                 ? usedRds.get().nonnullAllocatedRds().values().stream()
 116                 .map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
 117     }
 118
 119     public static  List<String> getUsedRds(org.opendaylight.mdsal.binding.util
 120                                                    .TypedReadTransaction<Datastore.Configuration> confTx,
 121                                            Uint32 vpnId, String destPrefix)
 122             throws ExecutionException, InterruptedException {
 123         Optional<DestPrefixes> usedRds = confTx.read(getUsedRdsIdentifier(vpnId, destPrefix)).get();
 124         return usedRds.isPresent() && usedRds.get().getAllocatedRds() != null
 125                 ? usedRds.get().nonnullAllocatedRds().values().stream()
 126             .map(AllocatedRds::getRd).distinct().collect(toList()) : new ArrayList<>();
 127     }
 128
 129     public static  InstanceIdentifier<ExtrarouteRds> getUsedRdsIdentifier(Uint32 vpnId) {
 130         return InstanceIdentifier.builder(ExtrarouteRdsMap.class)
 131                 .child(ExtrarouteRds.class, new ExtrarouteRdsKey(vpnId)).build();
 132     }
 133
 134     public static  InstanceIdentifier<DestPrefixes> getUsedRdsIdentifier(Uint32 vpnId, String destPrefix) {
 135         return InstanceIdentifier.builder(ExtrarouteRdsMap.class)
 136                 .child(ExtrarouteRds.class, new ExtrarouteRdsKey(vpnId))
 137                 .child(DestPrefixes.class, new DestPrefixesKey(destPrefix)).build();
 138     }
 139
 140     public static  InstanceIdentifier<AllocatedRds> getUsedRdsIdentifier(Uint32 vpnId, String destPrefix, String nh) {
 141         return InstanceIdentifier.builder(ExtrarouteRdsMap.class)
 142                 .child(ExtrarouteRds.class, new ExtrarouteRdsKey(vpnId))
 143                 .child(DestPrefixes.class, new DestPrefixesKey(destPrefix))
 144                 .child(AllocatedRds.class, new AllocatedRdsKey(nh)).build();
 145     }
 146
 147     @Nullable
 148     public static Class<? extends TunnelTypeBase> getTunnelType(ItmRpcService itmRpcService, String ifName) {
 149         try {
 150             Future<RpcResult<GetTunnelTypeOutput>> result =
 151                     itmRpcService.getTunnelType(new GetTunnelTypeInputBuilder().setIntfName(ifName).build());
 152             RpcResult<GetTunnelTypeOutput> rpcResult = result.get();
 153             if (!rpcResult.isSuccessful()) {
 154                 LOG.warn("RPC Call to getTunnelInterfaceId returned with Errors {}", rpcResult.getErrors());
 155             } else {
 156                 return rpcResult.getResult().getTunnelType();
 157             }
 158         } catch (InterruptedException | ExecutionException e) {
 159             LOG.warn("Exception when getting tunnel interface Id for tunnel type", e);
 160         }
 161         return null;
 162     }
 163
 164     public static java.util.Optional<String> getRdAllocatedForExtraRoute(DataBroker broker,
 165             Uint32 vpnId, String destPrefix, String nextHop) {
 166         InstanceIdentifier<AllocatedRds> usedRdsId = getUsedRdsIdentifier(vpnId, destPrefix, nextHop);
 167         try {
 168             return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId)
 169                     .map(AllocatedRds::getRd);
 170         } catch (ExecutionException | InterruptedException e) {
 171             LOG.error("getRdAllocatedForExtraRoute: failed to read Used Rds for vpn {} destprefix {} nexthop {} due "
 172                     + "to exception", vpnId, destPrefix, nextHop, e);
 173         }
 174         return Optional.empty();
 175     }
 176
 177     public static List<DestPrefixes> getExtraRouteDestPrefixes(DataBroker broker, Uint32 vpnId) {
 178         try {
 179             Optional<ExtrarouteRds> optionalExtraRoutes = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
 180                     getUsedRdsIdentifier(vpnId));
 181             Map<DestPrefixesKey, DestPrefixes> prefixesMap
 182                     = optionalExtraRoutes.map(ExtrarouteRds::getDestPrefixes).orElse(null);
 183             return prefixesMap == null ? Collections.emptyList() : new ArrayList<DestPrefixes>(prefixesMap.values());
 184         } catch (ExecutionException | InterruptedException e) {
 185             LOG.error("getExtraRouteDestPrefixes: failed to read ExRoutesRdsMap for vpn {} due to exception", vpnId, e);
 186         }
 187         return new ArrayList<>();
 188     }
 189 }