fibmanager/impl/src/main/java/org/opendaylight/netvirt/fibmanager/FibRpcServiceImpl.java

   1 /*
   2  * Copyright © 2016, 2017 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.fibmanager;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import java.net.InetAddress;
  12 import java.net.UnknownHostException;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.concurrent.ExecutionException;
  18 import javax.inject.Inject;
  19 import javax.inject.Singleton;
  20 import org.apache.commons.lang3.tuple.ImmutablePair;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  23 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  24 import org.opendaylight.genius.mdsalutil.MatchInfo;
  25 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
  26 import org.opendaylight.genius.mdsalutil.NwConstants;
  27 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  28 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
  29 import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Destination;
  30 import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
  31 import org.opendaylight.mdsal.binding.api.DataBroker;
  32 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  33 import org.opendaylight.netvirt.fibmanager.api.IFibManager;
  34 import org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnInput;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutput;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CleanupDpnForVpnOutputBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.FibRpcService;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnInput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnOutput;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.PopulateFibOnDpnOutputBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutput;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.RemoveFibEntryOutputBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey;
  55 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  56 import org.opendaylight.yangtools.yang.common.RpcResult;
  57 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  58 import org.opendaylight.yangtools.yang.common.Uint32;
  59 import org.opendaylight.yangtools.yang.common.Uint64;
  60 import org.slf4j.Logger;
  61 import org.slf4j.LoggerFactory;
  62
  63 @Singleton
  64 public class FibRpcServiceImpl implements FibRpcService {
  65     private static final Logger LOG = LoggerFactory.getLogger(FibRpcServiceImpl.class);
  66     private final DataBroker dataBroker;
  67     private final IMdsalApiManager mdsalManager;
  68     private final IFibManager fibManager;
  69     private final IVpnFootprintService vpnFootprintService;
  70
  71     @Inject
  72     public FibRpcServiceImpl(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
  73                              final IFibManager fibManager, final IVpnFootprintService vpnFootprintService) {
  74         this.dataBroker = dataBroker;
  75         this.mdsalManager = mdsalManager;
  76         this.fibManager = fibManager;
  77         this.vpnFootprintService = vpnFootprintService;
  78     }
  79
  80     /**
  81      * To install FIB routes on specified dpn with given instructions.
  82      */
  83     @Override
  84     public ListenableFuture<RpcResult<CreateFibEntryOutput>> createFibEntry(CreateFibEntryInput input) {
  85
  86         Uint64 dpnId = input.getSourceDpid();
  87         String vpnName = input.getVpnName();
  88         Uint32 vpnId = getVpnId(dataBroker, vpnName);
  89         String vpnRd = getVpnRd(dataBroker, vpnName);
  90         String ipAddress = input.getIpAddress();
  91         LOG.info("Create custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
  92         Map<InstructionKey, Instruction> instructionMap = input.getInstruction();
  93         LOG.info("ADD: Adding Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
  94         makeLocalFibEntry(vpnId, dpnId, ipAddress, new ArrayList<Instruction>(instructionMap.values()));
  95         IpAddresses.IpAddressSource ipAddressSource = IpAddresses.IpAddressSource
  96                 .forValue(input.getIpAddressSource().getIntValue());
  97         vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null /* interfaceName*/,
  98                 new ImmutablePair<>(ipAddressSource, ipAddress), true /*add*/);
  99         LOG.info("ADD: Added Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
 100         return RpcResultBuilder.success(new CreateFibEntryOutputBuilder().build()).buildFuture();
 101     }
 102
 103     /**
 104      * To remove FIB/LFIB/TST routes from specified dpn.
 105      */
 106     @Override
 107     public ListenableFuture<RpcResult<RemoveFibEntryOutput>> removeFibEntry(RemoveFibEntryInput input) {
 108         Uint64 dpnId = input.getSourceDpid();
 109         String vpnName = input.getVpnName();
 110         Uint32 vpnId = getVpnId(dataBroker, vpnName);
 111         String vpnRd = getVpnRd(dataBroker, vpnName);
 112
 113         String ipAddress = input.getIpAddress();
 114
 115         LOG.info("Delete custom FIB entry - {} on dpn {} for VPN {} ", ipAddress, dpnId, vpnName);
 116         LOG.info("REMOVE: Removing Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
 117         removeLocalFibEntry(dpnId, vpnId, ipAddress);
 118         IpAddresses.IpAddressSource ipAddressSource = IpAddresses.IpAddressSource
 119                 .forValue(input.getIpAddressSource().getIntValue());
 120         vpnFootprintService.updateVpnToDpnMapping(dpnId, vpnName, vpnRd, null /* interfaceName*/,
 121                 new ImmutablePair<>(ipAddressSource, ipAddress), false /*add*/);
 122         LOG.info("REMOVE: Removed Custom Fib Entry rd {} prefix {} label {}", vpnRd, ipAddress, input.getServiceId());
 123         return RpcResultBuilder.success(new RemoveFibEntryOutputBuilder().build()).buildFuture();
 124     }
 125
 126
 127     @Override
 128     public ListenableFuture<RpcResult<PopulateFibOnDpnOutput>> populateFibOnDpn(PopulateFibOnDpnInput input) {
 129         fibManager.populateFibOnNewDpn(input.getDpid(), input.getVpnId(), input.getRd(), null);
 130         return RpcResultBuilder.success(new PopulateFibOnDpnOutputBuilder().build()).buildFuture();
 131     }
 132
 133     @Override
 134     public ListenableFuture<RpcResult<CleanupDpnForVpnOutput>> cleanupDpnForVpn(CleanupDpnForVpnInput input) {
 135         fibManager.cleanUpDpnForVpn(input.getDpid(), input.getVpnId(), input.getRd(), null);
 136         return RpcResultBuilder.success(new CleanupDpnForVpnOutputBuilder().build()).buildFuture();
 137     }
 138
 139     private void removeLocalFibEntry(Uint64 dpnId, Uint32 vpnId, String ipPrefix) {
 140         String[] values = ipPrefix.split("/");
 141         String ipAddress = values[0];
 142         int prefixLength = values.length == 1 ? 0 : Integer.parseInt(values[1]);
 143         LOG.debug("Removing route from DPN. ip {} masklen {}", ipAddress, prefixLength);
 144         InetAddress destPrefix = null;
 145         try {
 146             destPrefix = InetAddress.getByName(ipAddress);
 147         } catch (UnknownHostException e) {
 148             LOG.error("UnknowHostException in removeRoute. Failed  to remove Route for ipPrefix {} DPN {} Vpn {}",
 149                     ipAddress, dpnId, vpnId, e);
 150             return;
 151         }
 152         List<MatchInfo> matches = new ArrayList<>();
 153
 154         matches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
 155             MetaDataUtil.METADATA_MASK_VRFID));
 156
 157         matches.add(MatchEthernetType.IPV4);
 158
 159         if (prefixLength != 0) {
 160             matches.add(new MatchIpv4Destination(destPrefix.getHostAddress(), Integer.toString(prefixLength)));
 161         }
 162
 163         String flowRef = getFlowRef(dpnId, NwConstants.L3_FIB_TABLE, vpnId, ipAddress);
 164
 165
 166         int priority = FibConstants.DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 167         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef,
 168             priority, flowRef, 0, 0,
 169             NwConstants.COOKIE_VM_FIB_TABLE, matches, null);
 170
 171         mdsalManager.removeFlow(dpnId, flowEntity);
 172
 173         LOG.info("FIB entry for prefix {} on dpn {} vpn {} removed successfully", ipAddress, dpnId,  vpnId);
 174     }
 175
 176     private void makeLocalFibEntry(Uint32 vpnId, Uint64 dpnId, String ipPrefix,
 177                                    List<Instruction> customInstructions) {
 178         String[] values = ipPrefix.split("/");
 179         String ipAddress = values[0];
 180         int prefixLength = values.length == 1 ? 0 : Integer.parseInt(values[1]);
 181         LOG.debug("Adding route to DPN. ip {} masklen {}", ipAddress, prefixLength);
 182         InetAddress destPrefix = null;
 183         try {
 184             destPrefix = InetAddress.getByName(ipAddress);
 185         } catch (UnknownHostException e) {
 186             LOG.error("UnknowHostException in addRoute. Failed  to add Route for ipPrefix {} VpnId {} DPN{}",
 187                     ipAddress, vpnId, dpnId, e);
 188             return;
 189         }
 190         List<MatchInfo> matches = new ArrayList<>();
 191
 192         matches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
 193             MetaDataUtil.METADATA_MASK_VRFID));
 194
 195         matches.add(MatchEthernetType.IPV4);
 196
 197         if (prefixLength != 0) {
 198             matches.add(new MatchIpv4Destination(destPrefix.getHostAddress(), Integer.toString(prefixLength)));
 199         }
 200
 201         String flowRef = getFlowRef(dpnId, NwConstants.L3_FIB_TABLE, vpnId, ipAddress);
 202
 203
 204         int priority = FibConstants.DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 205         Map<InstructionKey, Instruction> customInstructionsMap = new HashMap<InstructionKey, Instruction>();
 206         int instructionKey = 0;
 207         for (Instruction instructionObj : customInstructions) {
 208             customInstructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
 209         }
 210         Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef,
 211             priority, flowRef, 0, 0,
 212             NwConstants.COOKIE_VM_FIB_TABLE, matches, customInstructionsMap);
 213         mdsalManager.installFlow(dpnId, flowEntity);
 214
 215         LOG.debug("FIB entry for route {} on dpn {} installed successfully - flow {}", ipAddress, dpnId, flowEntity);
 216     }
 217
 218     private String getFlowRef(Uint64 dpnId, short tableId, Uint32 id, String ipAddress) {
 219         return FibConstants.FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR + tableId
 220                 + NwConstants.FLOWID_SEPARATOR + id + NwConstants.FLOWID_SEPARATOR + ipAddress;
 221     }
 222
 223     //TODO: Below Util methods to be removed once VpnUtil methods are exposed in api bundle
 224     @Nullable
 225     public static String getVpnRd(DataBroker broker, String vpnName) {
 226         InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
 227         try {
 228             return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id)
 229                     .map(VpnInstance::getVrfId).orElse(null);
 230         } catch (ExecutionException | InterruptedException e) {
 231             LOG.error("getVpnRd: Exception while reading VpnInstance DS for the vpn {}", vpnName, e);
 232         }
 233         return null;
 234     }
 235
 236     static InstanceIdentifier<VpnInstance> getVpnInstanceToVpnIdIdentifier(String vpnName) {
 237         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 238             .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 239     }
 240
 241
 242     static Uint32 getVpnId(DataBroker broker, String vpnName) {
 243         InstanceIdentifier<VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
 244         try {
 245             return SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id)
 246                     .map(VpnInstance::getVpnId).orElse(Uint32.ZERO);
 247         } catch (ExecutionException | InterruptedException e) {
 248             LOG.error("getVpnId: Exception while reading VpnInstance DS for the vpn {}", vpnName, e);
 249         }
 250         return Uint32.ZERO;
 251     }
 252 }