natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/rpcservice/NatRpcServiceImpl.java

   1 /*
   2  * Copyright © 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.natservice.rpcservice;
   9
  10 import com.google.common.util.concurrent.Futures;
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import javax.inject.Inject;
  15 import javax.inject.Singleton;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.genius.mdsalutil.NwConstants;
  18 import org.opendaylight.netvirt.natservice.internal.NatConstants;
  19 import org.opendaylight.netvirt.natservice.internal.NatUtil;
  20 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.Ports;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.ports.InternalToExternalPortMap;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.IpPortMapping;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.IntextIpProtocolType;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.port.map.ip.port.mapping.intext.ip.protocol.type.IpPortMap;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsForNetworkAndIpaddressInput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsForNetworkAndIpaddressOutput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsForNetworkAndIpaddressOutputBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnRouterInput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnRouterOutput;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnRouterOutputBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnVpnInput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnVpnOutput;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.GetNatTranslationsOnVpnOutputBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.OdlNatRpcService;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.dnat.configuration.DnatIpMapping;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.dnat.configuration.DnatIpMappingBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.nat.output.RouterNat;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.nat.output.RouterNatBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.snat.state.SnatIpMapping;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rpc.rev170209.snat.state.SnatIpMappingBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnet.attributes.AllocationPools;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  46 import org.opendaylight.yangtools.yang.common.RpcError;
  47 import org.opendaylight.yangtools.yang.common.RpcResult;
  48 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 @Singleton
  53 public class NatRpcServiceImpl implements OdlNatRpcService {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(NatRpcServiceImpl.class);
  56     private final DataBroker dataBroker;
  57     private final INeutronVpnManager nvpnManager;
  58
  59     @Inject
  60     public NatRpcServiceImpl(final DataBroker dataBroker, final INeutronVpnManager nvpnManager) {
  61         this.dataBroker = dataBroker;
  62         this.nvpnManager = nvpnManager;
  63     }
  64
  65     @Override
  66     public ListenableFuture<RpcResult<GetNatTranslationsOnVpnOutput>> getNatTranslationsOnVpn(
  67             GetNatTranslationsOnVpnInput input) {
  68         RpcResultBuilder<GetNatTranslationsOnVpnOutput> rpcResultBuilder = null;
  69
  70         List<Uuid> routerUuidList = NatUtil.getRouterUuIdsForVpn(dataBroker, input.getVpnUuid());
  71         if (routerUuidList.isEmpty()) {
  72             String errMsg = String.format("404 Not Found - Invalid external vpn {%s} provided",
  73                     input.getVpnUuid().getValue());
  74             rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsOnVpnOutput>failed()
  75                     .withError(RpcError.ErrorType.APPLICATION, errMsg);
  76             return rpcResultBuilder.buildFuture();
  77         }
  78         List<RouterNat> natRouterList = new ArrayList<>();
  79         for (Uuid routerUuid : routerUuidList) {
  80             long routerId = NatUtil.getVpnId(dataBroker, routerUuid.getValue());
  81             if (routerId == NatConstants.INVALID_ID) {
  82                 LOG.warn("getNatTranslationsOnVpn : Invalid RouterID found {}", routerId);
  83                 continue;
  84             }
  85             natRouterList.addAll(constructNatInformation(routerUuid, routerId));
  86         }
  87         GetNatTranslationsOnVpnOutputBuilder output = new GetNatTranslationsOnVpnOutputBuilder()
  88                 .setRouterNat(natRouterList);
  89         rpcResultBuilder = RpcResultBuilder.success();
  90         rpcResultBuilder.withResult(output.build());
  91         return Futures.immediateFuture(rpcResultBuilder.build());
  92     }
  93
  94     @Override
  95     public ListenableFuture<RpcResult<GetNatTranslationsOnRouterOutput>> getNatTranslationsOnRouter(
  96             GetNatTranslationsOnRouterInput input) {
  97         RpcResultBuilder<GetNatTranslationsOnRouterOutput> rpcResultBuilder = null;
  98         long routerId = NatUtil.getVpnId(dataBroker, input.getRouterUuid().getValue());
  99         if (routerId == NatConstants.INVALID_ID) {
 100             String errMsg = String.format("404 Not Found - No Router found with UUID {%s}",
 101                     input.getRouterUuid().getValue());
 102             rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsOnRouterOutput>failed()
 103                     .withError(RpcError.ErrorType.APPLICATION, errMsg);
 104             return rpcResultBuilder.buildFuture();
 105         }
 106
 107         List<RouterNat> routerNatList = constructNatInformation(input.getRouterUuid(), routerId);
 108
 109         GetNatTranslationsOnRouterOutputBuilder output = new GetNatTranslationsOnRouterOutputBuilder()
 110                 .setRouterNat(routerNatList);
 111         rpcResultBuilder = RpcResultBuilder.success();
 112         rpcResultBuilder.withResult(output.build());
 113         return rpcResultBuilder.buildFuture();
 114     }
 115
 116     @Override
 117     public ListenableFuture<RpcResult<GetNatTranslationsForNetworkAndIpaddressOutput>>
 118             getNatTranslationsForNetworkAndIpaddress(GetNatTranslationsForNetworkAndIpaddressInput input) {
 119
 120         String ipAddress = input.getIpAddress().stringValue();
 121         RpcResultBuilder<GetNatTranslationsForNetworkAndIpaddressOutput> rpcResultBuilder = null;
 122         GetNatTranslationsForNetworkAndIpaddressOutputBuilder output = null;
 123
 124         List<Uuid> subnetUuidList = NatUtil.getSubnetIdsFromNetworkId(dataBroker, input.getNetworkUuid());
 125         if (subnetUuidList.isEmpty()) {
 126             String errMsg = String.format("404 Not Found - Invalid Network UUID {%s} provided as no Subnetworks found",
 127                     input.getNetworkUuid().getValue());
 128             rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
 129                     .withError(RpcError.ErrorType.APPLICATION, errMsg);
 130             return rpcResultBuilder.buildFuture();
 131         }
 132         Subnet subNet = null;
 133         Boolean isIpInSubnet = Boolean.FALSE;
 134         outerloop:
 135         for (Uuid subnetUuid: subnetUuidList) {
 136             subNet = nvpnManager.getNeutronSubnet(subnetUuid);
 137             for (AllocationPools allocationPool : subNet.nonnullAllocationPools()) {
 138                 if (NatUtil.isIpInSubnet(ipAddress,
 139                         allocationPool.getStart().stringValue(),
 140                         allocationPool.getEnd().stringValue())) {
 141                     LOG.debug("getNatTranslationsForNetworkAndIpaddress : IP Adderess {} falls within the Subnet {}",
 142                             ipAddress, subNet.getUuid().getValue());
 143                     isIpInSubnet = Boolean.TRUE;
 144                     break outerloop;
 145                 }
 146             }
 147         }
 148
 149         if (!isIpInSubnet) {
 150             String errMsg = String.format("404 Not Found - IP Adress {%s} does not fall within the Subnet IP range"
 151                     + " of Network {%s}", ipAddress, input.getNetworkUuid().getValue());
 152             rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
 153                     .withError(RpcError.ErrorType.APPLICATION, errMsg);
 154             return rpcResultBuilder.buildFuture();
 155         }
 156
 157         Subnetmap subnetMap = NatUtil.getSubnetMap(dataBroker, subNet.getUuid());
 158         long routerId = NatUtil.getVpnId(dataBroker, subnetMap.getRouterId().getValue());
 159
 160         List<Ports> fipPorts = NatUtil.getFloatingIpPortsForRouter(dataBroker, subnetMap.getRouterId());
 161         if (fipPorts.isEmpty()) {
 162             LOG.warn("getNatTranslationsForNetworkAndIpaddress : No DNAT IP Mapping found for IP {}", ipAddress);
 163         } else {
 164             for (Ports fipPort : fipPorts) {
 165                 for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
 166                     if (fipMap.getInternalIp().equals(ipAddress)) {
 167                         output = new GetNatTranslationsForNetworkAndIpaddressOutputBuilder()
 168                                     .setExternalIp(fipMap.getExternalIp())
 169                                     .setNatTranslation("DNAT");
 170                         rpcResultBuilder = RpcResultBuilder.success();
 171                         rpcResultBuilder.withResult(output.build());
 172                         return rpcResultBuilder.buildFuture();
 173                     }
 174                 }
 175             }
 176         }
 177
 178         IpPortMapping ipPortMapping = NatUtil.getIportMapping(dataBroker, routerId);
 179         if (ipPortMapping == null) {
 180             LOG.warn("getNatTranslationsForNetworkAndIpaddress : No SNAT IP Mapping found for IP {}", ipAddress);
 181         } else {
 182             for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
 183                 for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
 184                     String[] internalIpPort = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
 185                     if (ipAddress.equals(internalIpPort[0])) {
 186
 187                         output = new GetNatTranslationsForNetworkAndIpaddressOutputBuilder()
 188                                 .setExternalIp(ipPortMap.getIpPortExternal().getIpAddress())
 189                                 .setInternalIp(internalIpPort[0])
 190                                 .setNatTranslation("SNAT")
 191                                 .setInternalPort(internalIpPort[1])
 192                                 .setExternalPort(ipPortMap.getIpPortExternal().getPortNum().toString())
 193                                 .setProtocol(protocolType.getProtocol().getName());
 194                         rpcResultBuilder = RpcResultBuilder.success();
 195                         rpcResultBuilder.withResult(output.build());
 196                         return rpcResultBuilder.buildFuture();
 197                     }
 198                 }
 199             }
 200         }
 201
 202         String errMsg = String.format("404 Not Found - No NAT Translation found for IP {%s}", ipAddress);
 203         rpcResultBuilder = RpcResultBuilder.<GetNatTranslationsForNetworkAndIpaddressOutput>failed()
 204                 .withError(RpcError.ErrorType.APPLICATION, errMsg);
 205         return rpcResultBuilder.buildFuture();
 206     }
 207
 208     private List<RouterNat> constructNatInformation(Uuid routerUuid, long routerId) {
 209
 210         String neutronRouterName = NatUtil.getNeutronRouterNamebyUuid(dataBroker, routerUuid);
 211
 212         RouterNatBuilder natRouterBuilder = new RouterNatBuilder();
 213         natRouterBuilder.setRouterUuid(routerUuid);
 214         natRouterBuilder.setRouterName(neutronRouterName);
 215
 216         IpPortMapping ipPortMapping = NatUtil.getIportMapping(dataBroker, routerId);
 217         if (ipPortMapping == null) {
 218             LOG.warn("constructNatInformation : No SNAT IP Mapping found for router-uuid {}", routerUuid.getValue());
 219         } else {
 220
 221             // Capturing SNAT information
 222             List<SnatIpMapping> snatIpMapping = new ArrayList<>();
 223
 224             for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
 225                 for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
 226                     String[] internalPortMap = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
 227                     SnatIpMappingBuilder natIpMappingBuilder = new SnatIpMappingBuilder()
 228                             .setInternalIp(internalPortMap[0]).setInternalPort(internalPortMap[1])
 229                             .setExternalIp(ipPortMap.getIpPortExternal().getIpAddress())
 230                             .setExternalPort(ipPortMap.getIpPortExternal().getPortNum().toString())
 231                             .setProtocol(protocolType.getProtocol().getName());
 232                     snatIpMapping.add(natIpMappingBuilder.build());
 233                 }
 234             }
 235             natRouterBuilder.setSnatIpMapping(snatIpMapping);
 236         }
 237
 238         // Capturing DNAT information
 239         List<DnatIpMapping> dnatIpMapping = new ArrayList<>();
 240         List<Ports> fipPorts = NatUtil.getFloatingIpPortsForRouter(dataBroker, routerUuid);
 241         if (fipPorts.isEmpty()) {
 242             LOG.warn("constructNatInformation : No DNAT IP Mapping found for router-uuid {}", routerUuid.getValue());
 243         } else {
 244             for (Ports fipPort : fipPorts) {
 245                 for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
 246                     DnatIpMappingBuilder natIpMappingBuilder = new DnatIpMappingBuilder()
 247                             .setExternalIp(fipMap.getExternalIp()).setInternalIp(fipMap.getInternalIp());
 248                     dnatIpMapping.add(natIpMappingBuilder.build());
 249                 }
 250             }
 251             natRouterBuilder.setDnatIpMapping(dnatIpMapping);
 252         }
 253
 254         List<RouterNat> natRouterList = new ArrayList<>();
 255         natRouterList.add(natRouterBuilder.build());
 256         return natRouterList;
 257     }
 258 }