package org.opendaylight.netvirt.neutronvpn.api.utils;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
return routerIds.stream().map(
routerId -> routerId.getRouterId()).collect(Collectors.toList());
}
-
- // Use Objects.requireNonNullElse instead with JDK9+
- @Nonnull
- public static <T> T requireNonNullElse(@Nullable T obj, @Nonnull T defaultObj) {
- return obj != null ? obj : requireNonNull(defaultObj);
- }
}
package org.opendaylight.netvirt.neutronvpn;
import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.base.Optional;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
routerPortsIdentifierBuilder.build());
if (optionalRouterPorts.isPresent()) {
RouterPorts routerPorts = optionalRouterPorts.get();
- List<Ports> portsList = requireNonNullElse(routerPorts.getPorts(), Collections.emptyList());
+ List<Ports> portsList = routerPorts.nonnullPorts();
List<InternalToExternalPortMap> intExtPortMap = new ArrayList<>();
for (Ports ports : portsList) {
if (Objects.equals(ports.getPortName(), fixedNeutronPortName)) {
- intExtPortMap =
- requireNonNullElse(ports.getInternalToExternalPortMap(), Collections.emptyList());
+ intExtPortMap = ports.nonnullInternalToExternalPortMap();
break;
}
}
package org.opendaylight.netvirt.neutronvpn;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.base.Strings;
Uuid internetVpnId = neutronvpnUtils.getInternetvpnUuidBoundToRouterId(routerId);
List<Subnetmap> subnetMapList = new ArrayList<>();
boolean portIsIpv6 = false;
- for (FixedIps portIP : requireNonNullElse(routerPort.getFixedIps(),
- Collections.<FixedIps>emptyList())) {
+ for (FixedIps portIP : routerPort.nonnullFixedIps()) {
// NOTE: Please donot change the order of calls to updateSubnetNodeWithFixedIP
// and addSubnetToVpn here
if (internetVpnId != null
nvpnManager.createVpnInterface(listVpnIds, routerPort, null);
}
IpVersionChoice ipVersion = IpVersionChoice.UNDEFINED;
- for (FixedIps portIP : requireNonNullElse(routerPort.getFixedIps(),
- Collections.<FixedIps>emptyList())) {
+ for (FixedIps portIP : routerPort.nonnullFixedIps()) {
String ipValue = portIP.getIpAddress().stringValue();
ipVersion = NeutronvpnUtils.getIpVersionFromString(ipValue);
if (ipVersion.isIpVersionChosen(IpVersionChoice.IPV4)) {
elanService.removeKnownL3DmacAddress(routerPort.getMacAddress().getValue(), infNetworkId.getValue());
Uuid vpnId = ObjectUtils.defaultIfNull(neutronvpnUtils.getVpnForRouter(routerId, true),
routerId);
- List<FixedIps> portIps = requireNonNullElse(routerPort.getFixedIps(), Collections.emptyList());
+ List<FixedIps> portIps = routerPort.nonnullFixedIps();
boolean vpnInstanceInternetIpVersionRemoved = false;
Uuid vpnInstanceInternetUuid = null;
for (FixedIps portIP : portIps) {
private void handleNeutronPortCreated(final Port port) {
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
- final List<FixedIps> portIpAddrsList = requireNonNullElse(port.getFixedIps(), Collections.emptyList());
+ final List<FixedIps> portIpAddrsList = port.nonnullFixedIps();
if (NeutronConstants.IS_ODL_DHCP_PORT.test(port)) {
return;
}
private void handleNeutronPortDeleted(final Port port) {
final String portName = port.getUuid().getValue();
final Uuid portId = port.getUuid();
- final List<FixedIps> portIpsList = requireNonNullElse(port.getFixedIps(), Collections.emptyList());
+ final List<FixedIps> portIpsList = port.nonnullFixedIps();
jobCoordinator.enqueueJob("PORT- " + portName,
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, confTx -> {
if (!(NeutronUtils.isPortVnicTypeNormal(port) || isPortTypeSwitchdev(port))) {
import static java.util.Collections.singletonList;
import static org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker.syncReadOptional;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
}
String infName = port.getUuid().getValue();
LOG.trace("neutronVpnManager: create config adjacencies for Port: {}", infName);
- for (FixedIps ip : requireNonNullElse(port.getFixedIps(), Collections.<FixedIps>emptyList())) {
+ for (FixedIps ip : port.nonnullFixedIps()) {
String ipValue = ip.getIpAddress().stringValue();
String ipPrefix = ip.getIpAddress().getIpv4Address() != null ? ipValue + "/32" : ipValue + "/128";
Subnetmap snTemp = neutronvpnUtils.getSubnetmap(ip.getSubnetId());
}
LOG.trace("withdraw adjacencies for Port: {} subnet {}", port.getUuid().getValue(),
sn != null ? sn.getSubnetIp() : "null");
- List<Adjacency> vpnAdjsList =
- requireNonNullElse(optionalVpnInterface.get().augmentation(Adjacencies.class).getAdjacency(),
- Collections.emptyList());
+ List<Adjacency> vpnAdjsList = optionalVpnInterface.get().augmentation(Adjacencies.class).nonnullAdjacency();
List<Adjacency> updatedAdjsList = new ArrayList<>();
boolean isIpFromAnotherSubnet = false;
for (Adjacency adj : vpnAdjsList) {
mipToQuery, infName, vpnId.getValue());
}
}
- for (FixedIps ip : requireNonNullElse(port.getFixedIps(), Collections.<FixedIps>emptyList())) {
+ for (FixedIps ip : port.nonnullFixedIps()) {
String ipValue = ip.getIpAddress().stringValue();
//skip IPv4 address
if (!NeutronvpnUtils.getIpVersionFromString(ipValue).isIpVersionChosen(IpVersionChoice.IPV6)) {
Adjacencies adjacencies = new AdjacenciesBuilder().setAdjacency(adjacencyList).build();
vpnIfBuilder.addAugmentation(Adjacencies.class, adjacencies);
}
- for (FixedIps ip : requireNonNullElse(port.getFixedIps(), Collections.<FixedIps>emptyList())) {
+ for (FixedIps ip : port.nonnullFixedIps()) {
String ipValue = ip.getIpAddress().stringValue();
if (oldVpnId != null) {
neutronvpnUtils.removeVpnPortFixedIpToPort(oldVpnId.getValue(),
SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
vpnsIdentifier);
if (optionalVpns.isPresent() && !optionalVpns.get().getVpnInstance().isEmpty()) {
- for (VpnInstance vpn : requireNonNullElse(optionalVpns.get().getVpnInstance(),
- Collections.<VpnInstance>emptyList())) {
+ for (VpnInstance vpn : optionalVpns.get().nonnullVpnInstance()) {
// eliminating implicitly created (router and VLAN provider external network specific) VPNs
// from getL3VPN output
if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
int failurecount = 0;
int warningcount = 0;
- List<Uuid> vpns = requireNonNullElse(input.getId(), Collections.emptyList());
+ List<Uuid> vpns = input.getId() != null ? input.getId() : Collections.emptyList();
for (Uuid vpn : vpns) {
try {
LOG.debug("L3VPN delete RPC: VpnID {}", vpn.getValue());
List<String> fixedIPList = new ArrayList<>();
Port port = neutronvpnUtils.getNeutronPort(portId);
if (port != null) {
- for (FixedIps ip : requireNonNullElse(port.getFixedIps(), Collections.<FixedIps>emptyList())) {
+ for (FixedIps ip : port.nonnullFixedIps()) {
fixedIPList.add(ip.getIpAddress().stringValue());
}
} else {
Optional<Ports> ports = syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, portidentifier);
if (ports.isPresent() && ports.get().getPort() != null) {
- for (Port port : requireNonNullElse(ports.get().getPort(), Collections.<Port>emptyList())) {
+ for (Port port : ports.get().nonnullPort()) {
List<FixedIps> fixedIPs = port.getFixedIps();
if (fixedIPs != null && !fixedIPs.isEmpty()) {
List<String> ipList = new ArrayList<>();
result.add("------------------------------------------------------------------------------------");
result.add("");
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnInstance vpn :
- requireNonNullElse(rpcResult.getResult().getL3vpnInstances(),
- Collections.<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
- .VpnInstance>emptyList())) {
+ rpcResult.getResult().nonnullL3vpnInstances()) {
String tenantId = vpn.getTenantId() != null ? vpn.getTenantId().getValue()
: "\" " + " \"";
result.add(String.format(" %-37s %-37s %-7s ", vpn.getId().getValue(), tenantId,
*/
package org.opendaylight.netvirt.neutronvpn;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
-
import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
builder.setEnableSnat(update.getExternalGatewayInfo().isEnableSnat());
ArrayList<ExternalIps> externalIps = new ArrayList<>();
- for (ExternalFixedIps fixedIps : requireNonNullElse(update.getExternalGatewayInfo().getExternalFixedIps(),
- Collections.<ExternalFixedIps>emptyList())) {
+ for (ExternalFixedIps fixedIps : update.getExternalGatewayInfo().nonnullExternalFixedIps()) {
addExternalFixedIpToExternalIpsList(externalIps, fixedIps);
}
builder.setExternalIps(externalIps);
package org.opendaylight.netvirt.neutronvpn;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.base.Function;
import com.google.common.base.Optional;
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(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()) {
List<Uuid> netIds = vpnMap.getNetworkIds();
if (netIds != null && netIds.contains(network)) {
return vpnMap.getVpnId();
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(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()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.vpnmap
.RouterIds> routerIdsList = vpnMap.getRouterIds();
if (routerIdsList == null || routerIdsList.isEmpty()) {
Optional<InterVpnLinks> interVpnLinksOpData = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
interVpnLinksIid);
if (interVpnLinksOpData.isPresent()) {
- for (InterVpnLink interVpnLink : requireNonNullElse(interVpnLinksOpData.get().getInterVpnLink(),
- Collections.<InterVpnLink>emptyList())) {
+ for (InterVpnLink interVpnLink : interVpnLinksOpData.get().nonnullInterVpnLink()) {
if (interVpnLink.getFirstEndpoint().getIpAddress().getValue().equals(endpointIp)
|| interVpnLink.getSecondEndpoint().getIpAddress().getValue().equals(endpointIp)) {
return Optional.of(interVpnLink);
MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, routerDpnId);
if (neutronRouterDpnsOpt.isPresent()) {
NeutronRouterDpns neutronRouterDpns = neutronRouterDpnsOpt.get();
- for (RouterDpnList routerDpnList : requireNonNullElse(neutronRouterDpns.getRouterDpnList(),
- Collections.<RouterDpnList>emptyList())) {
+ for (RouterDpnList routerDpnList : neutronRouterDpns.nonnullRouterDpnList()) {
if (routerDpnList.getDpnVpninterfacesList() != null) {
for (DpnVpninterfacesList dpnInterfaceList : routerDpnList.getDpnVpninterfacesList()) {
if (dpnInterfaceList.getDpnId().equals(dpid)) {
Optional<Subnetmaps> allSubnetMaps = read(LogicalDatastoreType.CONFIGURATION, subnetMapsId);
// calculate and store in list IpVersion for each subnetMap, belonging to current VpnInstance
List<IpVersionChoice> snIpVersions = new ArrayList<>();
- for (Subnetmap snMap : requireNonNullElse(allSubnetMaps.get().getSubnetmap(),
- Collections.<Subnetmap>emptyList())) {
+ for (Subnetmap snMap : allSubnetMaps.get().nonnullSubnetmap()) {
if (snMap.getId().equals(sm.getId())) {
continue;
}
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());
}
}
*/
package org.opendaylight.netvirt.neutronvpn.evpn.manager;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
int failurecount = 0;
List<String> existingRDs = neutronvpnUtils.getExistingRDs();
- for (Evpn vpn : requireNonNullElse(input.getEvpn(), Collections.<Evpn>emptyList())) {
+ for (Evpn vpn : input.nonnullEvpn()) {
if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-input",
formatAndLog(LOG::warn, "Creation of EVPN failed for VPN {} due to absence of RD/iRT/eRT input",
List<String> rd = vpnInstance.getIpv4Family().getRouteDistinguisher();
List<String> ertList = new ArrayList<>();
List<String> irtList = new ArrayList<>();
- for (VpnTarget vpnTarget : requireNonNullElse(vpnInstance.getIpv4Family().getVpnTargets().getVpnTarget(),
- Collections.<VpnTarget>emptyList())) {
+ for (VpnTarget vpnTarget : vpnInstance.getIpv4Family().getVpnTargets().nonnullVpnTarget()) {
if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
ertList.add(vpnTarget.getVrfRTValue());
}
public ListenableFuture<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
List<RpcError> errorList = new ArrayList<>();
- for (Uuid vpn : requireNonNullElse(input.getId(), Collections.<Uuid>emptyList())) {
- VpnInstance vpnInstance = VpnHelper.getVpnInstance(dataBroker, vpn.getValue());
- if (vpnInstance != null) {
- neutronvpnManager.removeVpn(vpn);
- } else {
- errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-value",
+ if (input.getId() != null) {
+ for (Uuid vpn : input.getId()) {
+ VpnInstance vpnInstance = VpnHelper.getVpnInstance(dataBroker, vpn.getValue());
+ if (vpnInstance != null) {
+ neutronvpnManager.removeVpn(vpn);
+ } else {
+ errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-value",
formatAndLog(LOG::warn, "EVPN with vpnid: {} does not exist", vpn.getValue())));
+ }
}
}
List<String> errorResponseList = new ArrayList<>();
package org.opendaylight.netvirt.neutronvpn.l2gw;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils.requireNonNullElse;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FutureCallback;
protected void add(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
LOG.info("Adding L2gateway with ID: {}", input.getUuid());
- for (Devices l2Device : requireNonNullElse(input.getDevices(), Collections.<Devices>emptyList())) {
+ for (Devices l2Device : input.nonnullDevices()) {
LOG.trace("Adding L2gateway device: {}", l2Device);
addL2Device(l2Device, input);
}
}), new FutureCallback<Void>() {
@Override
public void onSuccess(Void result) {
- for (Devices l2Device : requireNonNullElse(input.getDevices(), Collections.<Devices>emptyList())) {
+ for (Devices l2Device : input.nonnullDevices()) {
LOG.trace("Removing L2gateway device: {}", l2Device);
removeL2Device(l2Device, input);
}