import com.google.common.base.Optional;
import java.io.PrintStream;
import java.math.BigInteger;
-import java.util.Collections;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.apache.karaf.shell.commands.Command;
ps.printf(String.format(" %-36s %-20s %-20s %n", "Router Id ", "Datapath Node Id", "Managment Ip Address"));
ps.printf("-------------------------------------------------------------------------------------------%n");
if (npatSwitches.isPresent()) {
- for (RouterToNaptSwitch routerToNaptSwitch : NatUtil.requireNonNullElse(
- npatSwitches.get().getRouterToNaptSwitch(), Collections.<RouterToNaptSwitch>emptyList())) {
+ for (RouterToNaptSwitch routerToNaptSwitch : npatSwitches.get().nonnullRouterToNaptSwitch()) {
ps.printf(String.format(" %-36s %-20s %-20s %n", routerToNaptSwitch.getRouterName(),
routerToNaptSwitch.getPrimarySwitchId(), getDpnLocalIp(routerToNaptSwitch.getPrimarySwitchId())));
}
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import java.math.BigInteger;
import java.time.Duration;
addDefaultFibRouteForSNAT(confTx, dpnId, routerId);
int elanId = NatUtil.getElanInstanceByName(routers.getNetworkId().getValue(), getDataBroker())
.getElanTag().intValue();
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
String routerName = routers.getRouterName();
Long routerId = NatUtil.getVpnId(dataBroker, routerName);
removeDefaultFibRouteForSNAT(confTx, dpnId, routerId);
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
String routerName = routers.getRouterName();
Long routerId = NatUtil.getVpnId(dataBroker, routerName);
String externalGwMac = routers.getExtGwMacAddress();
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
Routers routers, BigInteger dpnId) throws ExecutionException, InterruptedException {
String routerName = routers.getRouterName();
Long routerId = NatUtil.getVpnId(confTx, routerName);
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
protected void removeMipAdjacencies(Routers routers) {
LOG.info("removeMipAdjacencies for router {}", routers.getRouterName());
String externalSubNetId = null;
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
VpnInterfaces vpnInterfaces = SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.CONFIGURATION, vpnInterfacesId);
List<VpnInterface> updatedVpnInterface = new ArrayList<>();
- for (VpnInterface vpnInterface : requireNonNullElse(vpnInterfaces.getVpnInterface(),
- Collections.<VpnInterface>emptyList())) {
+ for (VpnInterface vpnInterface : vpnInterfaces.nonnullVpnInterface()) {
List<Adjacency> updatedAdjacencies = new ArrayList<>();
Adjacencies adjacencies = vpnInterface.augmentation(Adjacencies.class);
if (null != adjacencies) {
- for (Adjacency adjacency : requireNonNullElse(adjacencies.getAdjacency(),
- Collections.<Adjacency>emptyList())) {
+ for (Adjacency adjacency : adjacencies.nonnullAdjacency()) {
if (!adjacency.getSubnetId().getValue().equals(externalSubNetId)) {
updatedAdjacencies.add(adjacency);
}
}
LearntVpnVipToPortDataBuilder learntVpnVipToPortDataBuilder = new LearntVpnVipToPortDataBuilder();
List<LearntVpnVipToPort> learntVpnVipToPortList = new ArrayList<>();
- for (LearntVpnVipToPort learntVpnVipToPort : requireNonNullElse(learntVpnVipToPortData.getLearntVpnVipToPort(),
- Collections.<LearntVpnVipToPort>emptyList())) {
+ for (LearntVpnVipToPort learntVpnVipToPort : learntVpnVipToPortData.nonnullLearntVpnVipToPort()) {
if (!networkId.equals(learntVpnVipToPort.getVpnName())) {
LOG.info("The learned port belongs to Vpn {} hence not removing", learntVpnVipToPort.getVpnName());
learntVpnVipToPortList.add(learntVpnVipToPort);
} else {
String externalSubNetId = null;
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.apache.commons.lang3.tuple.ImmutablePair;
String extGwMacAddress = NatUtil.getExtGwMacAddFromRouterName(confTx, routerName);
addOutboundTblTrackEntry(confTx, dpnId, routerId, extGwMacAddress);
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
removeSnatMissEntryForPrimrySwch(confTx, dpnId, routerId);
removeOutboundTblTrackEntry(confTx, dpnId, routerId);
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
if (!NWUtil.isIpv4Address(externalIp.getIpAddress())) {
// In this class we handle only IPv4 use-cases.
continue;
import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- for (VpnInstanceNames vpnInstance : requireNonNullElse(optionalVpnInterface.get().getVpnInstanceNames(),
- Collections.<VpnInstanceNames>emptyList())) {
+ for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames()) {
if (!vpnName.equals(vpnInstance.getVpnName())) {
continue;
}
LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
if (optionalVpnInterface.isPresent()) {
ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- for (VpnInstanceNames vpnInstance : requireNonNullElse(optionalVpnInterface.get().getVpnInstanceNames(),
- Collections.<VpnInstanceNames>emptyList())) {
+ for (VpnInstanceNames vpnInstance : optionalVpnInterface.get().nonnullVpnInstanceNames()) {
if (!vpnName.equals(vpnInstance.getVpnName())) {
continue;
}
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import java.math.BigInteger;
}
private void removeSnatEntries(Networks original, Uuid networkUuid) {
- for (Uuid routerUuid : requireNonNullElse(original.getRouterIds(), Collections.<Uuid>emptyList())) {
- long routerId = NatUtil.getVpnId(dataBroker, routerUuid.getValue());
- if (routerId == NatConstants.INVALID_ID) {
- LOG.error("removeSnatEntries : Invalid routerId returned for routerName {}", routerUuid.getValue());
- return;
- }
- Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker,routerId);
- if (natMode == NatMode.Controller) {
- coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + routerUuid.getValue(),
- () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> externalRouterListener.handleDisableSnatInternetVpn(routerUuid.getValue(), routerId,
- networkUuid, externalIps, original.getVpnid().getValue(), tx))),
- NatConstants.NAT_DJC_MAX_RETRIES);
+ if (original.getRouterIds() != null) {
+ for (Uuid routerUuid : original.getRouterIds()) {
+ long routerId = NatUtil.getVpnId(dataBroker, routerUuid.getValue());
+ if (routerId == NatConstants.INVALID_ID) {
+ LOG.error("removeSnatEntries : Invalid routerId returned for routerName {}", routerUuid.getValue());
+ return;
+ }
+ Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker,routerId);
+ if (natMode == NatMode.Controller) {
+ coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + routerUuid.getValue(),
+ () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ tx -> externalRouterListener.handleDisableSnatInternetVpn(routerUuid.getValue(), routerId,
+ networkUuid, externalIps, original.getVpnid().getValue(), tx))),
+ NatConstants.NAT_DJC_MAX_RETRIES);
+ }
}
}
}
private void associateExternalNetworkWithVPN(Networks network) {
- List<Uuid> routerIds = requireNonNullElse(network.getRouterIds(), Collections.emptyList());
- for (Uuid routerId : routerIds) {
- //long router = NatUtil.getVpnId(dataBroker, routerId.getValue());
+ if (network.getRouterIds() != null) {
+ List<Uuid> routerIds = network.getRouterIds();
+ for (Uuid routerId : routerIds) {
+ //long router = NatUtil.getVpnId(dataBroker, routerId.getValue());
- InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routerPortsId);
- if (!optRouterPorts.isPresent()) {
- LOG.debug("associateExternalNetworkWithVPN : Could not read Router Ports data object with id: {} "
+ InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
+ Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ routerPortsId);
+ if (!optRouterPorts.isPresent()) {
+ LOG.debug("associateExternalNetworkWithVPN : Could not read Router Ports data object with id: {} "
+ "to handle associate ext nw {}", routerId, network.getId());
- continue;
- }
- RouterPorts routerPorts = optRouterPorts.get();
- for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
- String portName = port.getPortName();
- BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
- if (dpnId.equals(BigInteger.ZERO)) {
- LOG.debug("associateExternalNetworkWithVPN : DPN not found for {}, "
- + "skip handling of ext nw {} association", portName, network.getId());
continue;
}
- for (InternalToExternalPortMap ipMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
- // remove all VPN related entries
- coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + ipMap.key(),
- () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> floatingIpListener.createNATFlowEntries(dpnId, portName, routerId.getValue(),
- network.getId(), ipMap, tx))), NatConstants.NAT_DJC_MAX_RETRIES);
+ RouterPorts routerPorts = optRouterPorts.get();
+ for (Ports port : routerPorts.nonnullPorts()) {
+ String portName = port.getPortName();
+ BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
+ if (dpnId.equals(BigInteger.ZERO)) {
+ LOG.debug("associateExternalNetworkWithVPN : DPN not found for {}, "
+ + "skip handling of ext nw {} association", portName, network.getId());
+ continue;
+ }
+ for (InternalToExternalPortMap ipMap : port.nonnullInternalToExternalPortMap()) {
+ // remove all VPN related entries
+ coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + ipMap.key(),
+ () -> Collections.singletonList(
+ txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ tx -> floatingIpListener.createNATFlowEntries(dpnId, portName, routerId.getValue(),
+ network.getId(), ipMap, tx))), NatConstants.NAT_DJC_MAX_RETRIES);
+ }
}
}
- }
- // SNAT
- for (Uuid routerId : routerIds) {
- LOG.debug("associateExternalNetworkWithVPN() : for routerId {}", routerId);
- Uuid networkId = network.getId();
- if (networkId == null) {
- LOG.error("associateExternalNetworkWithVPN : networkId is null for the router ID {}", routerId);
- return;
- }
- final String vpnName = network.getVpnid().getValue();
- if (vpnName == null) {
- LOG.error("associateExternalNetworkWithVPN : No VPN associated with ext nw {} for router {}",
+ // SNAT
+ for (Uuid routerId : routerIds) {
+ LOG.debug("associateExternalNetworkWithVPN() : for routerId {}", routerId);
+ Uuid networkId = network.getId();
+ if (networkId == null) {
+ LOG.error("associateExternalNetworkWithVPN : networkId is null for the router ID {}", routerId);
+ return;
+ }
+ final String vpnName = network.getVpnid().getValue();
+ if (vpnName == null) {
+ LOG.error("associateExternalNetworkWithVPN : No VPN associated with ext nw {} for router {}",
networkId, routerId);
- return;
- }
+ return;
+ }
- BigInteger dpnId = new BigInteger("0");
- InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitch =
- NatUtil.buildNaptSwitchRouterIdentifier(routerId.getValue());
- Optional<RouterToNaptSwitch> rtrToNapt =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
- if (rtrToNapt.isPresent()) {
- dpnId = rtrToNapt.get().getPrimarySwitchId();
- }
- LOG.debug("associateExternalNetworkWithVPN : got primarySwitch as dpnId{} ", dpnId);
- if (dpnId == null || dpnId.equals(BigInteger.ZERO)) {
- LOG.warn("associateExternalNetworkWithVPN : primary napt Switch not found for router {} on dpn: {}",
- routerId, dpnId);
- return;
- }
- final BigInteger finalDpnId = dpnId;
- coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + routerId.getValue(),
- () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- confTx -> {
- Long routerIdentifier = NatUtil.getVpnId(dataBroker, routerId.getValue());
- InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
- .rev160111.intext.ip.map.IpMapping> idBuilder =
- InstanceIdentifier.builder(IntextIpMap.class)
- .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
- .intext.ip.map.IpMapping.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
- .intext.ip.map.IpMappingKey(routerIdentifier));
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
- .intext.ip.map.IpMapping> id = idBuilder.build();
- Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
- .intext.ip.map.IpMapping> ipMapping = MDSALUtil.read(dataBroker,
- LogicalDatastoreType.OPERATIONAL, id);
- if (ipMapping.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMapping.get().getIpMap(),
- Collections.<IpMap>emptyList())) {
- String externalIp = ipMap.getExternalIp();
- LOG.debug("associateExternalNetworkWithVPN : Calling advToBgpAndInstallFibAndTsFlows "
- + "for dpnId {},vpnName {} and externalIp {}", finalDpnId, vpnName, externalIp);
- if (natMode == NatMode.Controller) {
- externalRouterListener.advToBgpAndInstallFibAndTsFlows(finalDpnId,
+ BigInteger dpnId = new BigInteger("0");
+ InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitch =
+ NatUtil.buildNaptSwitchRouterIdentifier(routerId.getValue());
+ Optional<RouterToNaptSwitch> rtrToNapt =
+ MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
+ if (rtrToNapt.isPresent()) {
+ dpnId = rtrToNapt.get().getPrimarySwitchId();
+ }
+ LOG.debug("associateExternalNetworkWithVPN : got primarySwitch as dpnId{} ", dpnId);
+ if (dpnId == null || dpnId.equals(BigInteger.ZERO)) {
+ LOG.warn("associateExternalNetworkWithVPN : primary napt Switch not found for router {} on dpn: {}",
+ routerId, dpnId);
+ return;
+ }
+ final BigInteger finalDpnId = dpnId;
+ coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + routerId.getValue(),
+ () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ confTx -> {
+ Long routerIdentifier = NatUtil.getVpnId(dataBroker, routerId.getValue());
+ InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
+ .rev160111.intext.ip.map.IpMapping> idBuilder =
+ InstanceIdentifier.builder(IntextIpMap.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
+ .intext.ip.map.IpMapping.class,
+ new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
+ .intext.ip.map.IpMappingKey(routerIdentifier));
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
+ .rev160111.intext.ip.map.IpMapping> id = idBuilder.build();
+ Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
+ .intext.ip.map.IpMapping> ipMapping = MDSALUtil.read(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ if (ipMapping.isPresent()) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
+ String externalIp = ipMap.getExternalIp();
+ LOG.debug(
+ "associateExternalNetworkWithVPN : Calling advToBgpAndInstallFibAndTsFlows "
+ + "for dpnId {},vpnName {} and externalIp {}", finalDpnId, vpnName,
+ externalIp);
+ if (natMode == NatMode.Controller) {
+ externalRouterListener.advToBgpAndInstallFibAndTsFlows(finalDpnId,
NwConstants.INBOUND_NAPT_TABLE, vpnName, routerIdentifier,
routerId.getValue(), externalIp, network.getId(),
null /* external-router */, confTx);
+ }
}
- }
- } else {
- LOG.warn("associateExternalNetworkWithVPN: No ipMapping present fot the routerId {}",
+ } else {
+ LOG.warn("associateExternalNetworkWithVPN: No ipMapping present fot the routerId {}",
routerId);
- }
+ }
- long vpnId = NatUtil.getVpnId(dataBroker, vpnName);
- // Install 47 entry to point to 21
- if (natMode == NatMode.Controller) {
- externalRouterListener.installNaptPfibEntriesForExternalSubnets(routerId.getValue(),
+ long vpnId = NatUtil.getVpnId(dataBroker, vpnName);
+ // Install 47 entry to point to 21
+ if (natMode == NatMode.Controller) {
+ externalRouterListener.installNaptPfibEntriesForExternalSubnets(routerId.getValue(),
finalDpnId, confTx);
- if (vpnId != -1) {
- LOG.debug("associateExternalNetworkWithVPN : Calling externalRouterListener "
+ if (vpnId != -1) {
+ LOG.debug("associateExternalNetworkWithVPN : Calling externalRouterListener "
+ "installNaptPfibEntry for dpnId {} and vpnId {}", finalDpnId, vpnId);
- externalRouterListener.installNaptPfibEntry(finalDpnId, vpnId, confTx);
+ externalRouterListener.installNaptPfibEntry(finalDpnId, vpnId, confTx);
+ }
}
- }
- })), NatConstants.NAT_DJC_MAX_RETRIES);
+ })), NatConstants.NAT_DJC_MAX_RETRIES);
+ }
}
}
private void disassociateExternalNetworkFromVPN(Networks network, String vpnName) {
- for (Uuid routerId : requireNonNullElse(network.getRouterIds(), Collections.<Uuid>emptyList())) {
- InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
- Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- routerPortsId);
- if (!optRouterPorts.isPresent()) {
- LOG.debug("disassociateExternalNetworkFromVPN : Could not read Router Ports data object with id: {} "
- + "to handle disassociate ext nw {}", routerId, network.getId());
- continue;
- }
- RouterPorts routerPorts = optRouterPorts.get();
- for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
- String portName = port.getPortName();
- BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
- if (dpnId.equals(BigInteger.ZERO)) {
- LOG.debug("disassociateExternalNetworkFromVPN : DPN not found for {},"
- + "skip handling of ext nw {} disassociation", portName, network.getId());
+ if (network.getRouterIds() != null) {
+ for (Uuid routerId : network.getRouterIds()) {
+ InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
+ Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ routerPortsId);
+ if (!optRouterPorts.isPresent()) {
+ LOG.debug(
+ "disassociateExternalNetworkFromVPN : Could not read Router Ports data object with id: {} "
+ + "to handle disassociate ext nw {}", routerId, network.getId());
continue;
}
- for (InternalToExternalPortMap intExtPortMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
- coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + intExtPortMap.key(),
- () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- tx -> floatingIpListener.removeNATFlowEntries(dpnId, portName, vpnName, routerId.getValue(),
- intExtPortMap, tx))), NatConstants.NAT_DJC_MAX_RETRIES);
+ RouterPorts routerPorts = optRouterPorts.get();
+ for (Ports port : routerPorts.nonnullPorts()) {
+ String portName = port.getPortName();
+ BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
+ if (dpnId.equals(BigInteger.ZERO)) {
+ LOG.debug("disassociateExternalNetworkFromVPN : DPN not found for {},"
+ + "skip handling of ext nw {} disassociation", portName, network.getId());
+ continue;
+ }
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
+ coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + intExtPortMap.key(),
+ () -> Collections.singletonList(
+ txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ tx -> floatingIpListener.removeNATFlowEntries(dpnId, portName, vpnName,
+ routerId.getValue(),
+ intExtPortMap, tx))), NatConstants.NAT_DJC_MAX_RETRIES);
+ }
}
}
}
import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FutureCallback;
int extIpCounter = externalIps.size();
LOG.debug("subnetRegisterMapping : counter values before looping counter {} and extIpCounter {}",
counter, extIpCounter);
- for (Uuid subnet : requireNonNullElse(routerEntry.getSubnetIds(), Collections.<Uuid>emptyList())) {
+ @Nullable List<Uuid> subnetIds = routerEntry.getSubnetIds();
+ if (subnetIds == null) {
+ return;
+ }
+ for (Uuid subnet : subnetIds) {
LOG.debug("subnetRegisterMapping : Looping internal subnets for subnet {}", subnet);
InstanceIdentifier<Subnetmap> subnetmapId = InstanceIdentifier
.builder(Subnetmaps.class)
}
if (ipPortMapping.isPresent()) {
- for (IntextIpProtocolType intextIpProtocolType : requireNonNullElse(
- ipPortMapping.get().getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
+ for (IntextIpProtocolType intextIpProtocolType :
+ ipPortMapping.get().nonnullIntextIpProtocolType()) {
ProtocolTypes protoType = intextIpProtocolType.getProtocol();
- for (IpPortMap ipPortMap : requireNonNullElse(intextIpProtocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
IpPortExternal ipPortExternal = ipPortMap.getIpPortExternal();
if (ipPortExternal.getIpAddress().equals(externalIp)) {
externalPorts.add(ipPortExternal.getPortNum());
}
if (externalCountersData.isPresent()) {
ExternalIpsCounter externalIpsCounters = externalCountersData.get();
- for (ExternalCounters ext : requireNonNullElse(externalIpsCounters.getExternalCounters(),
- Collections.<ExternalCounters>emptyList())) {
- for (ExternalIpCounter externalIpCount : requireNonNullElse(ext.getExternalIpCounter(),
- Collections.<ExternalIpCounter>emptyList())) {
+ for (ExternalCounters ext : externalIpsCounters.nonnullExternalCounters()) {
+ for (ExternalIpCounter externalIpCount : ext.nonnullExternalIpCounter()) {
if (externalIpCount.getExternalIp().equals(externalIp)) {
if (externalIpCount.getCounter() != 0) {
return true;
return;
}
- for (IntextIpProtocolType intextIpProtocolType : requireNonNullElse(ipPortMapping.getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
- for (IpPortMap ipPortMap : requireNonNullElse(intextIpProtocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
LOG.error("removeNaptFlowsFromActiveSwitchInternetVpn : Unable to retrieve the IpPortMapping");
return;
}
- for (IntextIpProtocolType intextIpProtocolType : requireNonNullElse(ipPortMapping.getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
- for (IpPortMap ipPortMap : requireNonNullElse(intextIpProtocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
routerId);
return;
}
- for (IntextIpProtocolType intextIpProtocolType : requireNonNullElse(ipPortMapping.getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
- for (IpPortMap ipPortMap : requireNonNullElse(intextIpProtocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IntextIpProtocolType intextIpProtocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IpPortMap ipPortMap : intextIpProtocolType.nonnullIpPortMap()) {
String ipPortInternal = ipPortMap.getIpPortInternal();
String[] ipPortParts = ipPortInternal.split(":");
if (ipPortParts.length != 2) {
*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
import com.google.common.base.Optional;
import java.math.BigInteger;
-import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
if (optNaptSwitches.isPresent()) {
NaptSwitches naptSwitches = optNaptSwitches.get();
- for (RouterToNaptSwitch naptSwitch : requireNonNullElse(naptSwitches.getRouterToNaptSwitch(),
- Collections.<RouterToNaptSwitch>emptyList())) {
+ for (RouterToNaptSwitch naptSwitch : naptSwitches.nonnullRouterToNaptSwitch()) {
BigInteger primarySwitch = naptSwitch.getPrimarySwitchId();
//update weight
Integer weight = switchWeights.get(primarySwitch);
*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.ArrayList;
InstanceIdentifier<IpMapping> id = idBuilder.build();
Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (ipMapping.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMapping.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
if (Objects.equals(ipMap.getInternalIp(), internalIp)) {
LOG.debug("checkIpMap : IpMap : {}", ipMap);
externalIp = ipMap.getExternalIp();
// Get all externalIps and decrement their counters before deleting the ipmap
Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
if (ipMapping.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMapping.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap()) {
String externalIp = ipMap.getExternalIp();
LOG.debug("removeIpMappingForRouterID : externalIP is {}", externalIp);
if (externalIp != null) {
LOG.debug("initialiseExternalCounter : Initialise External IPs counter");
//update the new counter value for this externalIp
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps()) {
String[] ipSplit = externalIp.getIpAddress().split("/");
String extIp = ipSplit[0];
String extPrefix = Short.toString(NatConstants.DEFAULT_PREFIX);
*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
import com.google.common.base.Optional;
import java.math.BigInteger;
-
-import java.util.Collections;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
LOG.warn("remove : Interface {} is not a VPN Interface, ignoring.", interfaceName);
return;
}
- for (VpnInstanceNames vpnInterfaceVpnInstance : requireNonNullElse(
- cfgVpnInterface.get().getVpnInstanceNames(), Collections.<VpnInstanceNames>emptyList())) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = NatUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
LOG.warn("update : Interface {} is not a VPN Interface, ignoring.", interfaceName);
return;
}
- for (VpnInstanceNames vpnInterfaceVpnInstance : requireNonNullElse(
- cfgVpnInterface.get().getVpnInstanceNames(), Collections.<VpnInstanceNames>emptyList())) {
+ for (VpnInstanceNames vpnInterfaceVpnInstance : cfgVpnInterface.get().nonnullVpnInstanceNames()) {
String vpnName = vpnInterfaceVpnInstance.getVpnName();
InstanceIdentifier<VpnInterfaceOpDataEntry> idOper = NatUtil
.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnName);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.collect.HashBasedTable;
+ "and port name {}", routerId, portName);
return Collections.emptyList();
}
- return requireNonNullElse(port.get().getInternalToExternalPortMap(), Collections.emptyList());
+ return port.get().nonnullInternalToExternalPortMap();
}
@Nullable
continue;
}
- for (IntIpProtoType protoType : requireNonNullElse(ipPort.getIntIpProtoType(),
- Collections.<IntIpProtoType>emptyList())) {
+ for (IntIpProtoType protoType : ipPort.nonnullIntIpProtoType()) {
ProtocolTypes protocol = protoType.getProtocol();
- for (Integer portnum : requireNonNullElse(protoType.getPorts(), Collections.<Integer>emptyList())) {
+ @Nullable List<Integer> ports = protoType.getPorts();
+ for (Integer portnum : (ports != null ? ports : Collections.<Integer>emptyList())) {
//build and remove the flow in outbound table
try {
removeNatFlow(naptSwitch, NwConstants.OUTBOUND_NAPT_TABLE, routerId, internalIp, portnum);
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.base.Strings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
}
- for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
+ for (Ports port : routerPorts.nonnullPorts()) {
//Get the DPN on which this interface resides
final String interfaceName = port.getPortName();
final BigInteger fipCfgdDpnId = NatUtil.getDpnForInterface(interfaceService, interfaceName);
tepAddedDpnId, fipCfgdDpnId, interfaceName);
continue;
}
- for (InternalToExternalPortMap intExtPortMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
final String internalIp = intExtPortMap.getInternalIp();
final String externalIp = intExtPortMap.getExternalIp();
LOG.debug("hndlTepAddForDnatInEachRtr : DNAT -> Advertising the FIB route to the floating IP {} "
l3Vni = natOverVxlanUtil.getInternetVpnVni(vpnName, routerId).longValue();
}
}
- for (Ports port : requireNonNullElse(routerPorts.getPorts(), Collections.<Ports>emptyList())) {
+ for (Ports port : routerPorts.nonnullPorts()) {
//Get the DPN on which this interface resides
String interfaceName = port.getPortName();
BigInteger fipCfgdDpnId = NatUtil.getDpnForInterface(interfaceService, interfaceName);
tepDeletedDpnId, fipCfgdDpnId, interfaceName);
continue;
}
- for (InternalToExternalPortMap intExtPortMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
String internalIp = intExtPortMap.getInternalIp();
String externalIp = intExtPortMap.getExternalIp();
externalIp = NatUtil.validateAndAddNetworkMask(externalIp);
package org.opendaylight.netvirt.natservice.internal;
import static java.util.Collections.emptyList;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
- for (VpnMap vpnMap : requireNonNullElse(optionalVpnMaps.get().getVpnMap(),
- Collections.<VpnMap>emptyList())) {
+ for (VpnMap vpnMap : optionalVpnMaps.get().nonnullVpnMap()) {
if (routerId.equals(vpnMap.getVpnId().getValue())) {
continue;
}
// Ensure there are no duplicates
Collection<String> externalIps = new HashSet<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMappingOptional.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
externalIps.add(ipMap.getExternalIp());
}
}
LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
Map<String, Long> externalIpsLabel = new HashMap<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMappingOptional.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
externalIpsLabel.put(ipMap.getExternalIp(), ipMap.getLabel());
}
}
if (externalCountersData.isPresent()) {
ExternalCounters externalCounter = externalCountersData.get();
short countOfLstLoadExtIp = 32767;
- for (ExternalIpCounter externalIpCounter : requireNonNullElse(externalCounter.getExternalIpCounter(),
- Collections.<ExternalIpCounter>emptyList())) {
+ for (ExternalIpCounter externalIpCounter : externalCounter.nonnullExternalIpCounter()) {
String curExternalIp = externalIpCounter.getExternalIp();
short countOfCurExtIp = externalIpCounter.getCounter();
if (countOfCurExtIp < countOfLstLoadExtIp) {
LogicalDatastoreType.OPERATIONAL, id);
List<BigInteger> dpns = new ArrayList<>();
if (routerDpnListData.isPresent()) {
- for (DpnVpninterfacesList dpnVpnInterface : requireNonNullElse(
- routerDpnListData.get().getDpnVpninterfacesList(), Collections.<DpnVpninterfacesList>emptyList())) {
+ for (DpnVpninterfacesList dpnVpnInterface : routerDpnListData.get().nonnullDpnVpninterfacesList()) {
dpns.add(dpnVpnInterface.getDpnId());
}
}
if (optionalDpnRoutersList.isPresent()) {
RoutersList routersList = new RoutersListBuilder().withKey(new RoutersListKey(routerName))
.setRouter(routerName).build();
- List<RoutersList> routersListFromDs = requireNonNullElse(optionalDpnRoutersList.get().getRoutersList(),
- emptyList());
+ List<RoutersList> routersListFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
if (!routersListFromDs.contains(routersList)) {
LOG.debug("addToDpnRoutersMap : Router {} not present for the DPN {}"
+ " in the ODL-L3VPN : DPNRouters map", routerName, dpId);
LOG.error("getEgressActionsForTunnels : RPC Call to Get egress actions for Tunnels {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().getAction();
+ actions = rpcResult.getResult().nonnullAction();
}
} else {
RpcResult<GetEgressActionsForInterfaceOutput> rpcResult =
LOG.error("getEgressActionsForInterface : RPC Call to Get egress actions for interface {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().getAction();
+ actions = rpcResult.getResult().nonnullAction();
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
- for (Action action : requireNonNullElse(actions, Collections.<Action>emptyList())) {
+ for (Action action : actions) {
org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action
actionClass = action.getAction();
if (actionClass instanceof OutputActionCase) {
LOG.error("getSubnetIdForFloatingIp : port is null");
return null;
}
- for (FixedIps ip : requireNonNullElse(port.getFixedIps(), Collections.<FixedIps>emptyList())) {
+ for (FixedIps ip : port.nonnullFixedIps()) {
if (Objects.equals(ip.getIpAddress(), targetIP)) {
return ip.getSubnetId();
}
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, externalNwIdentifier);
if (externalNwData.isPresent()) {
- for (Networks externalNw : requireNonNullElse(externalNwData.get().getNetworks(),
- Collections.<Networks>emptyList())) {
+ for (Networks externalNw : externalNwData.get().nonnullNetworks()) {
if (externalNw.getVpnid() != null && externalNw.getVpnid().equals(vpnUuid)) {
- return requireNonNullElse(externalNw.getRouterIds(), emptyList());
+ @Nullable List<Uuid> routerIds = externalNw.getRouterIds();
+ return routerIds != null ? routerIds : emptyList();
}
}
}
@Nullable
protected static Uuid getExternalSubnetForRouterExternalIp(String externalIpAddress, Routers router) {
externalIpAddress = validateAndAddNetworkMask(externalIpAddress);
- for (ExternalIps extIp : requireNonNullElse(router.getExternalIps(), Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps extIp : router.nonnullExternalIps()) {
String extIpString = validateAndAddNetworkMask(extIp.getIpAddress());
if (extIpString.equals(externalIpAddress)) {
return extIp.getSubnetId();
return node.augmentation(OvsdbBridgeAugmentation.class);
}
- // Use Objects.requireNonNullElse instead with JDK9+
- @Nonnull
- public static <T> T requireNonNullElse(@Nullable T obj, @Nonnull T defaultObj) {
- return obj != null ? obj : requireNonNull(defaultObj);
- }
-
public static String getDefaultFibRouteToSNATForSubnetJobKey(String subnetName, BigInteger dpnId) {
return NatConstants.NAT_DJC_PREFIX + subnetName + dpnId;
}
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
import java.math.BigInteger;
-import java.util.Collections;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
return;
}
Uuid networkId = Uuid.getDefaultInstance(externalNetwork);
- for (Ports port : requireNonNullElse(optRouterPorts.get().getPorts(), Collections.<Ports>emptyList())) {
+ for (Ports port : optRouterPorts.get().nonnullPorts()) {
String portName = port.getPortName();
BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(BigInteger.ZERO)) {
continue;
}
- for (InternalToExternalPortMap intExtPortMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
//remove all NAT related entries with routerName
//floatingIpListener.removeNATOnlyFlowEntries(dpnId, portName, routerName, null,
// intExtPortMap.getInternalIp(), externalIp);
return;
}
Uuid networkId = Uuid.getDefaultInstance(externalNetwork);
- for (Ports port : requireNonNullElse(optRouterPorts.get().getPorts(), Collections.<Ports>emptyList())) {
+ for (Ports port : optRouterPorts.get().nonnullPorts()) {
String portName = port.getPortName();
BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
if (dpnId.equals(BigInteger.ZERO)) {
+ "skip handling of router {} association with vpn {}", portName, routerName, vpnName);
continue;
}
- for (InternalToExternalPortMap intExtPortMap : requireNonNullElse(port.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap intExtPortMap : port.nonnullInternalToExternalPortMap()) {
//remove all NAT related entries with routerName
//floatingIpListener.removeNATOnlyFlowEntries(dpnId, portName, routerName, vpnName,
// intExtPortMap.getInternalIp(), externalIp);
package org.opendaylight.netvirt.natservice.internal;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
import com.google.common.base.Optional;
-
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
-
import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
if (original.isUpgradeInProgress() && !updated.isUpgradeInProgress()) {
Optional<NaptSwitches> npatSwitches = NatUtil.getAllPrimaryNaptSwitches(dataBroker);
if (npatSwitches.isPresent()) {
- for (RouterToNaptSwitch routerToNaptSwitch : requireNonNullElse(
- npatSwitches.get().getRouterToNaptSwitch(), Collections.<RouterToNaptSwitch>emptyList())) {
+ for (RouterToNaptSwitch routerToNaptSwitch : npatSwitches.get().nonnullRouterToNaptSwitch()) {
BigInteger primaryNaptDpnId = routerToNaptSwitch.getPrimarySwitchId();
if (!NatUtil.getSwitchStatus(dataBroker, routerToNaptSwitch.getPrimarySwitchId())) {
String routerUuid = routerToNaptSwitch.getRouterName();
return;
}
- for (Routers router : requireNonNullElse(routers.getRouters(), Collections.<Routers>emptyList())) {
+ for (Routers router : routers.nonnullRouters()) {
List<ExternalIps> externalIps = router.getExternalIps();
if (router.isEnableSnat() && externalIps != null && !externalIps.isEmpty()) {
centralizedSwitchScheduler.scheduleCentralizedSwitch(router);
*/
package org.opendaylight.netvirt.natservice.rpcservice;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
outerloop:
for (Uuid subnetUuid: subnetUuidList) {
subNet = nvpnManager.getNeutronSubnet(subnetUuid);
- for (AllocationPools allocationPool : requireNonNullElse(subNet.getAllocationPools(),
- Collections.<AllocationPools>emptyList())) {
+ for (AllocationPools allocationPool : subNet.nonnullAllocationPools()) {
if (NatUtil.isIpInSubnet(ipAddress,
allocationPool.getStart().stringValue(),
allocationPool.getEnd().stringValue())) {
LOG.warn("getNatTranslationsForNetworkAndIpaddress : No DNAT IP Mapping found for IP {}", ipAddress);
} else {
for (Ports fipPort : fipPorts) {
- for (InternalToExternalPortMap fipMap : requireNonNullElse(fipPort.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
if (fipMap.getInternalIp().equals(ipAddress)) {
output = new GetNatTranslationsForNetworkAndIpaddressOutputBuilder()
.setExternalIp(fipMap.getExternalIp())
if (ipPortMapping == null) {
LOG.warn("getNatTranslationsForNetworkAndIpaddress : No SNAT IP Mapping found for IP {}", ipAddress);
} else {
- for (IntextIpProtocolType protocolType : requireNonNullElse(ipPortMapping.getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
- for (IpPortMap ipPortMap : requireNonNullElse(protocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
String[] internalIpPort = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
if (ipAddress.equals(internalIpPort[0])) {
// Capturing SNAT information
List<SnatIpMapping> snatIpMapping = new ArrayList<>();
- for (IntextIpProtocolType protocolType : requireNonNullElse(ipPortMapping.getIntextIpProtocolType(),
- Collections.<IntextIpProtocolType>emptyList())) {
- for (IpPortMap ipPortMap : requireNonNullElse(protocolType.getIpPortMap(),
- Collections.<IpPortMap>emptyList())) {
+ for (IntextIpProtocolType protocolType : ipPortMapping.nonnullIntextIpProtocolType()) {
+ for (IpPortMap ipPortMap : protocolType.nonnullIpPortMap()) {
String[] internalPortMap = ipPortMap.getIpPortInternal().split(NwConstants.MACADDR_SEP);
SnatIpMappingBuilder natIpMappingBuilder = new SnatIpMappingBuilder()
.setInternalIp(internalPortMap[0]).setInternalPort(internalPortMap[1])
LOG.warn("constructNatInformation : No DNAT IP Mapping found for router-uuid {}", routerUuid.getValue());
} else {
for (Ports fipPort : fipPorts) {
- for (InternalToExternalPortMap fipMap : requireNonNullElse(fipPort.getInternalToExternalPortMap(),
- Collections.<InternalToExternalPortMap>emptyList())) {
+ for (InternalToExternalPortMap fipMap : fipPort.nonnullInternalToExternalPortMap()) {
DnatIpMappingBuilder natIpMappingBuilder = new DnatIpMappingBuilder()
.setExternalIp(fipMap.getExternalIp()).setInternalIp(fipMap.getInternalIp());
dnatIpMapping.add(natIpMappingBuilder.build());
Code Review / netvirt.git / commitdiff