*/
package org.opendaylight.netvirt.elan.utils;
-import com.google.common.base.Optional;
+import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+
import com.google.common.collect.MapDifference;
import com.google.common.collect.MapDifference.ValueDifference;
import com.google.common.collect.Maps;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
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.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.genius.infra.TypedReadTransaction;
+import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
+import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.internal.ElanBridgeManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
-import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
+import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.BridgeRefInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.Vteps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.VtepsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.VtepsKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.config.rev150710.ElanConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final String ALL_SUBNETS_GW = "0.0.0.0";
private static final String ALL_SUBNETS = "0.0.0.0/0";
private final ManagedNewTransactionRunner txRunner;
+ private final SingleTransactionDataBroker singleTxBroker;
private final SouthboundUtils southBoundUtils;
private final IElanService elanService;
private final ElanConfig elanConfig;
final IElanService elanService, final ElanConfig elanConfig, final ElanBridgeManager elanBridgeManager,
final ElanInstanceCache elanInstanceCache) {
this.txRunner = new ManagedNewTransactionRunnerImpl(dbx);
+ this.singleTxBroker = new SingleTransactionDataBroker(dbx);
this.elanService = elanService;
this.elanConfig = elanConfig;
this.elanBridgeManager = elanBridgeManager;
this.elanInstanceCache = elanInstanceCache;
- southBoundUtils = new SouthboundUtils(new MdsalUtils(dbx));
+ southBoundUtils = new SouthboundUtils(new ControllerMdsalUtils(dbx));
}
public boolean shouldCreateVtep(List<VpnInterfaces> vpnInterfaces) {
}
if (ElanUtils.isVxlanNetworkOrVxlanSegment(
- elanInstanceCache.get(elanInt.getElanInstanceName()).orNull())) {
+ elanInstanceCache.get(elanInt.getElanInstanceName()).orElse(null))) {
return true;
} else {
- LOG.debug("Non-VXLAN elanInstance: " + elanInt.getElanInstanceName());
+ LOG.debug("Non-VXLAN elanInstance: {}", elanInt.getElanInstanceName());
}
}
return false;
}
- private TransportZone createZone(String subnetIp, String zoneName) {
- List<Subnets> subnets = new ArrayList<>();
- subnets.add(buildSubnets(subnetIp));
- TransportZoneBuilder tzb = new TransportZoneBuilder().setKey(new TransportZoneKey(zoneName))
- .setTunnelType(TunnelTypeVxlan.class).setZoneName(zoneName).setSubnets(subnets);
+ private static TransportZone createZone(String subnetIp, String zoneName) {
+ TransportZoneBuilder tzb = new TransportZoneBuilder().withKey(new TransportZoneKey(zoneName))
+ .setTunnelType(TunnelTypeVxlan.class).setZoneName(zoneName);
return tzb.build();
}
- private void updateTransportZone(TransportZone zone, BigInteger dpnId, @Nonnull WriteTransaction tx) {
+ private static void updateTransportZone(TransportZone zone, Uint64 dpnId,
+ @NonNull TypedWriteTransaction<Configuration> tx) {
InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zone.getZoneName())).build();
- tx.merge(LogicalDatastoreType.CONFIGURATION, path, zone);
+ tx.merge(path, zone);
LOG.info("Transport zone {} updated due to dpn {} handling.", zone.getZoneName(), dpnId);
}
- public void updateTransportZone(String zoneNamePrefix, BigInteger dpnId) {
- ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
- Map<String, String> localIps = getDpnLocalIps(dpnId, tx);
+ public void updateTransportZone(String zoneNamePrefix, Uint64 dpnId) {
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
+ Map<String, String> localIps = getDpnLocalIps(dpnId);
if (!localIps.isEmpty()) {
LOG.debug("Will use local_ips for transport zone update for dpn {} and zone name prefix {}", dpnId,
zoneNamePrefix);
updateTransportZone(zoneName, dpnId, localIp, tx);
}
} else {
- updateTransportZone(zoneNamePrefix, dpnId, getDpnLocalIp(dpnId, tx), tx);
+ updateTransportZone(zoneNamePrefix, dpnId, getDpnLocalIp(dpnId), tx);
}
}), LOG, "Error updating transport zone");
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private void updateTransportZone(String zoneName, BigInteger dpnId, @Nullable String localIp,
- @Nonnull ReadWriteTransaction tx) throws ReadFailedException {
+ private void updateTransportZone(String zoneName, Uint64 dpnId, @Nullable String localIp,
+ @NonNull TypedReadWriteTransaction<Configuration> tx)
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<TransportZone> inst = InstanceIdentifier.create(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zoneName));
// FIXME: Read this through a cache
- TransportZone zone = tx.read(LogicalDatastoreType.CONFIGURATION, inst).checkedGet().orNull();
+ TransportZone zone = tx.read(inst).get().orElse(null);
if (zone == null) {
zone = createZone(ALL_SUBNETS, zoneName);
}
}
- private void deleteTransportZone(TransportZone zone, BigInteger dpnId, @Nonnull WriteTransaction tx) {
+ private static void deleteTransportZone(TransportZone zone, Uint64 dpnId,
+ @NonNull TypedWriteTransaction<Configuration> tx) {
InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zone.getZoneName())).build();
- tx.delete(LogicalDatastoreType.CONFIGURATION, path);
+ tx.delete(path);
LOG.info("Transport zone {} deleted due to dpn {} handling.", zone.getZoneName(), dpnId);
}
- public void deleteTransportZone(String zoneNamePrefix, BigInteger dpnId) {
- ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
- Map<String, String> localIps = getDpnLocalIps(dpnId, tx);
+ public void deleteTransportZone(String zoneNamePrefix, Uint64 dpnId) {
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
+ Map<String, String> localIps = getDpnLocalIps(dpnId);
if (!localIps.isEmpty()) {
LOG.debug("Will use local_ips for transport zone delete for dpn {} and zone name prefix {}", dpnId,
zoneNamePrefix);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private void deleteTransportZone(String zoneName, BigInteger dpnId, @Nonnull ReadWriteTransaction tx)
- throws ReadFailedException {
+ private static void deleteTransportZone(String zoneName, Uint64 dpnId,
+ @NonNull TypedReadWriteTransaction<Configuration> tx) throws ExecutionException, InterruptedException {
InstanceIdentifier<TransportZone> inst = InstanceIdentifier.create(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zoneName));
// FIXME: Read this through a cache
- TransportZone zone = tx.read(LogicalDatastoreType.CONFIGURATION, inst).checkedGet().orNull();
+ TransportZone zone = tx.read(inst).get().orElse(null);
if (zone != null) {
try {
deleteTransportZone(zone, dpnId, tx);
return;
}
- java.util.Optional<BigInteger> dpIdOpt = elanBridgeManager.getDpIdFromManagerNodeId(managerNodeId);
+ java.util.Optional<Uint64> dpIdOpt = elanBridgeManager.getDpIdFromManagerNodeId(managerNodeId);
if (!dpIdOpt.isPresent()) {
LOG.debug("No DPN id found for node {}", managerNodeId);
return;
}
- ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
- BigInteger dpId = dpIdOpt.get();
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
+ Uint64 dpId = dpIdOpt.get();
Optional<DPNTEPsInfo> dpnTepsInfoOpt = getDpnTepsInfo(dpId, tx);
if (!dpnTepsInfoOpt.isPresent()) {
LOG.debug("No DPNTEPsInfo found for DPN id {}", dpId);
Set<String> zonePrefixes = new HashSet<>();
Map<String, List<String>> tepTzMap = tunnelEndPoints.stream().collect(Collectors
- .toMap(tep -> String.valueOf(tep.getIpAddress().getValue()), this::getTepTransportZoneNames));
+ .toMap(tep -> tep.getIpAddress().stringValue(), this::getTepTransportZoneNames));
LOG.trace("Transport zone prefixes {}", tepTzMap);
handleRemovedLocalIps(mapDiff.entriesOnlyOnLeft(), dpId, zonePrefixes, tepTzMap, tx);
}), LOG, "Error handling OVSDB node update");
}
- private void handleAddedLocalIps(Map<String, String> addedEntries, BigInteger dpId, Set<String> zonePrefixes,
- ReadWriteTransaction tx) throws ReadFailedException {
+ private void handleAddedLocalIps(Map<String, String> addedEntries, Uint64 dpId, Set<String> zonePrefixes,
+ TypedReadWriteTransaction<Configuration> tx) throws ExecutionException, InterruptedException {
if (addedEntries == null || addedEntries.isEmpty()) {
LOG.trace("No added local_ips found for DPN {}", dpId);
return;
}
}
- private void handleChangedLocalIps(Map<String, ValueDifference<String>> changedEntries, BigInteger dpId,
- Set<String> zonePrefixes, Map<String, List<String>> tepTzMap, @Nonnull ReadWriteTransaction tx)
- throws ReadFailedException {
+ private void handleChangedLocalIps(Map<String, ValueDifference<String>> changedEntries, Uint64 dpId,
+ Set<String> zonePrefixes, Map<String, List<String>> tepTzMap,
+ @NonNull TypedReadWriteTransaction<Configuration> tx) throws ExecutionException, InterruptedException {
if (changedEntries == null || changedEntries.isEmpty()) {
LOG.trace("No changed local_ips found for DPN {}", dpId);
return;
}
}
- private void handleRemovedLocalIps(Map<String, String> removedEntries, BigInteger dpId, Set<String> zonePrefixes,
- Map<String, List<String>> tepTzMap, @Nonnull WriteTransaction tx) {
+ private static void handleRemovedLocalIps(Map<String, String> removedEntries, Uint64 dpId,
+ Set<String> zonePrefixes, Map<String, List<String>> tepTzMap,
+ @NonNull TypedWriteTransaction<Configuration> tx) {
if (removedEntries == null || removedEntries.isEmpty()) {
LOG.trace("No removed local_ips found on DPN {}", dpId);
return;
}
private List<String> getTepTransportZoneNames(TunnelEndPoints tep) {
- List<TzMembership> tzMembershipList = tep.getTzMembership();
+ List<TzMembership> tzMembershipList = new ArrayList<TzMembership>(tep.nonnullTzMembership().values());
if (tzMembershipList == null) {
- LOG.debug("No TZ membership exist for TEP ip {}", tep.getIpAddress().getValue());
+ LOG.debug("No TZ membership exist for TEP ip {}", tep.getIpAddress().stringValue());
return Collections.emptyList();
}
.collect(Collectors.toList());
}
- private Optional<DPNTEPsInfo> getDpnTepsInfo(BigInteger dpId, ReadTransaction tx) {
+ private static Optional<DPNTEPsInfo> getDpnTepsInfo(Uint64 dpId, TypedReadTransaction<Configuration> tx) {
InstanceIdentifier<DPNTEPsInfo> identifier = InstanceIdentifier.builder(DpnEndpoints.class)
.child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpId)).build();
try {
- return tx.read(LogicalDatastoreType.CONFIGURATION, identifier).checkedGet();
- } catch (ReadFailedException e) {
+ return tx.read(identifier).get();
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read DPNTEPsInfo for DPN id {}", dpId);
- return Optional.absent();
+ return Optional.empty();
}
}
*
* @return Whether a vtep was added or not.
*/
- private boolean addVtep(TransportZone zone, String subnetIp, BigInteger dpnId, @Nullable String localIp) {
- List<Subnets> zoneSubnets = zone.getSubnets();
- if (zoneSubnets == null) {
- return false;
- }
-
- Subnets subnets = getOrAddSubnet(zoneSubnets, subnetIp);
- for (Vteps existingVtep : subnets.getVteps()) {
- if (existingVtep.getDpnId().equals(dpnId)) {
+ private boolean addVtep(TransportZone zone, String subnetIp, Uint64 dpnId, @Nullable String localIp) {
+ for (Vteps existingVtep : new ArrayList<Vteps>(zone.nonnullVteps().values())) {
+ if (Objects.equals(existingVtep.getDpnId(), dpnId)) {
return false;
}
}
if (localIp != null) {
- IpAddress nodeIp = new IpAddress(localIp.toCharArray());
+ //This seems to be a unused code, creating unused objects
+ //Check if any assignment needed here.
+ /*IpAddress nodeIp = IpAddressBuilder.getDefaultInstance(localIp);
VtepsBuilder vtepsBuilder = new VtepsBuilder().setDpnId(dpnId).setIpAddress(nodeIp)
- .setPortname(TUNNEL_PORT).setOptionOfTunnel(elanConfig.isUseOfTunnels());
- subnets.getVteps().add(vtepsBuilder.build());
+ .setOptionOfTunnel(elanConfig.isUseOfTunnels());
+ zone.getVteps().add(vtepsBuilder.build());*/
return true;
}
return false;
}
- private void removeVtep(String zoneName, BigInteger dpId, @Nonnull WriteTransaction tx) {
+ private static void removeVtep(String zoneName, Uint64 dpId, @NonNull TypedWriteTransaction<Configuration> tx) {
InstanceIdentifier<Vteps> path = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zoneName))
- .child(Subnets.class, new SubnetsKey(new IpPrefix(ALL_SUBNETS.toCharArray())))
- .child(Vteps.class, new VtepsKey(dpId, TUNNEL_PORT)).build();
- tx.delete(LogicalDatastoreType.CONFIGURATION, path);
+ .child(Vteps.class, new VtepsKey(dpId)).build();
+ tx.delete(path);
}
- // search for relevant subnets for the given subnetIP, add one if it is
- // necessary
- private Subnets getOrAddSubnet(@Nonnull List<Subnets> subnets, @Nonnull String subnetIp) {
- IpPrefix subnetPrefix = new IpPrefix(subnetIp.toCharArray());
-
- for (Subnets subnet : subnets) {
- if (subnet.getPrefix().equals(subnetPrefix)) {
- return subnet;
- }
- }
-
- Subnets retSubnet = buildSubnets(subnetIp);
- subnets.add(retSubnet);
-
- return retSubnet;
- }
-
- private Subnets buildSubnets(String subnetIp) {
- SubnetsBuilder subnetsBuilder = new SubnetsBuilder().setDeviceVteps(new ArrayList<>())
- .setGatewayIp(new IpAddress(ALL_SUBNETS_GW.toCharArray()))
- .setKey(new SubnetsKey(new IpPrefix(subnetIp.toCharArray()))).setVlanId(0)
- .setVteps(new ArrayList<>());
- return subnetsBuilder.build();
- }
-
- private String getDpnLocalIp(BigInteger dpId, ReadTransaction tx) throws ReadFailedException {
- Optional<Node> node = getPortsNode(dpId, tx);
+ @Nullable
+ private String getDpnLocalIp(Uint64 dpId) throws ReadFailedException {
+ Optional<Node> node = getPortsNode(dpId);
if (node.isPresent()) {
String localIp = southBoundUtils.getOpenvswitchOtherConfig(node.get(), LOCAL_IP);
if (localIp == null) {
LOG.error("missing local_ip key in ovsdb:openvswitch-other-configs in operational"
- + " network-topology for node: " + node.get().getNodeId().getValue());
+ + " network-topology for node: {}", node.get().getNodeId().getValue());
} else {
return localIp;
}
return null;
}
- @Nonnull
- private Map<String, String> getDpnLocalIps(BigInteger dpId, ReadTransaction tx) throws ReadFailedException {
+ @NonNull
+ private Map<String, String> getDpnLocalIps(Uint64 dpId) throws ReadFailedException {
// Example of local IPs from other_config:
// local_ips="10.0.43.159:MPLS,11.11.11.11:DSL,ip:underlay-network"
- return getPortsNode(dpId, tx).toJavaUtil().map(
+ return getPortsNode(dpId).map(
node -> elanBridgeManager.getOpenvswitchOtherConfigMap(node, LOCAL_IPS)).orElse(Collections.emptyMap());
}
@SuppressWarnings("unchecked")
- private Optional<Node> getPortsNode(BigInteger dpnId, ReadTransaction tx) throws ReadFailedException {
+ private Optional<Node> getPortsNode(Uint64 dpnId) throws ReadFailedException {
InstanceIdentifier<BridgeRefEntry> bridgeRefInfoPath = InstanceIdentifier.create(BridgeRefInfo.class)
.child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId));
- // FIXME: Read this through a cache
- Optional<BridgeRefEntry> optionalBridgeRefEntry =
- tx.read(LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath).checkedGet();
- if (!optionalBridgeRefEntry.isPresent()) {
- LOG.error("no bridge ref entry found for dpnId: " + dpnId);
- return Optional.absent();
- }
+ try {
+ // FIXME: Read this through a cache
+ Optional<BridgeRefEntry> optionalBridgeRefEntry =
+ singleTxBroker
+ .syncReadOptional(LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
+ if (!optionalBridgeRefEntry.isPresent()) {
+ LOG.error("no bridge ref entry found for dpnId {}", dpnId);
+ return Optional.empty();
+ }
- InstanceIdentifier<Node> nodeId =
- optionalBridgeRefEntry.get().getBridgeReference().getValue().firstIdentifierOf(Node.class);
+ InstanceIdentifier<Node> nodeId =
+ optionalBridgeRefEntry.get().getBridgeReference().getValue()
+ .firstIdentifierOf(Node.class);
- // FIXME: Read this through a cache
- Optional<Node> optionalNode = tx.read(LogicalDatastoreType.OPERATIONAL, nodeId).checkedGet();
- if (!optionalNode.isPresent()) {
- LOG.error("missing node for dpnId: " + dpnId);
+ // FIXME: Read this through a cache
+ Optional<Node> optionalNode = singleTxBroker
+ .syncReadOptional(LogicalDatastoreType.OPERATIONAL, nodeId);
+ if (!optionalNode.isPresent()) {
+ LOG.error("missing node for dpnId {}", dpnId);
+ }
+ return optionalNode;
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("Exception while getting ports for Node {}", dpnId, e);
}
- return optionalNode;
+ return Optional.empty();
}
- private String getTzNameForUnderlayNetwork(String zoneNamePrefix, String underlayNetworkName) {
+ private static String getTzNameForUnderlayNetwork(String zoneNamePrefix, String underlayNetworkName) {
return zoneNamePrefix + IP_NETWORK_ZONE_NAME_DELIMITER + underlayNetworkName;
}
- private Optional<String> getZonePrefixForUnderlayNetwork(String zoneName, String underlayNetworkName) {
+ private static Optional<String> getZonePrefixForUnderlayNetwork(String zoneName, String underlayNetworkName) {
String[] zoneParts = zoneName.split(IP_NETWORK_ZONE_NAME_DELIMITER + underlayNetworkName);
- return zoneParts.length == 2 ? Optional.of(zoneParts[0]) : Optional.absent();
+ return zoneParts.length == 2 ? Optional.of(zoneParts[0]) : Optional.empty();
}
}
Code Review / netvirt.git / blobdiff