<artifactId>mdsalutil-api</artifactId>
<version>${genius.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.genius</groupId>
+ <artifactId>networkutils</artifactId>
+ <version>${genius.version}</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgpmanager-api</artifactId>
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
private final IFibManager fibManager;
private final FibRpcService fibService;
private final IVpnManager vpnManager;
- private final IdManagerService idManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public EvpnDnatFlowProgrammer(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final IFibManager fibManager,
final FibRpcService fibService,
final IVpnManager vpnManager,
- final IdManagerService idManager) {
+ final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.fibManager = fibManager;
this.fibService = fibService;
this.vpnManager = vpnManager;
- this.idManager = idManager;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
public void onAddFloatingIp(final BigInteger dpnId, final String routerName, final long routerId,
LOG.debug("onAddFloatingIp : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue with installing "
+ "DNAT flows for FloatingIp {}", vpnName, rd, externalIp);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
FloatingIPListener.updateOperationalDS(dataBroker, routerName, interfaceName, NatConstants.DEFAULT_LABEL_VALUE,
internalIp, externalIp);
LOG.debug("onRemoveFloatingIp : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue with installing "
+ "DNAT flows for FloatingIp {}", vpnName, rd, externalIp);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
private final IMdsalApiManager mdsalManager;
private final IdManagerService idManager;
private final EvpnSnatFlowProgrammer evpnSnatFlowProgrammer;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public EvpnNaptSwitchHA(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final EvpnSnatFlowProgrammer evpnSnatFlowProgrammer,
- final IdManagerService idManager) {
+ final IdManagerService idManager, final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.mdsalManager = mdsalManager;
this.evpnSnatFlowProgrammer = evpnSnatFlowProgrammer;
this.idManager = idManager;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
public void evpnRemoveSnatFlowsInOldNaptSwitch(String routerName, long routerId, String vpnName,
LOG.debug("evpnRemoveSnatFlowsInOldNaptSwitch : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue to installing "
+ "NAT flows", vpnName, rd);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
String gwMacAddress = NatUtil.getExtGwMacAddFromRouterName(dataBroker, routerName);
if (gwMacAddress == null) {
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
private final IBgpManager bgpManager;
private final IFibManager fibManager;
private final FibRpcService fibService;
- private final IdManagerService idManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public EvpnSnatFlowProgrammer(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final IBgpManager bgpManager,
final IFibManager fibManager,
final FibRpcService fibService,
- final IdManagerService idManager) {
+ final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.mdsalManager = mdsalManager;
this.bgpManager = bgpManager;
this.fibManager = fibManager;
this.fibService = fibService;
- this.idManager = idManager;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
public void evpnAdvToBgpAndInstallFibAndTsFlows(final BigInteger dpnId, final short tableId,
LOG.debug("evpnAdvToBgpAndInstallFibAndTsFlows : L3VNI value is not configured in Internet VPN {}"
+ " and RD {} Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue with "
+ "installing SNAT flows for External Fixed IP {}", vpnName, rd, externalIp);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
long vpnId = NatUtil.getVpnId(dataBroker, vpnName);
LOG.debug("evpnDelFibTsAndReverseTraffic : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue with installing "
+ "SNAT flows for External Fixed IP {}", vpnName, rd, externalIp);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
final String externalFixedIp = NatUtil.validateAndAddNetworkMask(externalIp);
private final JobCoordinator coordinator;
private final UpgradeState upgradeState;
private final IInterfaceManager interfaceManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
private final int snatPuntTimeout;
@Inject
final IElanService elanManager,
final JobCoordinator coordinator,
final UpgradeState upgradeState,
+ final NatOverVxlanUtil natOverVxlanUtil,
final IInterfaceManager interfaceManager) {
super(Routers.class, ExternalRoutersListener.class);
this.dataBroker = dataBroker;
this.coordinator = coordinator;
this.upgradeState = upgradeState;
this.interfaceManager = interfaceManager;
+ this.natOverVxlanUtil = natOverVxlanUtil;
if (config != null) {
this.natMode = config.getNatMode();
this.snatPuntTimeout = config.getSnatPuntTimeout().intValue();
primarySwitchId, routerName);
return primarySwitchId;
}
- // Validating and creating VNI pool during when NAPT switch is selected.
- // With Assumption this might be the first NAT service comes up.
- NatOverVxlanUtil.validateAndCreateVxlanVniPool(dataBroker, nvpnManager, idManager,
- NatConstants.ODL_VNI_POOL_NAME);
// Allocated an id from VNI pool for the Router.
- NatOverVxlanUtil.getRouterVni(idManager, routerName, NatConstants.INVALID_ID);
+ natOverVxlanUtil.getRouterVni(routerName, NatConstants.INVALID_ID);
primarySwitchId = naptSwitchSelector.selectNewNAPTSwitch(routerName);
LOG.debug("handleEnableSnat : Primary NAPT switch DPN ID {}", primarySwitchId);
matches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(routerId), MetaDataUtil.METADATA_MASK_VRFID));
List<ActionInfo> actionsInfo = new ArrayList<>();
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager, idManager,
+ routerId, routerName);
actionsInfo.add(new ActionSetFieldTunnelId(BigInteger.valueOf(tunnelId)));
LOG.debug("buildSnatFlowEntity : Setting the tunnel to the list of action infos {}", actionsInfo);
actionsInfo.add(new ActionGroup(groupId));
private FlowEntity buildTsFlowEntity(BigInteger dpId, String routerName, long routerId) {
List<MatchInfo> matches = new ArrayList<>();
matches.add(MatchEthernetType.IPV4);
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager,
+ idManager, routerId, routerName);
matches.add(new MatchTunnelId(BigInteger.valueOf(tunnelId)));
String flowRef = getFlowRefTs(dpId, NwConstants.INTERNAL_TUNNEL_TABLE, tunnelId);
List<InstructionInfo> instructions = new ArrayList<>();
//Inform BGP
long l3vni = 0;
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
- l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, l3vni).longValue();
+ l3vni = natOverVxlanUtil.getInternetVpnVni(vpnName, l3vni).longValue();
}
Routers extRouter = router != null ? router :
NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
handleDisableSnat(router, networkUuid, externalIps, true, null, primarySwitchId,
routerId, tx);
}
- NatOverVxlanUtil.releaseVNI(routerName, idManager);
+ natOverVxlanUtil.releaseVNI(routerName);
})), NatConstants.NAT_DJC_MAX_RETRIES);
}
LOG.error("handleDisableSnatInternetVpn : Failed to remove fib entries for routerId {} "
+ "in naptSwitchDpnId {}", routerId, naptSwitchDpnId, ex);
}
- NatOverVxlanUtil.releaseVNI(vpnId, idManager);
+ natOverVxlanUtil.releaseVNI(vpnId);
} catch (InterruptedException | ExecutionException e) {
LOG.error("handleDisableSnatInternetVpn: Exception while handling disableSNATInternetVpn for router {} "
+ "with internet vpn {}", routerName, vpnId, e);
//Remove the Terminating Service table entry which forwards the packet to Outbound NAPT Table (For the
// traffic which comes from the VMs of the non NAPT switches)
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil,
+ elanManager, idManager, routerId, routerName);
String tsFlowRef = getFlowRefTs(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, tunnelId);
FlowEntity tsNatFlowEntity = NatUtil.buildFlowEntity(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE, tsFlowRef);
LOG.info(
matches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(changedVpnId), MetaDataUtil.METADATA_MASK_VRFID));
List<ActionInfo> actionsInfo = new ArrayList<>();
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, changedVpnId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil,
+ elanManager, idManager, changedVpnId, routerName);
actionsInfo.add(new ActionSetFieldTunnelId(BigInteger.valueOf(tunnelId)));
LOG.debug("buildSnatFlowEntityWithUpdatedVpnId : Setting the tunnel to the list of action infos {}",
actionsInfo);
BigInteger tunnelId = BigInteger.valueOf(changedVpnId);
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
- tunnelId = NatOverVxlanUtil.getRouterVni(idManager, routerName, changedVpnId);
+ tunnelId = natOverVxlanUtil.getRouterVni(routerName, changedVpnId);
}
matches.add(new MatchTunnelId(tunnelId));
private final IdManagerService idManager;
private final IInterfaceManager interfaceManager;
private final SalFlowService salFlowServiceRpc;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public NaptEventHandler(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final IInterfaceManager interfaceManager,
final IElanService elanManager,
final IdManagerService idManager,
- final SalFlowService salFlowServiceRpc) {
+ final SalFlowService salFlowServiceRpc,
+ final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.mdsalManager = mdsalManager;
this.naptManager = naptManager;
this.elanManager = elanManager;
this.idManager = idManager;
this.salFlowServiceRpc = salFlowServiceRpc;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
// TODO Clean up the exception handling
if (pktOut != null) {
String routerName = NatUtil.getRouterName(dataBroker, routerId);
- long tunId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerId,
- routerName);
+ long tunId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager,
+ idManager, routerId, routerName);
LOG.info("sendNaptPacketOut for ({}:{}) on dpnId {} portNum {} tunId {}",
naptEntryEvent.getIpAddress(), naptEntryEvent.getPortNumber(), dpnID, portNum, tunId);
sendNaptPacketOut(pktOut, dpnID, portNum, actionInfos, tunId);
private final SnatServiceManager natServiceManager;
private final NatMode natMode;
private final IInterfaceManager interfaceManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
private volatile Collection<String> externalIpsCache;
final SnatServiceManager natServiceManager,
final NatserviceConfig config,
final NaptEventHandler naptEventHandler,
- final IInterfaceManager interfaceManager) {
+ final IInterfaceManager interfaceManager,
+ final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.mdsalManager = mdsalManager;
this.externalRouterListener = externalRouterListener;
} else {
this.natMode = NatMode.Controller;
}
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
protected void removeSnatFlowsInOldNaptSwitch(String routerName, Long routerId, BigInteger naptSwitch,
evpnNaptSwitchHA.evpnRemoveSnatFlowsInOldNaptSwitch(routerName, routerId, vpnName, naptSwitch, confTx);
} else {
//Remove the Terminating Service table entry which forwards the packet to Outbound NAPT Table
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager,
+ idManager, routerId, routerName);
String tsFlowRef = externalRouterListener.getFlowRefTs(naptSwitch, NwConstants.INTERNAL_TUNNEL_TABLE,
tunnelId);
FlowEntity tsNatFlowEntity = NatUtil.buildFlowEntity(naptSwitch, NwConstants.INTERNAL_TUNNEL_TABLE,
if (addordel == NatConstants.ADD_FLOW) {
List<ActionInfo> actionsInfo = new ArrayList<>();
- long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, elanManager, idManager, routerVpnId,
- routerName);
+ long tunnelId = NatUtil.getTunnelIdForNonNaptToNaptFlow(dataBroker, natOverVxlanUtil, elanManager,
+ idManager, routerVpnId, routerName);
actionsInfo.add(new ActionSetFieldTunnelId(BigInteger.valueOf(tunnelId)));
LOG.debug("buildSnatFlowEntity : Setting the tunnel to the list of action infos {}", actionsInfo);
actionsInfo.add(new ActionGroup(groupId));
*/
package org.opendaylight.netvirt.natservice.internal;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
-import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.opendaylight.genius.networkutils.VniUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class NatOverVxlanUtil {
+@Singleton
+public class NatOverVxlanUtil {
private static final Logger LOG = LoggerFactory.getLogger(NatOverVxlanUtil.class);
- private NatOverVxlanUtil() { }
+ private VniUtils vniUtils;
- public static BigInteger getInternetVpnVni(IdManagerService idManager, String vpnUuid, long vpnid) {
- BigInteger internetVpnVni = getVNI(vpnUuid, idManager);
+ @Inject
+ public NatOverVxlanUtil(final VniUtils vniUtils) {
+ this.vniUtils = vniUtils;
+ }
+
+ public BigInteger getInternetVpnVni(String vpnUuid, long vpnid) {
+ BigInteger internetVpnVni = getVNI(vpnUuid);
if (internetVpnVni.longValue() == -1) {
LOG.warn("getInternetVpnVni : Unable to obtain Internet Vpn VNI from VNI POOL for Vpn {}."
+ "Will use tunnel_id {} as Internet VNI", vpnUuid, vpnid);
return BigInteger.valueOf(vpnid);
}
+
return internetVpnVni;
}
- public static BigInteger getRouterVni(IdManagerService idManager, String routerName, long routerId) {
- BigInteger routerVni = getVNI(routerName, idManager);
+ public BigInteger getRouterVni(String routerName, long routerId) {
+ BigInteger routerVni = getVNI(routerName);
if (routerVni.longValue() == -1) {
LOG.warn("getRouterVni : Unable to obtain Router VNI from VNI POOL for router {}."
+ "Router ID will be used as tun_id", routerName);
return routerVni;
}
- public static BigInteger getVNI(String vniKey, IdManagerService idManager) {
- AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(NatConstants.ODL_VNI_POOL_NAME)
- .setIdKey(vniKey).build();
- try {
- Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
- RpcResult<AllocateIdOutput> rpcResult = result.get();
- if (rpcResult.isSuccessful()) {
- return BigInteger.valueOf(rpcResult.getResult().getIdValue());
- }
- } catch (NullPointerException | InterruptedException | ExecutionException e) {
- LOG.error("getVNI : Exception in get VNI for key {}", vniKey, e);
- }
- return BigInteger.valueOf(-1);
- }
-
- public static void releaseVNI(String vniKey, IdManagerService idManager) {
- ReleaseIdInput releaseIdInput = new ReleaseIdInputBuilder().setPoolName(NatConstants.ODL_VNI_POOL_NAME)
- .setIdKey(vniKey).build();
- try {
- RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(releaseIdInput).get();
- if (!rpcResult.isSuccessful()) {
- LOG.warn("releaseVNI : Unable to release ID {} from OpenDaylight VXLAN VNI range pool. Error {}",
- vniKey, rpcResult.getErrors());
- }
- } catch (NullPointerException | InterruptedException | ExecutionException e) {
- LOG.error("releaseVNI : Exception in release VNI for Key {}", vniKey, e);
- }
- }
-
- public static void validateAndCreateVxlanVniPool(DataBroker broker, INeutronVpnManager neutronvpnManager,
- IdManagerService idManager, String poolName) {
- /*
- * 1. If a NatPool doesn't exist create it. 2. If a NatPool exists, but
- * the range value is changed incorrectly (say some allocations exist in
- * the old range), we should NOT honor the new range . Throw the WARN
- * but continue running NAT Service with Old range. 3. If a NatPool
- * exists, but the given range is wider than the earlier one, we should
- * attempt to allocate with the new range again(TODO)
- */
- long lowLimit = NatConstants.VNI_DEFAULT_LOW_VALUE;
- long highLimit = NatConstants.VNI_DEFAULT_HIGH_VALUE;
- String configureVniRange = neutronvpnManager.getOpenDaylightVniRangesConfig();
- if (configureVniRange != null) {
- String[] configureVniRangeSplit = configureVniRange.split(":");
- lowLimit = Long.parseLong(configureVniRangeSplit[0]);
- highLimit = Long.parseLong(configureVniRangeSplit[1]);
- }
- Optional<IdPool> existingIdPool =
- SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, getIdPoolInstance(poolName));
- if (existingIdPool.isPresent()) {
- IdPool odlVniIdPool = existingIdPool.get();
- long currentStartLimit = odlVniIdPool.getAvailableIdsHolder().getStart();
- long currentEndLimit = odlVniIdPool.getAvailableIdsHolder().getEnd();
-
- if (lowLimit == currentStartLimit && highLimit == currentEndLimit) {
- LOG.debug("validateAndCreateVxlanVniPool : OpenDaylight VXLAN VNI range pool already exists "
- + "with configured Range");
- } else {
- if (odlVniIdPool.getIdEntries() != null && odlVniIdPool.getIdEntries().size() != 0) {
- LOG.warn("validateAndCreateVxlanVniPool : Some Allocation already exists with old Range. "
- + "Cannot modify existing limit of OpenDaylight VXLAN VNI range pool");
- } else {
- LOG.debug("validateAndCreateVxlanVniPool : No VNI's allocated from OpenDaylight VXLAN VNI range "
- + "pool. Delete and re-create pool with new configured Range {}-{}",lowLimit, highLimit);
- deleteOpenDaylightVniRangesPool(idManager, poolName);
- createOpenDaylightVniRangesPool(idManager, poolName, lowLimit, highLimit);
- }
- }
- } else {
- createOpenDaylightVniRangesPool(idManager, poolName, lowLimit, highLimit);
- }
- }
-
- public static void createOpenDaylightVniRangesPool(IdManagerService idManager, String poolName, long lowLimit,
- long highLimit) {
-
- CreateIdPoolInput createPool = null;
- createPool = new CreateIdPoolInputBuilder().setPoolName(poolName).setLow(lowLimit).setHigh(highLimit).build();
+ public void releaseVNI(String vniKey) {
try {
- Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
- if (result != null && result.get().isSuccessful()) {
- LOG.debug("createOpenDaylightVniRangesPool : Created OpenDaylight VXLAN VNI range pool {} "
- + "with range {}-{}", poolName, lowLimit, highLimit);
- } else {
- LOG.error("createOpenDaylightVniRangesPool : Failed to create OpenDaylight VXLAN VNI range pool {} "
- + "with range {}-{}", poolName, lowLimit, highLimit);
- }
+ vniUtils.releaseVNI(vniKey);
} catch (InterruptedException | ExecutionException e) {
- LOG.error("createOpenDaylightVniRangesPool : Failed to create OpenDaylight VXLAN VNI range pool {} "
- + "with range {}-{}", poolName, lowLimit, highLimit);
+ LOG.error("releaseVNI : Exception in release VNI for Key {}", vniKey, e);
}
}
- public static void deleteOpenDaylightVniRangesPool(IdManagerService idManager, String poolName) {
-
- DeleteIdPoolInput deletePool = new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
- Future<RpcResult<DeleteIdPoolOutput>> result = idManager.deleteIdPool(deletePool);
+ private BigInteger getVNI(String vniKey) {
try {
- if (result != null && result.get().isSuccessful()) {
- LOG.debug("deleteOpenDaylightVniRangesPool : Deleted OpenDaylight VXLAN VNI range pool {} successfully",
- poolName);
- } else {
- LOG.error("deleteOpenDaylightVniRangesPool : Failed to delete OpenDaylight VXLAN VNI range pool {} ",
- poolName);
- }
+ return vniUtils.getVNI(vniKey);
} catch (InterruptedException | ExecutionException e) {
- LOG.error("deleteOpenDaylightVniRangesPool : Failed to delete OpenDaylight VXLAN VNI range pool {} ",
- poolName, e);
+ LOG.error("getVNI : Exception in get VNI for key {}", vniKey, e);
}
- }
-
- private static InstanceIdentifier<IdPool> getIdPoolInstance(String poolName) {
- InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idPoolBuilder = InstanceIdentifier.builder(IdPools.class)
- .child(IdPool.class, new IdPoolKey(poolName));
- InstanceIdentifier<IdPool> id = idPoolBuilder.build();
- return id;
+ return BigInteger.valueOf(-1);
}
}
private final FibRpcService fibRpcService;
private final IElanService elanManager;
private final IInterfaceManager interfaceManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
private final NatMode natMode;
protected enum TunnelAction {
* @param config - Nat Service Config
* @param elanManager - Elan Manager
* @param interfaceManager - Interface Manager
+ * @param natOverVxlanUtils - Nat Over Vxlan Utility
*/
@Inject
public NatTunnelInterfaceStateListener(final DataBroker dataBroker,
final FibRpcService fibRpcService,
final NatserviceConfig config,
final IElanService elanManager,
- final IInterfaceManager interfaceManager) {
+ final IInterfaceManager interfaceManager,
+ final NatOverVxlanUtil natOverVxlanUtils) {
super(StateTunnelList.class, NatTunnelInterfaceStateListener.class);
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.fibRpcService = fibRpcService;
this.elanManager = elanManager;
this.interfaceManager = interfaceManager;
+ this.natOverVxlanUtil = natOverVxlanUtils;
if (config != null) {
this.natMode = config.getNatMode();
} else {
LOG.debug("hndlTepAddOnNaptSwitch : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue to installing "
+ "NAT flows", vpnName, rd);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, externalVpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(externalVpnName, routerId).longValue();
}
}
+ "having nextHopIp {}", externalIp, nextHopIp);
long l3vni = 0;
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
- l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, externalVpnName, l3vni).longValue();
+ l3vni = natOverVxlanUtil.getInternetVpnVni(externalVpnName, l3vni).longValue();
}
NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, externalVpnName, rd,
fibExternalIp, nextHopIp, networkId.getValue(), null /* mac-address */, label, l3vni,
LOG.debug("hndlTepAddForDnatInEachRtr : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue to installing "
+ "NAT flows", vpnName, rd);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
}
for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
+ "having nextHopIp {}", externalIp, nextHopIp);
long l3vni = 0;
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
- l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, l3vni).longValue();
+ l3vni = natOverVxlanUtil.getInternetVpnVni(vpnName, l3vni).longValue();
}
NatUtil.addPrefixToBGP(dataBroker, bgpManager, fibManager, vpnName, rd,
fibExternalIp, nextHopIp, null, null, label, l3vni, RouteOrigin.STATIC,
LOG.debug("hndlTepDelForDnatInEachRtr : L3VNI value is not configured in Internet VPN {} and RD {} "
+ "Carve-out L3VNI value from OpenDaylight VXLAN VNI Pool and continue to installing "
+ "NAT flows", vpnName, rd);
- l3Vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, routerId).longValue();
+ l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
}
for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
.child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
}
- public static long getTunnelIdForNonNaptToNaptFlow(DataBroker dataBroker, IElanService elanManager,
- IdManagerService idManager, long routerId, String routerName) {
+ public static long getTunnelIdForNonNaptToNaptFlow(DataBroker dataBroker, NatOverVxlanUtil natOverVxlanUtil,
+ IElanService elanManager, IdManagerService idManager,
+ long routerId, String routerName) {
if (elanManager.isOpenStackVniSemanticsEnforced()) {
// Router VNI will be set as tun_id if OpenStackSemantics is enabled
- return NatOverVxlanUtil.getRouterVni(idManager, routerName, routerId).longValue();
+ return natOverVxlanUtil.getRouterVni(routerName, routerId).longValue();
} else {
return NatEvpnUtil.getTunnelIdForRouter(idManager, dataBroker, routerName, routerId);
}
return;
}
LOG.debug("handleSNATForDPN : Switch {} is elected as NaptSwitch for router {}", dpnId, routerName);
-
- // When NAPT switch is elected during first VM comes up for the given Router
- if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanManager, extNwProvType)) {
- NatOverVxlanUtil.validateAndCreateVxlanVniPool(dataBroker, nvpnManager,
- idManager, NatConstants.ODL_VNI_POOL_NAME);
- }
-
Routers extRouters = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
if (extRouters != null) {
NatUtil.createRouterIdsConfigDS(dataBroker, routerId, routerName);
private final IFibManager fibManager;
private final NatDataUtil natDataUtil;
private final DataTreeEventCallbackRegistrar eventCallbacks;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public SnatServiceImplFactory(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final IVpnFootprintService vpnFootprintService,
final IFibManager fibManager,
final NatDataUtil natDataUtil,
- final DataTreeEventCallbackRegistrar eventCallbacks) {
+ final DataTreeEventCallbackRegistrar eventCallbacks,
+ final NatOverVxlanUtil natOverVxlanUtil) {
this.dataBroker = dataBroker;
this.mdsalManager = mdsalManager;
this.itmManager = itmManager;
this.fibManager = fibManager;
this.natDataUtil = natDataUtil;
this.eventCallbacks = eventCallbacks;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
@Override
@Nullable
public AbstractSnatService createVxlanGreSnatServiceImpl() {
if (natMode == NatMode.Conntrack) {
- NatOverVxlanUtil.validateAndCreateVxlanVniPool(dataBroker, nvpnManager, idManager,
- NatConstants.ODL_VNI_POOL_NAME);
return new VxlanGreConntrackBasedSnatService(dataBroker, mdsalManager, itmManager, odlInterfaceRpcService,
idManager, naptSwitchSelector, externalRouterListener, elanManager, interfaceManager,
- vpnFootprintService, fibManager, natDataUtil, eventCallbacks);
+ vpnFootprintService, fibManager, natDataUtil, eventCallbacks, natOverVxlanUtil);
}
return null;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.SendArpRequestInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.interfaces.InterfaceAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fib.rpc.rev160121.CreateFibEntryOutput;
private final IElanService elanService;
private final EvpnDnatFlowProgrammer evpnDnatFlowProgrammer;
private final INeutronVpnManager nvpnManager;
- private final IdManagerService idManager;
private final NatServiceCounters natServiceCounters;
+ private final NatOverVxlanUtil natOverVxlanUtil;
@Inject
public VpnFloatingIpHandler(final DataBroker dataBroker, final IMdsalApiManager mdsalManager,
final IElanService elanService,
final EvpnDnatFlowProgrammer evpnDnatFlowProgrammer,
final INeutronVpnManager nvpnManager,
- final IdManagerService idManager,
+ final NatOverVxlanUtil natOverVxlanUtil,
NatServiceCounters natServiceCounters) {
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.elanService = elanService;
this.evpnDnatFlowProgrammer = evpnDnatFlowProgrammer;
this.nvpnManager = nvpnManager;
- this.idManager = idManager;
this.natServiceCounters = natServiceCounters;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
@Override
* datapath for traffic forwarding for ``SNAT-to-DNAT`` and ``DNAT-to-DNAT`` cases within the
* DataCenter.
*/
- if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
- NatOverVxlanUtil.validateAndCreateVxlanVniPool(dataBroker, nvpnManager, idManager,
- NatConstants.ODL_VNI_POOL_NAME);
- }
String nextHopIp = NatUtil.getEndpointIpAddressForDPN(dataBroker, dpnId);
LOG.debug("onAddFloatingIp: Nexthop ip for prefix {} is {}", externalIp, nextHopIp);
if (provType == ProviderTypes.VXLAN) {
*/
long l3vni = 0;
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
- l3vni = NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, l3vni).longValue();
+ l3vni = natOverVxlanUtil.getInternetVpnVni(vpnName, l3vni).longValue();
}
String fibExternalIp = NatUtil.validateAndAddNetworkMask(externalIp);
//Inform BGP
// DPN, then the traffic will be hijacked to DNAT and if there are no DNAT match,
// then handled back to using using flow 25->44(which will be installed as part of SNAT)
if (NatUtil.isOpenStackVniSemanticsEnforcedForGreAndVxlan(elanService, provType)) {
- mkMatches.add(new MatchTunnelId(NatOverVxlanUtil.getInternetVpnVni(idManager, vpnName, serviceId)));
+ mkMatches.add(new MatchTunnelId(natOverVxlanUtil.getInternetVpnVni(vpnName, serviceId)));
flowPriority = 6;
} else {
mkMatches.add(new MatchTunnelId(BigInteger.valueOf(serviceId)));
private static final Logger LOG = LoggerFactory.getLogger(VxlanGreConntrackBasedSnatService.class);
private final ExternalRoutersListener externalRouterListener;
private final IElanService elanManager;
+ private final NatOverVxlanUtil natOverVxlanUtil;
public VxlanGreConntrackBasedSnatService(DataBroker dataBroker, IMdsalApiManager mdsalManager,
ItmRpcService itmManager, OdlInterfaceRpcService odlInterfaceRpcService,
IInterfaceManager interfaceManager,
IVpnFootprintService vpnFootprintService,
IFibManager fibManager, NatDataUtil natDataUtil,
- DataTreeEventCallbackRegistrar eventCallbacks) {
+ DataTreeEventCallbackRegistrar eventCallbacks,
+ NatOverVxlanUtil natOverVxlanUtil) {
super(dataBroker, mdsalManager, itmManager, idManager, naptSwitchSelector, odlInterfaceRpcService,
interfaceManager, vpnFootprintService, fibManager, natDataUtil, eventCallbacks);
this.externalRouterListener = externalRouterListener;
this.elanManager = elanManager;
+ this.natOverVxlanUtil = natOverVxlanUtil;
}
@Override
BigInteger tunnelId = BigInteger.valueOf(routerId);
if (elanManager.isOpenStackVniSemanticsEnforced()) {
- tunnelId = NatOverVxlanUtil.getRouterVni(idManager, routerName, routerId);
+ tunnelId = natOverVxlanUtil.getRouterVni(routerName, routerId);
}
matches.add(new MatchTunnelId(tunnelId));
BigInteger tunnelId = BigInteger.valueOf(routerId);
if (elanManager.isOpenStackVniSemanticsEnforced()) {
- tunnelId = NatOverVxlanUtil.getRouterVni(idManager, routerName, routerId);
+ tunnelId = natOverVxlanUtil.getRouterVni(routerName, routerId);
}
actionsInfo.add(new ActionSetFieldTunnelId(tunnelId));
interface="org.opendaylight.infrautils.jobcoordinator.JobCoordinator"/>
<reference id="upgradeState"
interface="org.opendaylight.serviceutils.upgrade.UpgradeState"/>
+ <reference id="vniUtils"
+ interface="org.opendaylight.genius.networkutils.VniUtils"/>
<reference id="dataTreeEventCallbackRegistrar"
interface="org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar"/>
<reference id="metricProvider"