package org.opendaylight.netvirt.natservice.internal;
import static java.util.Collections.emptyList;
-import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.apache.commons.net.util.SubnetUtils;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.common.util.Arguments;
+import org.opendaylight.genius.datastoreutils.ExpectedDataObjectNotFoundException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
import org.opendaylight.genius.utils.JvmGlobalLocks;
-import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+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.TransactionCommitFailedException;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
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.flow.types.rev131026.instruction.list.InstructionKey;
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.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddresses;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.IpAddressesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalIpsCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCounters;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.ExternalCountersKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.ips.counter.external.counters.ExternalIpCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.snatint.ip.port.map.intip.port.map.IpPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.snatint.ip.port.map.intip.port.map.ip.port.IntIpProtoType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.snatint.ip.port.map.intip.port.map.ip.port.IntIpProtoTypeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnAfConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.InterfacesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
}
try {
- return confTx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ return confTx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVpnId).orElse(NatConstants.INVALID_ID);
} catch (InterruptedException | ExecutionException e) {
try {
routerInterfacesData = SingleTransactionDataBroker.syncReadOptional(broker,
LogicalDatastoreType.CONFIGURATION, vmInterfaceIdentifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Read Failed Exception While read RouterInterface data for router {}", routerName, e);
- routerInterfacesData = Optional.absent();
+ routerInterfacesData = Optional.empty();
}
if (routerInterfacesData.isPresent()) {
return Boolean.TRUE;
InstanceIdentifier<VpnIds> id = InstanceIdentifier.builder(VpnIdToVpnInstance.class)
.child(VpnIds.class, new VpnIdsKey(vpnId)).build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(VpnIds::getVpnInstanceName).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(VpnIds::getVpnInstanceName).orElse(null);
}
/*
}
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::getNetworkId).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::getNetworkId).orElse(null);
}
static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
static boolean isSnatEnabledForRouterId(DataBroker broker, String routerId) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::isEnableSnat).orElse(false);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::isEnableSnat).orElse(false);
}
@Nullable
public static Uuid getVpnIdfromNetworkId(DataBroker broker, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Networks::getVpnid).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Networks::getVpnid).orElse(null);
}
@Nullable
public static Uuid getVpnIdfromNetworkId(TypedReadTransaction<Configuration> tx, Uuid networkId) {
try {
- return tx.read(buildNetworkIdentifier(networkId)).get().toJavaUtil().map(Networks::getVpnid).orElse(null);
+ return tx.read(buildNetworkIdentifier(networkId)).get().map(Networks::getVpnid).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading network VPN id for {}", networkId, e);
return null;
public static ProviderTypes getProviderTypefromNetworkId(DataBroker broker, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Networks::getProviderNetworkType).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Networks::getProviderNetworkType).orElse(null);
}
@Nullable
public static ProviderTypes getProviderTypefromNetworkId(TypedReadTransaction<Configuration> tx, Uuid networkId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
try {
- return tx.read(id).get().toJavaUtil().map(Networks::getProviderNetworkType).orElse(null);
+ return tx.read(id).get().map(Networks::getProviderNetworkType).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving provider type for {}", networkId, e);
return null;
}
InstanceIdentifier<RouterToNaptSwitch> id = buildNaptSwitchIdentifier(routerName);
return (SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(RouterToNaptSwitch::getPrimarySwitchId).orElse(
+ LogicalDatastoreType.CONFIGURATION, id).map(RouterToNaptSwitch::getPrimarySwitchId).orElse(
Uint64.valueOf(0L)));
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVrfId).orElse(null);
}
@Nullable
public static String getVpnRd(TypedReadTransaction<Configuration> tx, String vpnName) {
try {
- return tx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ return tx.read(getVpnInstanceToVpnIdIdentifier(vpnName)).get().map(
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
.VpnInstance::getVrfId).orElse(null);
} catch (InterruptedException | ExecutionException e) {
InstanceIdentifier<IpPortMap> ipPortMapId =
buildIpToPortMapIdentifier(routerId, internalIpAddress, internalPort, protocolType);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, ipPortMapId).toJavaUtil().map(IpPortMap::getIpPortExternal).orElse(
+ LogicalDatastoreType.CONFIGURATION, ipPortMapId).map(IpPortMap::getIpPortExternal).orElse(
null);
}
LOG.error("getRouterIdfromVpnInstance : Router not found for vpn : {}", vpnName);
return null;
}
- List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(optionalVpnMap.get().getRouterIds());
+ List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .vpnmaps.vpnmap.RouterIds>(optionalVpnMap.get().nonnullRouterIds().values()));
if (routerIdsList != null && !routerIdsList.isEmpty()) {
for (Uuid routerUuid : routerIdsList) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerUuid.getValue());
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
- for (VpnMap vpnMap : optionalVpnMaps.get().nonnullVpnMap()) {
+ for (VpnMap vpnMap : optionalVpnMaps.get().nonnullVpnMap().values()) {
if (routerId.equals(vpnMap.getVpnId().getValue())) {
continue;
}
- List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(vpnMap.getRouterIds());
+ List<Uuid> routerIdsList = NeutronUtils.getVpnMapRouterIdsListUuid(
+ new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602
+ .vpnmaps.vpnmap.RouterIds>(vpnMap.nonnullRouterIds().values()));
if (routerIdsList.isEmpty()) {
continue;
}
static Uint32 getAssociatedVpn(DataBroker broker, String routerName) {
InstanceIdentifier<Routermapping> routerMappingId = NatUtil.getRouterVpnMappingId(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.OPERATIONAL, routerMappingId).toJavaUtil().map(Routermapping::getVpnId).orElse(
+ LogicalDatastoreType.OPERATIONAL, routerMappingId).map(Routermapping::getVpnId).orElse(
NatConstants.INVALID_ID);
}
List<Uint16> portList = SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION,
- buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).toJavaUtil().map(
+ buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).map(
IntIpProtoType::getPorts).orElse(emptyList());
if (!portList.isEmpty()) {
String internalIpAddress) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION,
- buildSnatIntIpPortIdentifier(routerId, internalIpAddress)).orNull();
+ buildSnatIntIpPortIdentifier(routerId, internalIpAddress)).orElse(null);
}
public static ProtocolTypes getProtocolType(NAPTEntryEvent.Protocol protocol) {
@Nullable
public static IpPortMapping getIportMapping(DataBroker broker, Uint32 routerId) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull();
+ LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orElse(null);
}
public static InstanceIdentifier<IpPortMapping> getIportMappingIdentifier(Uint32 routerId) {
// Ensure there are no duplicates
Collection<String> externalIps = new HashSet<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap().values()) {
externalIps.add(ipMap.getExternalIp());
}
}
public static List<String> getExternalIpsForRouter(DataBroker dataBroker, String routerName) {
Routers routerData = NatUtil.getRoutersFromConfigDS(dataBroker, routerName);
if (routerData != null) {
- return NatUtil.getIpsListFromExternalIps(routerData.getExternalIps());
+ return NatUtil.getIpsListFromExternalIps(
+ new ArrayList<ExternalIps>(routerData.nonnullExternalIps().values()));
}
return emptyList();
LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId));
Map<String, Uint32> externalIpsLabel = new HashMap<>();
if (ipMappingOptional.isPresent()) {
- for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap()) {
+ for (IpMap ipMap : ipMappingOptional.get().nonnullIpMap().values()) {
externalIpsLabel.put(ipMap.getExternalIp(), ipMap.getLabel());
}
}
InstanceIdentifier<ExternalCounters> id =
InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(segmentId)).build();
- Optional<ExternalCounters> externalCountersData =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<ExternalCounters> externalCountersData;
+ try {
+ externalCountersData = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getLeastLoadedExternalIp: Exception while reading ExternalCounters DS for the segmentId {}",
+ segmentId, e);
+ return leastLoadedExternalIp;
+ }
if (externalCountersData.isPresent()) {
ExternalCounters externalCounter = externalCountersData.get();
short countOfLstLoadExtIp = 32767;
- for (ExternalIpCounter externalIpCounter : externalCounter.nonnullExternalIpCounter()) {
+ for (ExternalIpCounter externalIpCounter : externalCounter.nonnullExternalIpCounter().values()) {
String curExternalIp = externalIpCounter.getExternalIp();
short countOfCurExtIp = externalIpCounter.getCounter().toJava();
if (countOfCurExtIp < countOfLstLoadExtIp) {
.child(Subnetmap.class, new SubnetmapKey(subnetId))
.build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, subnetmapId).toJavaUtil().map(Subnetmap::getSubnetIp).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, subnetmapId).map(Subnetmap::getSubnetIp).orElse(null);
}
public static String[] getExternalIpAndPrefix(String leastLoadedExtIpAddr) {
LogicalDatastoreType.OPERATIONAL, id);
List<Uint64> dpns = new ArrayList<>();
if (routerDpnListData.isPresent()) {
- for (DpnVpninterfacesList dpnVpnInterface : routerDpnListData.get().nonnullDpnVpninterfacesList()) {
+ for (DpnVpninterfacesList dpnVpnInterface
+ : routerDpnListData.get().nonnullDpnVpninterfacesList().values()) {
dpns.add(dpnVpnInterface.getDpnId());
}
}
static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces
.@Nullable RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orNull();
+ LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orElse(null);
}
static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
if (optionalDpnVpninterfacesList.isPresent()) {
LOG.debug("addToNeutronRouterDpnsMap : RouterDpnList already present for the Router {} and DPN {} for the "
+ "Interface {} in the ODL-L3VPN : NeutronRouterDpn map", routerName, dpId, interfaceName);
- operTx.merge(dpnVpnInterfacesListIdentifier
+ operTx.mergeParentStructureMerge(dpnVpnInterfacesListIdentifier
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router
.dpns.router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces.class,
- new RouterInterfacesKey(interfaceName)), routerInterface, CREATE_MISSING_PARENTS);
+ new RouterInterfacesKey(interfaceName)), routerInterface);
} else {
LOG.debug("addToNeutronRouterDpnsMap : Building new RouterDpnList for the Router {} and DPN {} for the "
+ "Interface {} in the ODL-L3VPN : NeutronRouterDpn map", routerName, dpId, interfaceName);
routerInterfaces.add(routerInterface);
dpnVpnList.setRouterInterfaces(routerInterfaces);
routerDpnListBuilder.setDpnVpninterfacesList(Collections.singletonList(dpnVpnList.build()));
- operTx.merge(getRouterId(routerName), routerDpnListBuilder.build(), CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(getRouterId(routerName), routerDpnListBuilder.build());
}
}
if (optionalDpnRoutersList.isPresent()) {
RoutersList routersList = new RoutersListBuilder().withKey(new RoutersListKey(routerName))
.setRouter(routerName).build();
- List<RoutersList> routersListFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
- if (!routersListFromDs.contains(routersList)) {
+ Map<RoutersListKey, RoutersList> keyroutersMapFromDs = optionalDpnRoutersList.get().nonnullRoutersList();
+ if (!keyroutersMapFromDs.values().contains(routersList)) {
LOG.debug("addToDpnRoutersMap : Router {} not present for the DPN {}"
+ " in the ODL-L3VPN : DPNRouters map", routerName, dpId);
- operTx.merge(dpnRoutersListIdentifier
- .child(RoutersList.class, new RoutersListKey(routerName)), routersList, CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(dpnRoutersListIdentifier
+ .child(RoutersList.class, new RoutersListKey(routerName)), routersList);
} else {
LOG.debug("addToDpnRoutersMap : Router {} already mapped to the DPN {} in the ODL-L3VPN : "
+ "DPNRouters map", routerName, dpId);
RoutersListBuilder routersListBuilder = new RoutersListBuilder();
routersListBuilder.setRouter(routerName);
dpnRoutersListBuilder.setRoutersList(Collections.singletonList(routersListBuilder.build()));
- operTx.merge(getDpnRoutersId(dpId), dpnRoutersListBuilder.build(), CREATE_MISSING_PARENTS);
+ operTx.mergeParentStructureMerge(getDpnRoutersId(dpId), dpnRoutersListBuilder.build());
}
}
optionalRouterDpnList = operTx.read(routerDpnListIdentifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the router DPN list for {}", routerDpnListIdentifier, e);
- optionalRouterDpnList = Optional.absent();
+ optionalRouterDpnList = Optional.empty();
}
if (optionalRouterDpnList.isPresent()) {
List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns
.router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces> routerInterfaces =
- new ArrayList<>(optionalRouterDpnList.get().nonnullRouterInterfaces());
+ new ArrayList<>(optionalRouterDpnList.get().nonnullRouterInterfaces().values());
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns.router.dpn
.list.dpn.vpninterfaces.list.RouterInterfaces routerInterface =
new RouterInterfacesBuilder().withKey(new RouterInterfacesKey(vpnInterfaceName))
}
//Get the VM interfaces for the router on the current DPN only.
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces
- .map.router.interfaces.Interfaces> vmInterfaces = routerInterfacesData.get().getInterfaces();
- if (vmInterfaces == null) {
+ Map<InterfacesKey, Interfaces> vmInterfacesMap
+ = routerInterfacesData.get().nonnullInterfaces();
+ if (vmInterfacesMap == null) {
LOG.debug("removeFromDpnRoutersMap : VM interfaces are not present for the router {} in the "
+ "NeutronVPN - router-interfaces-map", routerName);
return;
// If the removed VPN interface is the only interface through which the router is connected to the DPN,
// then remove RouterList.
for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .router.interfaces.Interfaces vmInterface : vmInterfaces) {
+ .router.interfaces.Interfaces vmInterface : vmInterfacesMap.values()) {
String vmInterfaceName = vmInterface.getInterfaceId();
Uint64 vmDpnId = getDpnForInterface(ifaceMgrRpcService, vmInterfaceName);
if (vmDpnId.equals(Uint64.ZERO) || !vmDpnId.equals(curDpnId)) {
LOG.error("getEgressActionsForTunnels : RPC Call to Get egress actions for Tunnels {} "
+ "returned with Errors {}", ifName, rpcResult.getErrors());
} else {
- actions = rpcResult.getResult().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
} 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().nonnullAction();
+ actions = new ArrayList<Action>(rpcResult.getResult().nonnullAction().values());
}
}
List<ActionInfo> listActionInfo = new ArrayList<>();
return emptyList();
}
- return portsOptional.get().getPort();
+ return new ArrayList<Port>(portsOptional.get().nonnullPort().values());
}
@Nullable
for (Port port : ports) {
if (deviceType.equals(port.getDeviceOwner()) && port.getFixedIps() != null) {
- for (FixedIps ip : port.getFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
if (Objects.equals(ip.getIpAddress(), targetIP)) {
return port;
}
LOG.error("getSubnetIdForFloatingIp : port is null");
return null;
}
- for (FixedIps ip : port.nonnullFixedIps()) {
+ for (FixedIps ip : port.nonnullFixedIps().values()) {
if (Objects.equals(ip.getIpAddress(), targetIP)) {
return ip.getSubnetId();
}
InstanceIdentifier<Subnetmap> subnetmapId = InstanceIdentifier.builder(Subnetmaps.class)
.child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull();
+ LogicalDatastoreType.CONFIGURATION, subnetmapId).orElse(null);
}
@NonNull
.child(NetworkMap.class, new NetworkMapKey(networkId)).build();
List<Uuid> subnetIdList = SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(NetworkMap::getSubnetIdList).orElse(
+ LogicalDatastoreType.CONFIGURATION, id).map(NetworkMap::getSubnetIdList).orElse(
emptyList());
if (!subnetIdList.isEmpty()) {
subnetIdList = new ArrayList<>(subnetIdList);
protected static String getFloatingIpPortMacFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orElse(null);
}
protected static String getFloatingIpPortMacFromFloatingIpId(TypedReadTransaction<Configuration> confTx,
Uuid floatingIpId) {
try {
- return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().toJavaUtil().map(
+ return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().map(
FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the floating IP port MAC for {}", floatingIpId, e);
protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) {
InstanceIdentifier<FloatingIpIdToPortMapping> id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(
+ LogicalDatastoreType.CONFIGURATION, id).map(
FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orElse(null);
}
protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(TypedReadTransaction<Configuration> confTx,
Uuid floatingIpId) {
try {
- return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().toJavaUtil().map(
+ return confTx.read(buildfloatingIpIdToPortMappingIdentifier(floatingIpId)).get().map(
FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading the floating IP port subnet for {}", floatingIpId, e);
InstanceIdentifier<Interface> ifStateId =
buildStateInterfaceId(interfaceName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.OPERATIONAL, ifStateId).orNull();
+ LogicalDatastoreType.OPERATIONAL, ifStateId).orElse(null);
}
static InstanceIdentifier<Interface> buildStateInterfaceId(String interfaceName) {
public static Routers getRoutersFromConfigDS(DataBroker dataBroker, String routerName) {
InstanceIdentifier<Routers> routerIdentifier = NatUtil.buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, routerIdentifier).orNull();
+ LogicalDatastoreType.CONFIGURATION, routerIdentifier).orElse(null);
}
@Nullable
public static Routers getRoutersFromConfigDS(TypedReadTransaction<Configuration> confTx, String routerName) {
try {
- return confTx.read(NatUtil.buildRouterIdentifier(routerName)).get().orNull();
+ return confTx.read(NatUtil.buildRouterIdentifier(routerName)).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading router {}", routerName, e);
return null;
static String getExtGwMacAddFromRouterName(DataBroker broker, String routerName) {
InstanceIdentifier<Routers> id = buildRouterIdentifier(routerName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, id).toJavaUtil().map(Routers::getExtGwMacAddress).orElse(null);
+ LogicalDatastoreType.CONFIGURATION, id).map(Routers::getExtGwMacAddress).orElse(null);
}
@Nullable
static String getExtGwMacAddFromRouterName(TypedReadTransaction<Configuration> tx, String routerName) {
try {
- return tx.read(buildRouterIdentifier(routerName)).get().toJavaUtil().map(
+ return tx.read(buildRouterIdentifier(routerName)).get().map(
Routers::getExtGwMacAddress).orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving external gateway MAC address for router {}", routerName, e);
public static String getNeutronRouterNamebyUuid(DataBroker broker, Uuid routerUuid) {
InstanceIdentifier<Router> neutronRouterIdentifier = NatUtil.buildNeutronRouterIdentifier(routerUuid);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).toJavaUtil().map(Router::getName).orElse(
+ LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).map(Router::getName).orElse(
null);
}
@NonNull
public static List<Ports> getFloatingIpPortsForRouter(DataBroker broker, Uuid routerUuid) {
InstanceIdentifier<RouterPorts> routerPortsIdentifier = getRouterPortsId(routerUuid.getValue());
- List<Ports> portsList = SingleTransactionDataBroker
+ List<Ports> portsList = new ArrayList<Ports>(SingleTransactionDataBroker
.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, LogicalDatastoreType.CONFIGURATION,
- routerPortsIdentifier).toJavaUtil().map(RouterPorts::getPorts).orElse(emptyList());
+ routerPortsIdentifier).map(RouterPorts::nonnullPorts).orElse(Collections.emptyMap()).values());
+
if (!portsList.isEmpty()) {
portsList = new ArrayList<>(portsList);
}
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
LogicalDatastoreType.CONFIGURATION, externalNwIdentifier);
if (externalNwData.isPresent()) {
- for (Networks externalNw : externalNwData.get().nonnullNetworks()) {
+ for (Networks externalNw : externalNwData.get().nonnullNetworks().values()) {
if (externalNw.getVpnid() != null && externalNw.getVpnid().equals(vpnUuid)) {
@Nullable List<Uuid> routerIds = externalNw.getRouterIds();
return routerIds != null ? new ArrayList<>(routerIds) : emptyList();
SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, id);
if (routerData.isPresent()) {
- return NatUtil.getExternalSubnetIdsFromExternalIps(routerData.get().getExternalIps());
+ return NatUtil.getExternalSubnetIdsFromExternalIps(
+ new ArrayList<ExternalIps>(routerData.get().nonnullExternalIps().values()));
} else {
LOG.warn("getExternalSubnetIdsForRouter : No external router data for router {}", routerName);
return Collections.emptySet();
.subnets.Subnets> getOptionalExternalSubnets(DataBroker dataBroker, Uuid subnetId) {
if (subnetId == null) {
LOG.warn("getOptionalExternalSubnets : subnetId is null");
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
.subnets.Subnets> getOptionalExternalSubnets(TypedReadTransaction<Configuration> tx, Uuid subnetId) {
if (subnetId == null) {
LOG.warn("getOptionalExternalSubnets : subnetId is null");
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
return tx.read(subnetsIdentifier).get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving external subnets on {}", subnetId, e);
- return Optional.absent();
+ return Optional.empty();
}
}
@Nullable
protected static Uuid getExternalSubnetForRouterExternalIp(String externalIpAddress, Routers router) {
externalIpAddress = validateAndAddNetworkMask(externalIpAddress);
- for (ExternalIps extIp : router.nonnullExternalIps()) {
+ for (ExternalIps extIp : router.nonnullExternalIps().values()) {
String extIpString = validateAndAddNetworkMask(extIp.getIpAddress());
if (extIpString.equals(externalIpAddress)) {
return extIp.getSubnetId();
public static ElanInstance getElanInstanceByName(String elanInstanceName, DataBroker broker) {
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+ LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orElse(null);
}
@Nullable
public static ElanInstance getElanInstanceByName(TypedReadTransaction<Configuration> tx, String elanInstanceName) {
try {
- return tx.read(getElanInstanceConfigurationDataPath(elanInstanceName)).get().orNull();
+ return tx.read(getElanInstanceConfigurationDataPath(elanInstanceName)).get().orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error retrieving ELAN instance by name {}", elanInstanceName, e);
return null;
LOG.debug("makePreDnatToSnatTableEntry : Create Pre-DNAT table {} --> table {} flow on NAPT DpnId {} ",
NwConstants.PDNAT_TABLE, tableId, naptDpnId);
- List<Instruction> preDnatToSnatInstructions = new ArrayList<>();
- preDnatToSnatInstructions.add(new InstructionGotoTable(tableId).buildInstruction(0));
+ Map<InstructionKey, Instruction> preDnatToSnatInstructionsMap = new HashMap<InstructionKey, Instruction>();
+ preDnatToSnatInstructionsMap.put(new InstructionKey(0),
+ new InstructionGotoTable(tableId).buildInstruction(0));
List<MatchInfo> matches = new ArrayList<>();
matches.add(MatchEthernetType.IPV4);
String flowRef = getFlowRefPreDnatToSnat(naptDpnId, NwConstants.PDNAT_TABLE, "PreDNATToSNAT");
Flow preDnatToSnatTableFlowEntity = MDSALUtil.buildFlowNew(NwConstants.PDNAT_TABLE,flowRef,
5, flowRef, 0, 0, NwConstants.COOKIE_DNAT_TABLE,
- matches, preDnatToSnatInstructions);
+ matches, preDnatToSnatInstructionsMap);
mdsalManager.addFlow(confTx, naptDpnId, preDnatToSnatTableFlowEntity);
LOG.debug("makePreDnatToSnatTableEntry : Successfully installed Pre-DNAT flow {} on NAPT DpnId {} ",
String vpnName, String externalIp,
Boolean isMoreThanOneFipCheckOnDpn) {
InstanceIdentifier<VpnToDpnList> id = getVpnToDpnListIdentifier(rd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnToDpnList> dpnInVpn;
+ try {
+ dpnInVpn = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("isFloatingIpPresentForDpn: Exception while reading VpnToDpnList DS for the rd {} dpnId {}",
+ rd, dpnId, e);
+ return false;
+ }
if (dpnInVpn.isPresent()) {
LOG.debug("isFloatingIpPresentForDpn : vpn-to-dpn-list is not empty for vpnName {}, dpn id {}, "
+ "rd {} and floatingIp {}", vpnName, dpnId, rd, externalIp);
try {
- List<IpAddresses> ipAddressList = dpnInVpn.get().getIpAddresses();
- if (ipAddressList != null && !ipAddressList.isEmpty()) {
+ Map<IpAddressesKey, IpAddresses> keyIpAddressesMap = dpnInVpn.get().getIpAddresses();
+ if (keyIpAddressesMap != null && !keyIpAddressesMap.isEmpty()) {
int floatingIpPresentCount = 0;
- for (IpAddresses ipAddress: ipAddressList) {
+ for (IpAddresses ipAddress: keyIpAddressesMap.values()) {
if (!Objects.equals(ipAddress.getIpAddress(), externalIp)
&& IpAddresses.IpAddressSource.FloatingIP.equals(ipAddress.getIpAddressSource())) {
floatingIpPresentCount++;
@Nullable
public static String getPrimaryRd(String vpnName, TypedReadTransaction<Configuration> tx)
throws ExecutionException, InterruptedException {
- return tx.read(getVpnInstanceIdentifier(vpnName)).get().toJavaUtil().map(NatUtil::getPrimaryRd).orElse(null);
+ return tx.read(getVpnInstanceIdentifier(vpnName)).get().map(NatUtil::getPrimaryRd).orElse(null);
}
@Nullable
@NonNull
public static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
- VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
- return vpnConfig.getRouteDistinguisher() != null ? new ArrayList<>(
- vpnConfig.getRouteDistinguisher()) : new ArrayList<>();
+ return vpnInstance.getRouteDistinguisher() != null ? new ArrayList<>(
+ vpnInstance.getRouteDistinguisher()) : new ArrayList<>();
}
public static String validateAndAddNetworkMask(String ipAddress) {
public static boolean checkForRoutersWithSameExtNetAndNaptSwitch(DataBroker broker, Uuid networkId,
String routerName, Uint64 dpnId) {
InstanceIdentifier<Networks> id = buildNetworkIdentifier(networkId);
- Optional<Networks> networkData = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
+ Optional<Networks> networkData = null;
+ try {
+ networkData = SingleTransactionDataBroker.syncReadOptional(broker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkForRoutersWithSameExtNetAndNaptSwitch: Exception while reading Networks DS for the "
+ + "network {} router {} dpnId {}", networkId.getValue(), routerName, dpnId, e);
+ return false;
+ }
if (networkData != null && networkData.isPresent()) {
List<Uuid> routerUuidList = networkData.get().getRouterIds();
if (routerUuidList != null && !routerUuidList.isEmpty()) {
public static boolean checkForRoutersWithSameExtSubnetAndNaptSwitch(DataBroker broker, Uuid externalSubnetId,
String routerName, Uint64 dpnId) {
- List<Uuid> routerUuidList = getOptionalExternalSubnets(broker, externalSubnetId).toJavaUtil()
- .map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external
+ List<Uuid> routerUuidList = getOptionalExternalSubnets(broker, externalSubnetId)
+ .map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external
.subnets.Subnets::getRouterIds).orElse(emptyList());
if (!routerUuidList.isEmpty()) {
for (Uuid routerUuid : routerUuidList) {
public static void installRouterGwFlows(ManagedNewTransactionRunner txRunner, IVpnManager vpnManager,
Routers router, Uint64 primarySwitchId, int addOrRemove) {
- ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
- List<ExternalIps> externalIps = router.getExternalIps();
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
+ Map<ExternalIpsKey, ExternalIps> keyExternalIpsMap = router.getExternalIps();
List<String> externalIpsSting = new ArrayList<>();
- if (externalIps == null || externalIps.isEmpty()) {
+ if (keyExternalIpsMap == null || keyExternalIpsMap.isEmpty()) {
LOG.error("installRouterGwFlows: setupRouterGwFlows no externalIP present");
return;
}
- for (ExternalIps externalIp : externalIps) {
+ for (ExternalIps externalIp : keyExternalIpsMap.values()) {
externalIpsSting.add(externalIp.getIpAddress());
}
- Uuid subnetVpnName = externalIps.get(0).getSubnetId();
+ Uuid subnetVpnName = keyExternalIpsMap.get(0).getSubnetId();
if (addOrRemove == NwConstants.ADD_FLOW) {
vpnManager.addRouterGwMacFlow(router.getRouterName(), router.getExtGwMacAddress(), primarySwitchId,
router.getNetworkId(), subnetVpnName.getValue(), tx);
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId, dpnInterface);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read elanDpnInterface with error {}", e.getMessage());
} catch (TransactionCommitFailedException e) {
LOG.warn("Failed to add elanDpnInterface with error {}", e.getMessage());
.withKey(new DpnInterfacesKey(dpnId)).build();
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId, dpnInterface);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to read elanDpnInterface with error {}", e.getMessage());
} catch (TransactionCommitFailedException e) {
LOG.warn("Failed to remove elanDpnInterface with error {}", e.getMessage());
return SingleTransactionDataBroker.syncRead(dataBroker,
LogicalDatastoreType.OPERATIONAL, getLearntVpnVipToPortDataId());
}
- catch (ReadFailedException e) {
+ catch (ExpectedDataObjectNotFoundException e) {
LOG.warn("Failed to read LearntVpnVipToPortData with error {}", e.getMessage());
return null;
}
LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath);
if (!bridgeRefEntry.isPresent()) {
LOG.info("getBridgeRefInfo : bridgeRefEntry is not present for {}", dpnId);
- return Optional.absent();
+ return Optional.empty();
}
InstanceIdentifier<Node> nodeId =
@Nullable
public static String getProviderMappings(Uint64 dpId, DataBroker dataBroker) {
- return getBridgeRefInfo(dpId, dataBroker).toJavaUtil().map(node -> getOpenvswitchOtherConfigs(node,
+ return getBridgeRefInfo(dpId, dataBroker).map(node -> getOpenvswitchOtherConfigs(node,
PROVIDER_MAPPINGS, dataBroker)).orElse(null);
}
}
if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
- for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
+ for (OpenvswitchOtherConfigs openvswitchOtherConfigs
+ : ovsdbNode.nonnullOpenvswitchOtherConfigs().values()) {
if (Objects.equals(openvswitchOtherConfigs.getOtherConfigKey(), key)) {
return openvswitchOtherConfigs.getOtherConfigValue();
}
return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
}
- return Optional.absent();
+ return Optional.empty();
}
if (optionalExternalSubnets.isPresent()) {
return optionalExternalSubnets.get();
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read the subnets from the datastore.");
}
return null;
try {
portsOptional = SingleTransactionDataBroker
.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, portsIdentifier);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Read Failed Exception While Reading Neutron Port for {}", ifaceName, e);
- portsOptional = Optional.absent();
+ portsOptional = Optional.empty();
}
if (!portsOptional.isPresent()) {
LOG.error("getNeutronPort : No neutron ports found for interface {}", ifaceName);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
.vpn.instance.to.vpn.id.VpnInstance> id = getVpnInstanceToVpnIdIdentifier(vpnName);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
- .vpn.instance.to.vpn.id.VpnInstance> vpnInstance = Optional.absent();
+ .vpn.instance.to.vpn.id.VpnInstance> vpnInstance = Optional.empty();
try {
vpnInstance = SingleTransactionDataBroker.syncReadOptional(broker, LogicalDatastoreType.CONFIGURATION, id);
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read VpnInstance {}", vpnInstance, e);
}
if (vpnInstance.isPresent()) {
Code Review / netvirt.git / blobdiff