From b72c1f881bed5d0f83c46b792cc08389c22a6c75 Mon Sep 17 00:00:00 2001 From: Stephen Kitt Date: Fri, 23 Jun 2017 11:16:52 +0200 Subject: [PATCH 1/1] Remove NatUtil::read() MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit As a step in the MD-SAL utilities clean-up, remove NatUtil::read(), simply replacing it with SingleTransactionDataBroker::syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional() (which is itself deprecated, but I didn’t want to redo the error-handling in this patch). Change-Id: I6798e460d7fb61653a5e3f754d5c083fe1084c80 Signed-off-by: Stephen Kitt --- .../cli/DisplayNaptSwithcesCli.java | 27 +- .../WeightedCentralizedSwitchScheduler.java | 14 +- .../internal/EvpnDnatFlowProgrammer.java | 15 +- .../internal/ExternalNetworkListener.java | 5 +- .../internal/FloatingIPListener.java | 22 +- .../internal/InterfaceStateEventListener.java | 16 +- .../natservice/internal/NaptManager.java | 21 +- .../natservice/internal/NaptSwitchHA.java | 9 +- .../natservice/internal/NatEvpnUtil.java | 21 +- .../NatInterfaceStateChangeListener.java | 11 +- .../natservice/internal/NatOverVxlanUtil.java | 6 +- .../internal/NatRouterInterfaceListener.java | 4 +- .../NatTunnelInterfaceStateListener.java | 21 +- .../netvirt/natservice/internal/NatUtil.java | 390 +++++++----------- .../internal/RouterDpnChangeListener.java | 9 +- .../internal/RouterPortsListener.java | 8 +- .../internal/SNATDefaultRouteProgrammer.java | 6 +- .../internal/VpnFloatingIpHandler.java | 4 +- 18 files changed, 279 insertions(+), 330 deletions(-) diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java index a3245f0cbd..bc4fdb5cfe 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/cli/DisplayNaptSwithcesCli.java @@ -18,7 +18,6 @@ import org.apache.karaf.shell.console.OsgiCommandSupport; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; -import org.opendaylight.netvirt.natservice.internal.NatUtil; 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; @@ -65,31 +64,22 @@ public class DisplayNaptSwithcesCli extends OsgiCommandSupport { InstanceIdentifier bridgeRefInfoPath = InstanceIdentifier.create(BridgeRefInfo.class) .child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId)); - Optional bridgeRefEntry = NatUtil.read(dataBroker,LogicalDatastoreType.OPERATIONAL, - bridgeRefInfoPath); + Optional bridgeRefEntry = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, bridgeRefInfoPath); if (!bridgeRefEntry.isPresent()) { return Optional.absent(); } InstanceIdentifier nodeId = - ((InstanceIdentifier) bridgeRefEntry.get().getBridgeReference().getValue()) - .firstIdentifierOf(Node.class); + bridgeRefEntry.get().getBridgeReference().getValue().firstIdentifierOf(Node.class); - Optional node = NatUtil.read(dataBroker,LogicalDatastoreType.OPERATIONAL, nodeId); - return node; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, nodeId); } private String getDpnLocalIp(BigInteger dpId) { - Optional node = getPortsNode(dpId); - - if (node.isPresent()) { - String localIp = getOpenvswitchOtherConfig(node.get(), LOCAL_IP); - if (localIp != null) { - return localIp; - } - } - - return null; + return getPortsNode(dpId).transform(node -> getOpenvswitchOtherConfig(node, LOCAL_IP)).orNull(); } private String getOpenvswitchOtherConfig(Node node, String key) { @@ -118,7 +108,8 @@ public class DisplayNaptSwithcesCli extends OsgiCommandSupport { if (bridgeAugmentation != null) { InstanceIdentifier ovsdbNodeIid = (InstanceIdentifier) bridgeAugmentation.getManagedBy().getValue(); - return NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid); } return Optional.absent(); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java index f85fd920c7..57abe10e45 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/ha/WeightedCentralizedSwitchScheduler.java @@ -63,8 +63,9 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche String vpnName = router.getRouterName(); long vpnId = NatUtil.getVpnId(dataBroker, routerName); for (Uuid subnetUuid :router.getSubnetIds()) { - Optional subnetMapEntry = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, - getSubnetMapIdentifier(subnetUuid)); + Optional subnetMapEntry = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional( + dataBroker, LogicalDatastoreType.CONFIGURATION, getSubnetMapIdentifier(subnetUuid)); if (subnetMapEntry.isPresent()) { Uuid routerPortUuid = subnetMapEntry.get().getRouterInterfacePortId(); NatUtil.createOrUpdateVpnToDpnList(dataBroker, vpnId, nextSwitchId, routerPortUuid.getValue(), @@ -98,8 +99,9 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche String vpnName = router.getRouterName(); long vpnId = NatUtil.getVpnId(dataBroker, vpnName); for (Uuid subnetUuid :router.getSubnetIds()) { - Optional subnetMapEntry = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, - getSubnetMapIdentifier(subnetUuid)); + Optional subnetMapEntry = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional( + dataBroker, LogicalDatastoreType.CONFIGURATION, getSubnetMapIdentifier(subnetUuid)); if (subnetMapEntry.isPresent()) { Uuid routerPortUuid = subnetMapEntry.get().getRouterInterfacePortId(); NatUtil.removeOrUpdateVpnToDpnList(dataBroker, vpnId, primarySwitchId, routerPortUuid.getValue(), @@ -147,8 +149,8 @@ public class WeightedCentralizedSwitchScheduler implements CentralizedSwitchSche public static NaptSwitches getNaptSwitches(DataBroker dataBroker) { InstanceIdentifier id = InstanceIdentifier.builder(NaptSwitches.class).build(); - Optional naptSwitches = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); - return naptSwitches.isPresent() ? naptSwitches.get() : null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id).orNull(); } private BigInteger getSwitchWithLowestWeight() { diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java index a624a9f8f5..9b2e092bb4 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/EvpnDnatFlowProgrammer.java @@ -24,6 +24,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.ActionInfo; import org.opendaylight.genius.mdsalutil.MDSALUtil; import org.opendaylight.genius.mdsalutil.MatchInfo; @@ -195,8 +196,9 @@ public class EvpnDnatFlowProgrammer { //Read the FIP vpn-interface details from Configuration l3vpn:vpn-interfaces model and write into Operational DS InstanceIdentifier vpnIfIdentifier = NatUtil.getVpnInterfaceIdentifier(floatingIpInterface); - Optional optionalVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, - vpnIfIdentifier); + Optional optionalVpnInterface = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier); if (optionalVpnInterface.isPresent()) { VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get()); Adjacencies adjs = vpnIfBuilder.getAugmentation(Adjacencies.class); @@ -295,15 +297,14 @@ public class EvpnDnatFlowProgrammer { }); //Read the FIP vpn-interface details from Operational l3vpn:vpn-interfaces model and delete from Operational DS InstanceIdentifier vpnIfIdentifier = NatUtil.getVpnInterfaceIdentifier(floatingIpInterface); - Optional optionalVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, - vpnIfIdentifier); + Optional optionalVpnInterface = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, vpnIfIdentifier); if (optionalVpnInterface.isPresent()) { WriteTransaction writeOperTxn = dataBroker.newWriteOnlyTransaction(); LOG.debug("NAT Service : Remove vpnInterface {} to Operational l3vpn:vpn-interfaces ", floatingIpInterface); writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL, vpnIfIdentifier); - if (writeOperTxn != null) { - writeOperTxn.submit(); - } + writeOperTxn.submit(); } else { LOG.debug("NAT Service : No vpnInterface {} found in Operational l3vpn:vpn-interfaces ", floatingIpInterface); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java index 97a0cf3dbe..d50ee1b1ce 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworkListener.java @@ -20,6 +20,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.FlowEntity; import org.opendaylight.genius.mdsalutil.InstructionInfo; import org.opendaylight.genius.mdsalutil.MDSALUtil; @@ -159,7 +160,9 @@ public class ExternalNetworkListener extends AsyncDataTreeChangeListenerBase id = NatUtil.getVpnInstanceOpDataIdentifier(routerId); - Optional vpnInstOp = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id); + Optional vpnInstOp = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, id); if (vpnInstOp.isPresent()) { List dpnListInVpn = vpnInstOp.get().getVpnToDpnList(); if (dpnListInVpn != null) { diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java index 748db4cdd7..618926380b 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/FloatingIPListener.java @@ -19,6 +19,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.ActionInfo; import org.opendaylight.genius.mdsalutil.FlowEntity; import org.opendaylight.genius.mdsalutil.InstructionInfo; @@ -309,7 +310,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase portIid, LogicalDatastoreType dataStoreType) { - Optional rtrPort = NatUtil.read(dataBroker, dataStoreType, portIid); + Optional rtrPort = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + dataStoreType, portIid); if (!rtrPort.isPresent()) { LOG.error("NAT Service : Unable to read router port entry for {}", portIid); return null; @@ -331,7 +334,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase nwId = InstanceIdentifier.builder(ExternalNetworks.class).child(Networks.class, new NetworksKey(extNwId)).build(); - Optional nw = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, nwId); + Optional nw = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, nwId); if (!nw.isPresent()) { LOG.error("NAT Service : Unable to read external network for {}", extNwId); return NatConstants.INVALID_ID; @@ -598,12 +603,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase intExtPortMapIdentifier = NatUtil.getIntExtPortMapIdentifier(routerId, interfaceName, internalIp); - Optional intExtPortMap = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, - intExtPortMapIdentifier); - if (intExtPortMap.isPresent()) { - return intExtPortMap.get().getLabel(); - } - return NatConstants.INVALID_ID; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, intExtPortMapIdentifier).transform( + InternalToExternalPortMap::getLabel).or(NatConstants.INVALID_ID); } static void updateOperationalDS(DataBroker dataBroker, String routerId, String interfaceName, long label, @@ -611,7 +613,9 @@ public class FloatingIPListener extends AsyncDataTreeChangeListenerBase portsId = NatUtil.getPortsIdentifier(routerId, interfaceName); - Optional optPorts = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, portsId); + Optional optPorts = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, portsId); InternalToExternalPortMap intExtPortMap = new InternalToExternalPortMapBuilder().setKey(new InternalToExternalPortMapKey(internalIp)).setInternalIp(internalIp).setExternalIp(externalIp) .setLabel(label).build(); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java index eb9fa336ce..f7df4eb922 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/InterfaceStateEventListener.java @@ -24,6 +24,7 @@ import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.FlowEntity; import org.opendaylight.genius.mdsalutil.NwConstants; import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager; @@ -283,7 +284,8 @@ public class InterfaceStateEventListener InstanceIdentifier rtrNaptSw = InstanceIdentifier.builder(NaptSwitches.class) .child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build(); Optional routerToNaptSwitchData = - NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, rtrNaptSw); + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, rtrNaptSw); if (routerToNaptSwitchData.isPresent()) { RouterToNaptSwitch routerToNaptSwitchInstance = routerToNaptSwitchData.get(); return routerToNaptSwitchInstance.getPrimarySwitchId(); @@ -330,14 +332,15 @@ public class InterfaceStateEventListener private List getIntExtPortMapListForPortName(String portName, String routerId) { InstanceIdentifier portToIpMapIdentifier = NatUtil.buildPortToIpMapIdentifier(routerId, portName); - Optional port = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, portToIpMapIdentifier); + Optional port = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, portToIpMapIdentifier); if (!port.isPresent()) { LOG.error("NAT Service : Unable to read router port entry for router ID {} and port name {}", routerId, portName); return null; } - List intExtPortMapList = port.get().getInternalToExternalPortMap(); - return intExtPortMapList; + return port.get().getInternalToExternalPortMap(); } private List getFixedIpsForPort(String interfname) { @@ -414,8 +417,9 @@ public class InterfaceStateEventListener + " Interface {}. Fetching from VPN Interface op data store. ", interfaceName, e); InstanceIdentifier id = NatUtil.getVpnInterfaceIdentifier(interfaceName); - Optional optVpnInterface = NatUtil.read(dataBroker, - LogicalDatastoreType.OPERATIONAL, id); + Optional optVpnInterface = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional( + dataBroker, LogicalDatastoreType.OPERATIONAL, id); if (!optVpnInterface.isPresent()) { LOG.debug("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName); return futures; diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java index 30f0eee5d1..23801c022f 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptManager.java @@ -24,6 +24,7 @@ import org.apache.commons.net.util.SubnetUtils; import org.apache.commons.net.util.SubnetUtils.SubnetInfo; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.MDSALUtil; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder; @@ -475,43 +476,35 @@ public class NaptManager { } protected InstanceIdentifier getIpMapIdentifier(long segid, String internal) { - InstanceIdentifier id = InstanceIdentifier.builder(IntextIpMap.class) + return InstanceIdentifier.builder(IntextIpMap.class) .child(IpMapping.class, new IpMappingKey(segid)) .child(IpMap.class, new IpMapKey(internal)).build(); - return id; } protected InstanceIdentifier getExternalIpsIdentifier(long segmentId, String external) { - InstanceIdentifier id = InstanceIdentifier.builder(ExternalIpsCounter.class) + return InstanceIdentifier.builder(ExternalIpsCounter.class) .child(ExternalCounters.class, new ExternalCountersKey(segmentId)) .child(ExternalIpCounter.class, new ExternalIpCounterKey(external)).build(); - return id; } public static List getIpMapList(DataBroker broker, Long routerId) { InstanceIdentifier id = getIpMapList(routerId); - Optional ipMappingListData = NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id); - if (ipMappingListData.isPresent()) { - IpMapping ipMapping = ipMappingListData.get(); - return ipMapping.getIpMap(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, id).transform(IpMapping::getIpMap).orNull(); } protected static InstanceIdentifier getIpMapList(long routerId) { - InstanceIdentifier id = InstanceIdentifier.builder( + return InstanceIdentifier.builder( IntextIpMap.class).child(IpMapping.class, new IpMappingKey(routerId)).build(); - return id; } protected InstanceIdentifier getIpPortMapIdentifier(long segid, String internal, NAPTEntryEvent.Protocol protocol) { ProtocolTypes protocolType = NatUtil.getProtocolType(protocol); - InstanceIdentifier id = InstanceIdentifier.builder(IntextIpPortMap.class) + return InstanceIdentifier.builder(IntextIpPortMap.class) .child(IpPortMapping.class, new IpPortMappingKey(segid)) .child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType)) .child(IpPortMap.class, new IpPortMapKey(internal)).build(); - return id; } private SessionAddress checkIpPortMap(long segmentId, String internalIpPort, diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java index 356a6fdcbd..00d6bd879a 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NaptSwitchHA.java @@ -21,6 +21,7 @@ import javax.inject.Inject; import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.ActionInfo; import org.opendaylight.genius.mdsalutil.BucketInfo; import org.opendaylight.genius.mdsalutil.FlowEntity; @@ -357,7 +358,9 @@ public class NaptSwitchHA { List routerUuidsAsString = new ArrayList<>(); InstanceIdentifier extNetwork = InstanceIdentifier.builder(ExternalNetworks.class) .child(Networks.class, new NetworksKey(extNetworkId)).build(); - Optional extNetworkData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, extNetwork); + Optional extNetworkData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, extNetwork); if (extNetworkData.isPresent()) { List routerUuids = extNetworkData.get().getRouterIds(); if (routerUuids != null) { @@ -663,7 +666,9 @@ public class NaptSwitchHA { LOG.debug("Querying switch with dpnId {} is up/down", nodeId); InstanceIdentifier nodeInstanceId = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(nodeId)).build(); - Optional nodeOptional = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, nodeInstanceId); + Optional nodeOptional = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, nodeInstanceId); if (nodeOptional.isPresent()) { LOG.debug("Switch {} is up", nodeId); return true; diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java index 54d10cfd2a..a793c9c054 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatEvpnUtil.java @@ -8,7 +8,6 @@ package org.opendaylight.netvirt.natservice.internal; -import com.google.common.base.Optional; import java.math.BigInteger; import java.util.ArrayList; import java.util.Collections; @@ -19,6 +18,7 @@ import java.util.concurrent.Future; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.interfacemanager.globals.IfmConstants; import org.opendaylight.genius.mdsalutil.MDSALUtil; import org.opendaylight.genius.mdsalutil.MatchInfo; @@ -128,11 +128,8 @@ public class NatEvpnUtil { private static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) { InstanceIdentifier id = NatUtil.getVpnInstanceOpDataIdentifier(rd); - Optional vpnInstanceOpData = NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id); - if (vpnInstanceOpData.isPresent()) { - return vpnInstanceOpData.get(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, id).orNull(); } private static boolean isL3VpnOverVxLan(Long l3Vni) { @@ -231,12 +228,10 @@ public class NatEvpnUtil { } public static Uuid getFloatingIpInterfaceIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) { - InstanceIdentifier id = NatUtil.buildfloatingIpIdToPortMappingIdentifier(floatingIpId); - Optional optFloatingIpIdToPortMapping = NatUtil.read(broker, LogicalDatastoreType - .CONFIGURATION, id); - if (optFloatingIpIdToPortMapping.isPresent()) { - return optFloatingIpIdToPortMapping.get().getFloatingIpPortId(); - } - return null; + InstanceIdentifier id = + NatUtil.buildfloatingIpIdToPortMappingIdentifier(floatingIpId); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform( + FloatingIpIdToPortMapping::getFloatingIpPortId).orNull(); } } diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java index 7d26a57070..0b504efaad 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatInterfaceStateChangeListener.java @@ -21,6 +21,7 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState; @@ -178,8 +179,9 @@ public class NatInterfaceStateChangeListener LOG.warn("NAT Service : Unable to retrieve DPNID from Interface operational data store for " + "Interface {}. Exception {} ", interfaceName, e); InstanceIdentifier id = NatUtil.getVpnInterfaceIdentifier(interfaceName); - Optional optVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, - id); + Optional optVpnInterface = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional( + dataBroker, LogicalDatastoreType.OPERATIONAL, id); if (!optVpnInterface.isPresent()) { LOG.warn("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName); return futures; @@ -229,8 +231,9 @@ public class NatInterfaceStateChangeListener "NAT Service : Unable to retrieve DPN ID from Interface operational data " + "store for Interface {}. Exception {} ", update.getName(), e); InstanceIdentifier id = NatUtil.getVpnInterfaceIdentifier(interfaceName); - Optional optVpnInterface = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, - id); + Optional optVpnInterface = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional( + dataBroker, LogicalDatastoreType.OPERATIONAL, id); if (!optVpnInterface.isPresent()) { LOG.warn("NAT Service : Interface {} is not a VPN Interface, ignoring.", interfaceName); return futures; diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java index 29fafc40ef..209061be56 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatOverVxlanUtil.java @@ -15,6 +15,7 @@ import java.util.concurrent.Future; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder; @@ -106,8 +107,9 @@ public class NatOverVxlanUtil { lowLimit = Long.parseLong(configureVniRangeSplit[0]); highLimit = Long.parseLong(configureVniRangeSplit[1]); } - Optional existingIdPool = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, - getIdPoolInstance(poolName)); + Optional existingIdPool = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, getIdPoolInstance(poolName)); if (existingIdPool.isPresent()) { IdPool odlVniIdPool = existingIdPool.get(); long currentStartLimit = odlVniIdPool.getAvailableIdsHolder().getStart(); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java index 8feb30ef80..dff189aab7 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatRouterInterfaceListener.java @@ -96,10 +96,10 @@ public class NatRouterInterfaceListener final String interfaceName = interfaceInfo.getInterfaceId(); //Delete the RouterInterfaces maintained in the ODL:L3VPN configuration model - NatUtil.delete(dataBroker, LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)); + WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction(); + writeTxn.delete(LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)); //Delete the NeutronRouterDpnMap from the ODL:L3VPN operational model - WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction(); NatUtil.removeFromNeutronRouterDpnsMap(dataBroker, routerId, interfaceName, interfaceManager, writeTxn); //Delete the DpnRouterMap from the ODL:L3VPN operational model diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java index 8002f41da8..7befb426c8 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatTunnelInterfaceStateListener.java @@ -27,6 +27,7 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager; import org.opendaylight.genius.mdsalutil.BucketInfo; import org.opendaylight.genius.mdsalutil.FlowEntity; @@ -363,8 +364,9 @@ public class NatTunnelInterfaceStateListener + " : {} and DEST IP: {}", fibManager.getTransportTypeStr(tunnelType), srcTepIp, destTepIp); InstanceIdentifier dpnRoutersListId = NatUtil.getDpnRoutersId(srcDpnId); - Optional optionalRouterDpnList = NatUtil.read(dataBroker, LogicalDatastoreType - .OPERATIONAL, dpnRoutersListId); + Optional optionalRouterDpnList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, dpnRoutersListId); if (!optionalRouterDpnList.isPresent()) { LOG.warn("NAT Service : RouterDpnList model is empty for DPN {}. Hence ignoring TEP add event for the ITM " + "TUNNEL TYPE {} b/w SRC IP {} and DST IP {} and TUNNEL NAME {} ", @@ -422,8 +424,9 @@ public class NatTunnelInterfaceStateListener List routersList = null; InstanceIdentifier dpnRoutersListId = NatUtil.getDpnRoutersId(srcDpnId); - Optional optionalRouterDpnList = NatUtil.read(dataBroker, LogicalDatastoreType - .OPERATIONAL, dpnRoutersListId); + Optional optionalRouterDpnList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, dpnRoutersListId); if (optionalRouterDpnList.isPresent()) { routersList = optionalRouterDpnList.get().getRoutersList(); } else { @@ -459,8 +462,9 @@ public class NatTunnelInterfaceStateListener // Check if this is externalRouter else ignore InstanceIdentifier extRoutersId = NatUtil.buildRouterIdentifier(routerName); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType - .CONFIGURATION, extRoutersId); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, extRoutersId); if (!routerData.isPresent()) { LOG.debug("NAT Service : SNAT -> Ignoring TEP add for router {} since its not External Router", routerName); @@ -887,8 +891,9 @@ public class NatTunnelInterfaceStateListener // Check if this is externalRouter else ignore InstanceIdentifier extRoutersId = NatUtil.buildRouterIdentifier(routerName); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType - .CONFIGURATION, extRoutersId); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, extRoutersId); if (!routerData.isPresent()) { LOG.debug("NAT Service : SNAT -> Ignoring TEP del for router {} since its not External Router", routerName); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java index e6e8abf6f8..8a035e777a 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/NatUtil.java @@ -9,8 +9,6 @@ package org.opendaylight.netvirt.natservice.internal; import com.google.common.base.Optional; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import java.math.BigInteger; import java.net.InetAddress; @@ -28,7 +26,6 @@ import java.util.stream.Collectors; import javax.annotation.Nonnull; import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; 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.TransactionCommitFailedException; @@ -206,7 +203,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev14 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.add.group.input.buckets.bucket.action.action.NxActionResubmitRpcAddGroupCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad; -import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; @@ -246,7 +242,9 @@ public class NatUtil { InstanceIdentifier id = getVpnInstanceToVpnIdIdentifier(vpnName); Optional vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id); + .instance.to.vpn.id.VpnInstance> vpnInstance = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id); long vpnId = NatConstants.INVALID_ID; if (vpnInstance.isPresent()) { @@ -310,8 +308,8 @@ public class NatUtil { static String getVpnInstanceFromVpnIdentifier(DataBroker broker, long vpnId) { InstanceIdentifier id = InstanceIdentifier.builder(VpnIdToVpnInstance.class) .child(VpnIds.class, new VpnIdsKey(vpnId)).build(); - Optional vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id); - return vpnInstance.isPresent() ? vpnInstance.get().getVpnInstanceName() : null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(VpnIds::getVpnInstanceName).orNull(); } /* @@ -343,12 +341,9 @@ public class NatUtil { LOG.error("getNetworkIdFromRouterName - empty routerName received"); return null; } - InstanceIdentifier id = buildRouterIdentifier(routerName); - Optional routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (routerData.isPresent()) { - return routerData.get().getNetworkId(); - } - return null; + InstanceIdentifier id = buildRouterIdentifier(routerName); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Routers::getNetworkId).orNull(); } static InstanceIdentifier buildRouterIdentifier(String routerId) { @@ -371,41 +366,34 @@ public class NatUtil { * @return boolean true if enabled, otherwise false */ static boolean isSnatEnabledForRouterId(DataBroker broker, String routerId) { - InstanceIdentifier id = buildRouterIdentifier(routerId); - Optional routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (routerData.isPresent()) { - return routerData.get().isEnableSnat(); - } - return false; + InstanceIdentifier id = buildRouterIdentifier(routerId); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Routers::isEnableSnat).or(false); } public static Uuid getVpnIdfromNetworkId(DataBroker broker, Uuid networkId) { InstanceIdentifier id = buildNetworkIdentifier(networkId); - Optional networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (networkData.isPresent()) { - return networkData.get().getVpnid(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getVpnid).orNull(); } public static ProviderTypes getProviderTypefromNetworkId(DataBroker broker, Uuid networkId) { InstanceIdentifier id = buildNetworkIdentifier(networkId); - Optional networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (networkData.isPresent() && networkData.get() != null) { - return networkData.get().getProviderNetworkType(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getProviderNetworkType).orNull(); } public static List getRouterIdsfromNetworkId(DataBroker broker, Uuid networkId) { InstanceIdentifier id = buildNetworkIdentifier(networkId); - Optional networkData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - return networkData.isPresent() ? networkData.get().getRouterIds() : Collections.emptyList(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Networks::getRouterIds).or(Collections.emptyList()); } static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) { InstanceIdentifier id = NatUtil.buildRouterIdentifier(routerId); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (routerData.isPresent()) { Uuid networkId = routerData.get().getNetworkId(); if (networkId != null) { @@ -416,9 +404,8 @@ public class NatUtil { } private static InstanceIdentifier buildNetworkIdentifier(Uuid networkId) { - InstanceIdentifier network = InstanceIdentifier.builder(ExternalNetworks.class) + return InstanceIdentifier.builder(ExternalNetworks.class) .child(Networks.class, new NetworksKey(networkId)).build(); - return network; } public static BigInteger getPrimaryNaptfromRouterId(DataBroker broker, Long routerId) { @@ -432,13 +419,9 @@ public class NatUtil { LOG.error("getPrimaryNaptfromRouterName - empty routerName received"); return null; } - InstanceIdentifier id = buildNaptSwitchIdentifier(routerName); - Optional routerToNaptSwitchData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (routerToNaptSwitchData.isPresent()) { - RouterToNaptSwitch routerToNaptSwitchInstance = routerToNaptSwitchData.get(); - return routerToNaptSwitchInstance.getPrimarySwitchId(); - } - return null; + InstanceIdentifier id = buildNaptSwitchIdentifier(routerName); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(RouterToNaptSwitch::getPrimarySwitchId).orNull(); } private static InstanceIdentifier buildNaptSwitchIdentifier(String routerId) { @@ -448,27 +431,9 @@ public class NatUtil { } public static String getRouterName(DataBroker broker, Long routerId) { - InstanceIdentifier id = buildRouterIdentifier(routerId); - Optional routerIdsData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (routerIdsData.isPresent()) { - RouterIds routerIdsInstance = routerIdsData.get(); - return routerIdsInstance.getRouterName(); - } - return null; - } - - // TODO Clean up the exception handling - @SuppressWarnings("checkstyle:IllegalCatch") - public static Optional read(DataBroker broker, LogicalDatastoreType datastoreType, - InstanceIdentifier path) { - - ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); - - try { - return tx.read(datastoreType, path).get(); - } catch (Exception e) { - throw new RuntimeException(e); - } + InstanceIdentifier id = buildRouterIdentifier(routerId); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(RouterIds::getRouterName).orNull(); } static InstanceIdentifier getVpnInstanceOpDataIdentifier(String vrfId) { @@ -479,15 +444,11 @@ public class NatUtil { public static long readVpnId(DataBroker broker, String vpnName) { InstanceIdentifier id = getVpnInstanceToVpnIdIdentifier(vpnName); - Optional vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id); - - long vpnId = NatConstants.INVALID_ID; - if (vpnInstance.isPresent()) { - vpnId = vpnInstance.get().getVpnId(); - } - - return vpnId; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform( + org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id + .VpnInstance::getVpnId).or( + NatConstants.INVALID_ID); } public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, BigInteger cookie, String flowId) { @@ -517,7 +478,9 @@ public class NatUtil { InstanceIdentifier tunnelInfoId = InstanceIdentifier.builder(DpnEndpoints.class) .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpnId)).build(); - Optional tunnelInfo = read(broker, LogicalDatastoreType.CONFIGURATION, tunnelInfoId); + Optional tunnelInfo = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, tunnelInfoId); if (tunnelInfo.isPresent()) { List nexthopIpList = tunnelInfo.get().getTunnelEndPoints(); if (nexthopIpList != null && !nexthopIpList.isEmpty()) { @@ -531,42 +494,34 @@ public class NatUtil { InstanceIdentifier id = getVpnInstanceToVpnIdIdentifier(vpnName); - Optional vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id); - - String rd = null; - if (vpnInstance.isPresent()) { - rd = vpnInstance.get().getVrfId(); - } - return rd; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform( + org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id + .VpnInstance::getVrfId).orNull(); } public static IpPortExternal getExternalIpPortMap(DataBroker broker, Long routerId, String internalIpAddress, String internalPort, NAPTEntryEvent.Protocol protocol) { ProtocolTypes protocolType = NatUtil.getProtocolType(protocol); - InstanceIdentifier ipPortMapId = + InstanceIdentifier ipPortMapId = buildIpToPortMapIdentifier(routerId, internalIpAddress, internalPort, protocolType); - Optional ipPortMapData = read(broker, LogicalDatastoreType.CONFIGURATION, ipPortMapId); - if (ipPortMapData.isPresent()) { - IpPortMap ipPortMapInstance = ipPortMapData.get(); - return ipPortMapInstance.getIpPortExternal(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, ipPortMapId).transform(IpPortMap::getIpPortExternal).orNull(); } private static InstanceIdentifier buildIpToPortMapIdentifier(Long routerId, String internalIpAddress, String internalPort, ProtocolTypes protocolType) { - InstanceIdentifier ipPortMapId = InstanceIdentifier.builder(IntextIpPortMap.class) + return InstanceIdentifier.builder(IntextIpPortMap.class) .child(IpPortMapping.class, new IpPortMappingKey(routerId)) .child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType)) .child(IpPortMap.class, new IpPortMapKey(internalIpAddress + ":" + internalPort)).build(); - return ipPortMapId; } static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName) { InstanceIdentifier interfaceId = getVpnInterfaceIdentifier(interfaceName); - return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent(); } static InstanceIdentifier getVpnInterfaceIdentifier(String vpnInterfaceName) { @@ -576,7 +531,8 @@ public class NatUtil { static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) { InstanceIdentifier interfaceId = getVpnInterfaceIdentifier(interfaceName); - return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).orNull(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, interfaceId).orNull(); } public static String getDpnFromNodeConnectorId(NodeConnectorId portId) { @@ -584,7 +540,7 @@ public class NatUtil { * NodeConnectorId is of form 'openflow:dpnid:portnum' */ String[] split = portId.getValue().split(OF_URI_SEPARATOR); - if (split == null || split.length != 3) { + if (split.length != 3) { return null; } return split[1]; @@ -601,8 +557,9 @@ public class NatUtil { public static String getRouterIdfromVpnInstance(DataBroker broker, String vpnName) { InstanceIdentifier vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class) .child(VpnMap.class, new VpnMapKey(new Uuid(vpnName))).build(); - Optional optionalVpnMap = read(broker, LogicalDatastoreType.CONFIGURATION, - vpnMapIdentifier); + Optional optionalVpnMap = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier); if (optionalVpnMap.isPresent()) { Uuid routerId = optionalVpnMap.get().getRouterId(); if (routerId != null) { @@ -614,8 +571,9 @@ public class NatUtil { static Uuid getVpnForRouter(DataBroker broker, String routerId) { InstanceIdentifier vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build(); - Optional optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION, - vpnMapsIdentifier); + Optional optionalVpnMaps = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier); if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) { List allMaps = optionalVpnMaps.get().getVpnMap(); if (routerId != null) { @@ -633,13 +591,9 @@ public class NatUtil { static long getAssociatedVpn(DataBroker broker, String routerName) { InstanceIdentifier routerMappingId = NatUtil.getRouterVpnMappingId(routerName); - Optional optRouterMapping = - NatUtil.read(broker, LogicalDatastoreType.OPERATIONAL, routerMappingId); - if (optRouterMapping.isPresent()) { - Routermapping routerMapping = optRouterMapping.get(); - return routerMapping.getVpnId(); - } - return NatConstants.INVALID_ID; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, routerMappingId).transform(Routermapping::getVpnId).or( + NatConstants.INVALID_ID); } public static String getAssociatedVPN(DataBroker dataBroker, Uuid networkId, Logger log) { @@ -721,14 +675,13 @@ public class NatUtil { return routerInstanceIndentifier; } + // TODO non-null public static List getInternalIpPortListInfo(DataBroker dataBroker, Long routerId, String internalIpAddress, ProtocolTypes protocolType) { - Optional optionalIpProtoType = read(dataBroker, LogicalDatastoreType.CONFIGURATION, - buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)); - if (optionalIpProtoType.isPresent()) { - return optionalIpProtoType.get().getPorts(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, + buildSnatIntIpPortIdentifier(routerId, internalIpAddress, protocolType)).transform( + IntIpProtoType::getPorts).orNull(); } public static InstanceIdentifier buildSnatIntIpPortIdentifier(Long routerId, @@ -792,7 +745,8 @@ public class NatUtil { } public static IpPortMapping getIportMapping(DataBroker broker, long routerId) { - return read(broker, LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, getIportMappingIdentifier(routerId)).orNull(); } public static InstanceIdentifier getIportMappingIdentifier(long routerId) { @@ -810,10 +764,12 @@ public class NatUtil { return idBuilder; } + // TODO Rework to return non-null Collection public static List getExternalIpsForRouter(DataBroker dataBroker, Long routerId) { Optional ipMappingOptional = - read(dataBroker, LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId)); + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId)); List externalIps = new ArrayList<>(); if (ipMappingOptional.isPresent()) { List ipMaps = ipMappingOptional.get().getIpMap(); @@ -835,10 +791,12 @@ public class NatUtil { return Collections.emptyList(); } + // TODO Rework to return non-null Map public static HashMap getExternalIpsLabelForRouter(DataBroker dataBroker, Long routerId) { Optional ipMappingOptional = - read(dataBroker, LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId)); + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, getIpMappingBuilder(routerId)); HashMap externalIpsLabel = new HashMap<>(); if (ipMappingOptional.isPresent()) { List ipMaps = ipMappingOptional.get().getIpMap(); @@ -896,12 +854,8 @@ public class NatUtil { .builder(Subnetmaps.class) .child(Subnetmap.class, new SubnetmapKey(subnetId)) .build(); - Optional removedSubnet = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetmapId); - if (removedSubnet.isPresent()) { - Subnetmap subnetMapEntry = removedSubnet.get(); - return subnetMapEntry.getSubnetIp(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, subnetmapId).transform(Subnetmap::getSubnetIp).orNull(); } @@ -918,7 +872,9 @@ public class NatUtil { public static List getDpnsForRouter(DataBroker dataBroker, String routerUuid) { InstanceIdentifier id = InstanceIdentifier.builder(NeutronRouterDpns.class) .child(RouterDpnList.class, new RouterDpnListKey(routerUuid)).build(); - Optional routerDpnListData = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id); + Optional routerDpnListData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, id); List dpns = new ArrayList<>(); if (routerDpnListData.isPresent()) { List dpnVpninterfacesList = routerDpnListData.get().getDpnVpninterfacesList(); @@ -941,13 +897,8 @@ public class NatUtil { static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces .RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) { - Optional optRouterInterface = - read(broker, LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)); - if (optRouterInterface.isPresent()) { - return optRouterInterface.get(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, NatUtil.getRouterInterfaceId(interfaceName)).orNull(); } static InstanceIdentifier dpnVpnInterfacesListIdentifier = getRouterDpnId(routerName, dpId); - Optional optionalDpnVpninterfacesList = read(broker, LogicalDatastoreType - .OPERATIONAL, dpnVpnInterfacesListIdentifier); + Optional optionalDpnVpninterfacesList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, dpnVpnInterfacesListIdentifier); org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.neutron.router.dpns .router.dpn.list.dpn.vpninterfaces.list.RouterInterfaces routerInterface = new RouterInterfacesBuilder().setKey(new RouterInterfacesKey(interfaceName)) @@ -1030,8 +982,9 @@ public class NatUtil { dpId, routerName, interfaceName); InstanceIdentifier dpnRoutersListIdentifier = getDpnRoutersId(dpId); - Optional optionalDpnRoutersList = read(broker, LogicalDatastoreType.OPERATIONAL, - dpnRoutersListIdentifier); + Optional optionalDpnRoutersList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier); if (optionalDpnRoutersList.isPresent()) { RoutersList routersList = new RoutersListBuilder().setKey(new RoutersListKey(routerName)) @@ -1070,8 +1023,9 @@ public class NatUtil { return; } InstanceIdentifier routerDpnListIdentifier = getRouterDpnId(routerName, dpId); - Optional optionalRouterDpnList = NatUtil.read(broker, LogicalDatastoreType - .OPERATIONAL, routerDpnListIdentifier); + Optional optionalRouterDpnList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier); if (optionalRouterDpnList.isPresent()) { List routerInterfaces = @@ -1101,8 +1055,9 @@ public class NatUtil { } InstanceIdentifier routerDpnListIdentifier = getRouterDpnId(routerName, dpId); - Optional optionalRouterDpnList = NatUtil.read(broker, LogicalDatastoreType - .OPERATIONAL, routerDpnListIdentifier); + Optional optionalRouterDpnList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier); if (optionalRouterDpnList.isPresent()) { LOG.debug("NAT Service : Removing the dpn-vpninterfaces-list from the odl-l3vpn:neutron-router-dpns model " + "for the router {}", routerName); @@ -1123,8 +1078,9 @@ public class NatUtil { return; } InstanceIdentifier routerDpnListIdentifier = getRouterDpnId(routerName, dpId); - Optional optionalRouterDpnList = read(broker, LogicalDatastoreType - .OPERATIONAL, routerDpnListIdentifier); + Optional optionalRouterDpnList = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, routerDpnListIdentifier); if (optionalRouterDpnList.isPresent()) { List routerInterfaces = @@ -1186,8 +1142,9 @@ public class NatUtil { //Get the dpn-routers-list instance for the current DPN. InstanceIdentifier dpnRoutersListIdentifier = getDpnRoutersId(curDpnId); - Optional dpnRoutersListData = read(broker, LogicalDatastoreType.OPERATIONAL, - dpnRoutersListIdentifier); + Optional dpnRoutersListData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, dpnRoutersListIdentifier); if (dpnRoutersListData == null || !dpnRoutersListData.isPresent()) { LOG.debug("NAT Service : dpn-routers-list is not present for DPN {} in the ODL-L3VPN:dpn-routers model", @@ -1197,7 +1154,9 @@ public class NatUtil { //Get the routers-list instance for the router on the current DPN only InstanceIdentifier routersListIdentifier = getRoutersList(curDpnId, routerName); - Optional routersListData = read(broker, LogicalDatastoreType.OPERATIONAL, routersListIdentifier); + Optional routersListData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, routersListIdentifier); if (routersListData == null || !routersListData.isPresent()) { LOG.debug("NAT Service : routers-list is not present for the DPN {} in the ODL-L3VPN:dpn-routers model", @@ -1210,8 +1169,9 @@ public class NatUtil { InstanceIdentifier routerInterfacesId = getRoutersInterfacesIdentifier(routerName); Optional routerInterfacesData = read(broker, LogicalDatastoreType.CONFIGURATION, - routerInterfacesId); + .RouterInterfaces> routerInterfacesData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, routerInterfacesId); if (routerInterfacesData == null || !routerInterfacesData.isPresent()) { LOG.debug("NAT Service : Unable to get the routers list for the DPN {}. Possibly all subnets removed" @@ -1355,11 +1315,13 @@ public class NatUtil { portsIdentifier = InstanceIdentifier.create(Neutron.class) .child(org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports.class); Optional - portsOptional = read(broker, LogicalDatastoreType.CONFIGURATION, portsIdentifier); + portsOptional = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, portsIdentifier); if (!portsOptional.isPresent() || portsOptional.get().getPort() == null) { LOG.trace("No neutron ports found"); - return Collections.EMPTY_LIST; + return Collections.emptyList(); } return portsOptional.get().getPort(); @@ -1399,14 +1361,15 @@ public class NatUtil { public static Subnetmap getSubnetMap(DataBroker broker, Uuid subnetId) { InstanceIdentifier subnetmapId = InstanceIdentifier.builder(Subnetmaps.class) .child(Subnetmap.class, new SubnetmapKey(subnetId)).build(); - return read(broker, LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, subnetmapId).orNull(); } public static List getSubnetIdsFromNetworkId(DataBroker broker, Uuid networkId) { InstanceIdentifier id = InstanceIdentifier.builder(NetworkMaps.class) .child(NetworkMap.class, new NetworkMapKey(networkId)).build(); - Optional optionalNetworkMap = read(broker, LogicalDatastoreType.CONFIGURATION, id); - return optionalNetworkMap.isPresent() ? optionalNetworkMap.get().getSubnetIdList() : null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(NetworkMap::getSubnetIdList).orNull(); } public static String getSubnetGwMac(DataBroker broker, Uuid subnetId, String vpnName) { @@ -1416,7 +1379,9 @@ public class NatUtil { InstanceIdentifier subnetInst = InstanceIdentifier.create(Neutron.class).child(Subnets.class) .child(Subnet.class, new SubnetKey(subnetId)); - Optional subnetOpt = read(broker, LogicalDatastoreType.CONFIGURATION, subnetInst); + Optional subnetOpt = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, subnetInst); if (!subnetOpt.isPresent()) { return null; } @@ -1430,7 +1395,9 @@ public class NatUtil { InstanceIdentifier portIpInst = InstanceIdentifier.builder(NeutronVpnPortipPortData.class) .child(VpnPortipToPort.class, new VpnPortipToPortKey(gatewayIp.getIpv4Address().getValue(), vpnName)) .build(); - Optional portIpToPortOpt = read(broker, LogicalDatastoreType.CONFIGURATION, portIpInst); + Optional portIpToPortOpt = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, portIpInst); if (portIpToPortOpt.isPresent()) { return portIpToPortOpt.get().getMacAddress(); } @@ -1438,7 +1405,9 @@ public class NatUtil { InstanceIdentifier learntIpInst = InstanceIdentifier.builder(LearntVpnVipToPortData.class) .child(LearntVpnVipToPort.class, new LearntVpnVipToPortKey(gatewayIp.getIpv4Address().getValue(), vpnName)) .build(); - Optional learntIpToPortOpt = read(broker, LogicalDatastoreType.OPERATIONAL, learntIpInst); + Optional learntIpToPortOpt = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.OPERATIONAL, learntIpInst); if (learntIpToPortOpt.isPresent()) { return learntIpToPortOpt.get().getMacAddress(); } @@ -1468,23 +1437,17 @@ public class NatUtil { } protected static String getFloatingIpPortMacFromFloatingIpId(DataBroker broker, Uuid floatingIpId) { - InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId); - Optional optFloatingIpIdToPortMapping = read(broker, LogicalDatastoreType - .CONFIGURATION, id); - if (optFloatingIpIdToPortMapping.isPresent()) { - return optFloatingIpIdToPortMapping.get().getFloatingIpPortMacAddress(); - } - return null; + InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform( + FloatingIpIdToPortMapping::getFloatingIpPortMacAddress).orNull(); } protected static Uuid getFloatingIpPortSubnetIdFromFloatingIpId(DataBroker broker, Uuid floatingIpId) { - InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId); - Optional optFloatingIpIdToPortMapping = read(broker, LogicalDatastoreType - .CONFIGURATION, id); - if (optFloatingIpIdToPortMapping.isPresent()) { - return optFloatingIpIdToPortMapping.get().getFloatingIpPortSubnetId(); - } - return null; + InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform( + FloatingIpIdToPortMapping::getFloatingIpPortSubnetId).orNull(); } static InstanceIdentifier buildfloatingIpIdToPortMappingIdentifier(Uuid floatingIpId) { @@ -1492,42 +1455,11 @@ public class NatUtil { FloatingIpIdToPortMappingKey(floatingIpId)).build(); } - static final FutureCallback DEFAULT_CALLBACK = - new FutureCallback() { - @Override - public void onSuccess(Void result) { - LOG.debug("NAT Service : Success in Datastore operation"); - } - - @Override - public void onFailure(Throwable error) { - LOG.error("NAT Service : Error in Datastore operation", error); - } - - ; - }; - - static void delete(DataBroker broker, LogicalDatastoreType datastoreType, - InstanceIdentifier path) { - delete(broker, datastoreType, path, DEFAULT_CALLBACK); - } - - static void delete(DataBroker broker, LogicalDatastoreType datastoreType, - InstanceIdentifier path, FutureCallback callback) { - WriteTransaction tx = broker.newWriteOnlyTransaction(); - tx.delete(datastoreType, path); - Futures.addCallback(tx.submit(), callback); - } - static Interface getInterfaceStateFromOperDS(DataBroker dataBroker, String interfaceName) { InstanceIdentifier ifStateId = buildStateInterfaceId(interfaceName); - Optional ifStateOptional = read(dataBroker, LogicalDatastoreType.OPERATIONAL, ifStateId); - if (ifStateOptional.isPresent()) { - return ifStateOptional.get(); - } - - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, ifStateId).orNull(); } static InstanceIdentifier buildStateInterfaceId(String interfaceName) { @@ -1543,11 +1475,8 @@ public class NatUtil { public static Routers getRoutersFromConfigDS(DataBroker dataBroker, String routerName) { InstanceIdentifier routerIdentifier = NatUtil.buildRouterIdentifier(routerName); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerIdentifier); - if (routerData.isPresent()) { - return routerData.get(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, routerIdentifier).orNull(); } static void createRouterIdsConfigDS(DataBroker dataBroker, String routerName) { @@ -1592,11 +1521,8 @@ public class NatUtil { static String getExtGwMacAddFromRouterId(DataBroker broker, long routerId) { String routerName = getRouterName(broker, routerId); InstanceIdentifier id = buildRouterIdentifier(routerName); - Optional routerData = read(broker, LogicalDatastoreType.CONFIGURATION, id); - if (routerData.isPresent()) { - return routerData.get().getExtGwMacAddress(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, id).transform(Routers::getExtGwMacAddress).orNull(); } static InstanceIdentifier buildNeutronRouterIdentifier(Uuid routerUuid) { @@ -1608,29 +1534,23 @@ public class NatUtil { public static String getNeutronRouterNamebyUuid(DataBroker broker, Uuid routerUuid) { InstanceIdentifier neutronRouterIdentifier = NatUtil.buildNeutronRouterIdentifier(routerUuid); - Optional neutronRouterData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, - neutronRouterIdentifier); - if (neutronRouterData.isPresent()) { - return neutronRouterData.get().getName(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, neutronRouterIdentifier).transform(Router::getName).orNull(); } + // TODO Rework to return non-null public static List getFloatingIpPortsForRouter(DataBroker broker, Uuid routerUuid) { - InstanceIdentifier routerPortsIdentifier = getRouterPortsId(routerUuid.getValue()); - Optional routerPortsData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, - routerPortsIdentifier); - if (routerPortsData.isPresent()) { - return routerPortsData.get().getPorts(); - } - return null; + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, + routerPortsIdentifier).transform(RouterPorts::getPorts).orNull(); } public static List getRouterUuIdsForVpn(DataBroker broker, Uuid vpnUuid) { InstanceIdentifier externalNwIdentifier = InstanceIdentifier.create(ExternalNetworks.class); - Optional externalNwData = NatUtil.read(broker, LogicalDatastoreType.CONFIGURATION, - externalNwIdentifier); + Optional externalNwData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, externalNwIdentifier); if (externalNwData.isPresent()) { for (Networks externalNw : externalNwData.get().getNetworks()) { if (externalNw.getVpnid() != null && externalNw.getVpnid().equals(vpnUuid)) { @@ -1659,8 +1579,7 @@ public class NatUtil { return Collections.emptyList(); } - Set subnetsSet = externalIps.stream().map(externalIp -> externalIp.getSubnetId()) - .collect(Collectors.toSet()); + Set subnetsSet = externalIps.stream().map(ExternalIps::getSubnetId).collect(Collectors.toSet()); return new ArrayList<>(subnetsSet); } @@ -1671,7 +1590,9 @@ public class NatUtil { } InstanceIdentifier id = buildRouterIdentifier(routerName); - Optional routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (routerData.isPresent()) { return NatUtil.getExternalSubnetIdsFromExternalIps(routerData.get().getExternalIps()); } else { @@ -1693,7 +1614,8 @@ public class NatUtil { InstanceIdentifier.builder(ExternalSubnets.class) .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice .rev160111.external.subnets.Subnets.class, new SubnetsKey(subnetId)).build(); - return read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetsIdentifier); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, subnetsIdentifier); } protected static long getExternalSubnetVpnId(DataBroker dataBroker, Uuid subnetId) { @@ -1746,19 +1668,19 @@ public class NatUtil { return Collections.emptyList(); } - return externalIps.stream().map(externalIp -> externalIp.getIpAddress()).collect(Collectors.toList()); + return externalIps.stream().map(ExternalIps::getIpAddress).collect(Collectors.toList()); } // elan-instances config container public static ElanInstance getElanInstanceByName(String elanInstanceName, DataBroker broker) { InstanceIdentifier elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName); - return read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull(); + return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker, + LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull(); } public static InstanceIdentifier getElanInstanceConfigurationDataPath(String elanInstanceName) { return InstanceIdentifier.builder(ElanInstances.class) .child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build(); - } public static long getTunnelIdForNonNaptToNaptFlow(DataBroker dataBroker, IElanService elanManager, @@ -1852,7 +1774,9 @@ public class NatUtil { synchronized (vpnName.intern()) { InstanceIdentifier id = getVpnToDpnListIdentifier(primaryRd, dpnId); - Optional dpnInVpn = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id); + Optional dpnInVpn = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, id); org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance .op.data.entry.vpn.to.dpn.list.VpnInterfaces vpnInterface = new VpnInterfacesBuilder() .setInterfaceName(intfName).build(); @@ -1898,7 +1822,9 @@ public class NatUtil { String rd = getVpnRd(dataBroker, vpnName); synchronized (vpnName.intern()) { InstanceIdentifier id = getVpnToDpnListIdentifier(rd, dpnId); - VpnToDpnList dpnInVpn = read(dataBroker, LogicalDatastoreType.OPERATIONAL, id).orNull(); + VpnToDpnList dpnInVpn = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, id).orNull(); if (dpnInVpn == null) { LOG.error("removeOrUpdateVpnToDpnList: Could not find DpnToVpn map for VPN=[name={} rd={} id={}]" + " and dpnId={}", vpnName, rd, id, dpnId); @@ -1946,7 +1872,9 @@ public class NatUtil { public static String getPrimaryRd(DataBroker dataBroker, String vpnName) { InstanceIdentifier id = getVpnInstanceIdentifier(vpnName); - Optional vpnInstance = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + Optional vpnInstance = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (vpnInstance.isPresent()) { return getPrimaryRd(vpnInstance.get()); } diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java index 62c188a00c..95741ac993 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterDpnChangeListener.java @@ -19,6 +19,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.BucketInfo; import org.opendaylight.genius.mdsalutil.FlowEntity; import org.opendaylight.genius.mdsalutil.GroupEntity; @@ -108,7 +109,9 @@ public class RouterDpnChangeListener BigInteger dpnId = dpnInfo.getDpnId(); //check router is associated to external network InstanceIdentifier id = NatUtil.buildRouterIdentifier(routerId); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (routerData.isPresent()) { Routers router = routerData.get(); Uuid networkId = router.getNetworkId(); @@ -181,7 +184,9 @@ public class RouterDpnChangeListener BigInteger dpnId = dpnInfo.getDpnId(); //check router is associated to external network InstanceIdentifier id = NatUtil.buildRouterIdentifier(routerId); - Optional routerData = NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + Optional routerData = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (routerData.isPresent()) { Routers router = routerData.get(); Uuid networkId = router.getNetworkId(); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java index 0b3dd2cc2c..a69d542ffa 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/RouterPortsListener.java @@ -14,6 +14,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.MDSALUtil; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid; import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.FloatingIpInfo; @@ -61,7 +62,9 @@ public class RouterPortsListener @Override protected void add(final InstanceIdentifier identifier, final RouterPorts routerPorts) { LOG.trace("Add router ports method - key: " + identifier + ", value=" + routerPorts); - Optional optRouterPorts = NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, identifier); + Optional optRouterPorts = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, identifier); if (optRouterPorts.isPresent()) { RouterPorts ports = optRouterPorts.get(); String routerName = ports.getRouterId(); @@ -80,7 +83,8 @@ public class RouterPortsListener if (vpnName != null) { InstanceIdentifier routerMappingId = NatUtil.getRouterVpnMappingId(routerName); Optional optRouterMapping = - NatUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, routerMappingId); + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, routerMappingId); if (!optRouterMapping.isPresent()) { Long vpnId = NatUtil.getVpnId(dataBroker, vpnName.getValue()); LOG.debug("Updating router {} to VPN {} association with Id {}", routerName, vpnName, vpnId); diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java index 683f0c377f..b795a406fc 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/SNATDefaultRouteProgrammer.java @@ -19,6 +19,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.FlowEntity; import org.opendaylight.genius.mdsalutil.InstructionInfo; import org.opendaylight.genius.mdsalutil.MDSALUtil; @@ -174,8 +175,9 @@ public class SNATDefaultRouteProgrammer { String subnetId = subnet.getId().getValue(); InstanceIdentifier networkVpnInstanceIdentifier = NatUtil.getVpnInstanceOpDataIdentifier(networkId); - Optional networkVpnInstanceOp = NatUtil.read(dataBroker, - LogicalDatastoreType.OPERATIONAL, networkVpnInstanceIdentifier); + Optional networkVpnInstanceOp = + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.OPERATIONAL, networkVpnInstanceIdentifier); if (networkVpnInstanceOp.isPresent()) { List dpnListInVpn = networkVpnInstanceOp.get().getVpnToDpnList(); if (dpnListInVpn != null) { diff --git a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java index 3248ec2ac1..962665d234 100644 --- a/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java +++ b/vpnservice/natservice/natservice-impl/src/main/java/org/opendaylight/netvirt/natservice/internal/VpnFloatingIpHandler.java @@ -25,6 +25,7 @@ import javax.inject.Singleton; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker; import org.opendaylight.genius.mdsalutil.ActionInfo; import org.opendaylight.genius.mdsalutil.MDSALUtil; import org.opendaylight.genius.mdsalutil.MatchInfo; @@ -478,7 +479,8 @@ public class VpnFloatingIpHandler implements FloatingIPHandler { InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId); try { Optional optFloatingIpIdToPortMapping = - NatUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id); + SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker, + LogicalDatastoreType.CONFIGURATION, id); if (optFloatingIpIdToPortMapping.isPresent() && optFloatingIpIdToPortMapping.get().isFloatingIpDeleted()) { LOG.debug("Deleting floating IP UUID {} to Floating IP neutron port mapping from Floating " + "IP Port Info Config DS", floatingIpId.getValue()); -- 2.36.6