*/
package org.opendaylight.netvirt.natservice.internal;
-import static org.opendaylight.netvirt.natservice.internal.NatUtil.requireNonNullElse;
-
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.locks.ReentrantLock;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.inject.Singleton;
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.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.utils.JvmGlobalLocks;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalIpsCounter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpPortMap;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @param external subnet prefix or ip address
*/
- public void registerMapping(long segmentId, IPAddress internal, IPAddress external) {
+ public void registerMapping(Uint32 segmentId, IPAddress internal, IPAddress external) {
LOG.debug("registerMapping : called with segmentid {}, internalIp {}, prefix {}, externalIp {} "
+ "and prefix {} ", segmentId, internal.getIpAddress(),
internal.getPrefixLength(), external.getIpAddress(), external.getPrefixLength());
internalIp, externalIp);
}
- public void updateCounter(long segmentId, String externalIp, boolean isAdd) {
+ public void updateCounter(Uint32 segmentId, String externalIp, boolean isAdd) {
short counter = 0;
InstanceIdentifier<ExternalIpCounter> id = InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(segmentId))
.child(ExternalIpCounter.class, new ExternalIpCounterKey(externalIp)).build();
- Optional<ExternalIpCounter> externalIpCounter =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<ExternalIpCounter> externalIpCounter = Optional.empty();
+ try {
+ externalIpCounter = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("updateCounter: Exception while reading ExternalIpCounter DS for the segmentId {} externalIp {} ",
+ segmentId, externalIp, e);
+ }
if (externalIpCounter.isPresent()) {
- counter = externalIpCounter.get().getCounter();
+ counter = externalIpCounter.get().getCounter().toJava();
if (isAdd) {
counter++;
LOG.debug("updateCounter : externalIp and counter after increment are {} and {}", externalIp, counter);
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
@Nullable
- public SessionAddress getExternalAddressMapping(long segmentId, SessionAddress sourceAddress,
+ public SessionAddress getExternalAddressMapping(Uint32 segmentId, SessionAddress sourceAddress,
NAPTEntryEvent.Protocol protocol) {
LOG.debug("getExternalAddressMapping : called with segmentId {}, internalIp {} and port {}",
segmentId, sourceAddress.getIpAddress(), sourceAddress.getPortNumber());
createNaptPortPool(extIp);
LOG.debug("getExternalAddressMapping : Created Pool for next Ext IP {}", extIp);
}
- AllocateIdInput getIdInput = new AllocateIdInputBuilder()
- .setPoolName(extIp).setIdKey(internalIpPort)
- .build();
- try {
- Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
- RpcResult<AllocateIdOutput> rpcResult;
- if (result != null && result.get().isSuccessful()) {
- LOG.debug("getExternalAddressMapping : Got id from idManager");
- rpcResult = result.get();
- } else {
- LOG.error("getExternalAddressMapping : getExternalAddressMapping, idManager could not "
- + "allocate id retry if subnet");
- if (!extSubnetFlag) {
- LOG.error("getExternalAddressMapping : getExternalAddressMapping returning null "
- + "for single IP case, may be ports exhausted");
- return null;
- }
- LOG.debug("getExternalAddressMapping : Could be ports exhausted case, "
- + "try with another externalIP if possible");
- nextExtIpFlag = true;
- continue;
- }
- int extPort = rpcResult.getResult().getIdValue().intValue();
- // Write to ip-port-map before returning
- IpPortExternalBuilder ipExt = new IpPortExternalBuilder();
- IpPortExternal ipPortExt = ipExt.setIpAddress(extIp).setPortNum(extPort).build();
- IpPortMap ipm = new IpPortMapBuilder().withKey(new IpPortMapKey(internalIpPort))
- .setIpPortInternal(internalIpPort).setIpPortExternal(ipPortExt).build();
- LOG.debug("getExternalAddressMapping : writing into ip-port-map with "
- + "externalIP {} and port {}",
- ipPortExt.getIpAddress(), ipPortExt.getPortNum());
- try {
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
- getIpPortMapIdentifier(segmentId, internalIpPort, protocol), ipm);
- } catch (UncheckedExecutionException uee) {
- LOG.error("getExternalAddressMapping : Failed to write into ip-port-map with exception",
- uee);
+ Uint32 extPort = NatUtil.getUniqueId(idManager, extIp, internalIpPort);
+ if (extPort == NatConstants.INVALID_ID) {
+ LOG.error("getExternalAddressMapping : getExternalAddressMapping, idManager could not "
+ + "allocate id retry if subnet");
+ if (!extSubnetFlag) {
+ LOG.error("getExternalAddressMapping : getExternalAddressMapping returning null "
+ + "for single IP case, may be ports exhausted");
+ return null;
}
+ LOG.debug("getExternalAddressMapping : Could be ports exhausted case, "
+ + "try with another externalIP if possible");
+ nextExtIpFlag = true;
+ continue;
+ }
+ // Write to ip-port-map before returning
+ IpPortExternalBuilder ipExt = new IpPortExternalBuilder();
+ IpPortExternal ipPortExt = ipExt.setIpAddress(extIp).setPortNum(extPort.intValue()).build();
+ IpPortMap ipm = new IpPortMapBuilder().withKey(new IpPortMapKey(internalIpPort))
+ .setIpPortInternal(internalIpPort).setIpPortExternal(ipPortExt).build();
+ LOG.debug("getExternalAddressMapping : writing into ip-port-map with "
+ + "externalIP {} and port {}",
+ ipPortExt.getIpAddress(), ipPortExt.getPortNum());
+ try {
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ getIpPortMapIdentifier(segmentId, internalIpPort, protocol), ipm);
+ } catch (UncheckedExecutionException uee) {
+ LOG.error("getExternalAddressMapping : Failed to write into ip-port-map with exception",
+ uee);
+ }
- // Write to snat-internal-ip-port-info
- String internalIpAddress = sourceAddress.getIpAddress();
- int ipPort = sourceAddress.getPortNumber();
- ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
- final ReentrantLock lock = lockFor(segmentId, internalIpAddress, protocolType);
- lock.lock();
+ // Write to snat-internal-ip-port-info
+ String internalIpAddress = sourceAddress.getIpAddress();
+ int ipPort = sourceAddress.getPortNumber();
+ ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
+ final ReentrantLock lock = lockFor(segmentId, internalIpAddress, protocolType);
+ lock.lock();
+ try {
+ List<Uint16> portList = new ArrayList<>(
+ NatUtil.getInternalIpPortListInfo(dataBroker, segmentId, internalIpAddress,
+ protocolType));
+ portList.add(Uint16.valueOf(ipPort));
+
+ IntIpProtoTypeBuilder builder = new IntIpProtoTypeBuilder();
+ IntIpProtoType intIpProtocolType =
+ builder.withKey(new IntIpProtoTypeKey(protocolType)).setPorts(portList).build();
try {
- List<Integer> portList = new ArrayList<>(
- NatUtil.getInternalIpPortListInfo(dataBroker, segmentId, internalIpAddress,
- protocolType));
- portList.add(ipPort);
-
- IntIpProtoTypeBuilder builder = new IntIpProtoTypeBuilder();
- IntIpProtoType intIpProtocolType =
- builder.withKey(new IntIpProtoTypeKey(protocolType)).setPorts(portList).build();
- try {
- MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
- NatUtil.buildSnatIntIpPortIdentifier(segmentId, internalIpAddress, protocolType),
- intIpProtocolType);
- } catch (Exception ex) {
- LOG.error("getExternalAddressMapping : Failed to write into snat-internal-ip-port-info "
- + "with exception", ex);
- }
- } finally {
- lock.unlock();
+ MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ NatUtil.buildSnatIntIpPortIdentifier(segmentId, internalIpAddress, protocolType),
+ intIpProtocolType);
+ } catch (Exception ex) {
+ LOG.error("getExternalAddressMapping : Failed to write into snat-internal-ip-port-info "
+ + "with exception", ex);
}
- SessionAddress externalIpPort = new SessionAddress(extIp, extPort);
- LOG.debug("getExternalAddressMapping : successfully returning externalIP {} "
- + "and port {}", externalIpPort.getIpAddress(), externalIpPort.getPortNumber());
- return externalIpPort;
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("getExternalAddressMapping : Exception caught", e);
- return null;
+ } finally {
+ lock.unlock();
}
+ SessionAddress externalIpPort = new SessionAddress(extIp, extPort.intValue());
+ LOG.debug("getExternalAddressMapping : successfully returning externalIP {} "
+ + "and port {}", externalIpPort.getIpAddress(), externalIpPort.getPortNumber());
+ return externalIpPort;
} // end of for loop
LOG.error("getExternalAddressMapping : Unable to handle external IP address and port mapping with segmentId {},"
+ "internalIp {} and internalPort {}", segmentId, sourceAddress.getIpAddress(),
return null;
}
- /**
- * Release the existing mapping of internal ip/port to external ip/port pair
- * if no mapping exist for given internal ip/port, it returns false.
- *
- * @param segmentId - Router ID
- * @param address - Session Address
- * @param protocol - TCP/UDP
- * @return true if mapping exist and the mapping is removed successfully
- */
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public boolean releaseAddressMapping(long segmentId, SessionAddress address, NAPTEntryEvent.Protocol protocol) {
- LOG.debug("releaseAddressMapping : called with segmentId {}, internalIP {}, port {}",
- segmentId, address.getIpAddress(), address.getPortNumber());
- // delete entry from IpPort Map and IP Map if exists
- String internalIpPort = address.getIpAddress() + ":" + address.getPortNumber();
- SessionAddress existingIpPort = checkIpPortMap(segmentId, internalIpPort, protocol);
- if (existingIpPort != null) {
- // delete the entry from IpPortMap DS
- try {
- removeFromIpPortMapDS(segmentId, internalIpPort, protocol);
- } catch (Exception e) {
- LOG.error("releaseAddressMapping : failed, Removal of ipportmap {} for "
- + "router {} failed", internalIpPort, segmentId, e);
- return false;
- }
- } else {
- LOG.error("releaseAddressMapping : failed, segmentId {} and internalIpPort {} "
- + "not found in IpPortMap DS", segmentId, internalIpPort);
- return false;
- }
- String existingIp = checkIpMap(segmentId, address.getIpAddress());
- if (existingIp != null) {
- // delete the entry from IpMap DS
- try {
- removeFromIpMapDS(segmentId, address.getIpAddress());
- } catch (Exception e) {
- LOG.error("releaseAddressMapping : Removal of ipmap {} for router {} failed",
- address.getIpAddress(), segmentId, e);
- return false;
- }
- //delete the entry from snatIntIpportinfo
- try {
- removeFromSnatIpPortDS(segmentId, address.getIpAddress());
- } catch (Exception e) {
- LOG.error("releaseAddressMapping : failed, Removal of snatipportmap {} for "
- + "router {} failed", address.getIpAddress(), segmentId, e);
- return false;
- }
- } else {
- LOG.error("releaseAddressMapping : failed, segmentId {} and internalIpPort {} "
- + "not found in IpMap DS", segmentId, internalIpPort);
- return false;
- }
- // Finally release port from idmanager
- removePortFromPool(internalIpPort, existingIpPort.getIpAddress());
-
- LOG.debug("releaseAddressMapping : Exited successfully for segmentId {} and internalIpPort {}",
- segmentId, internalIpPort);
- return true;
- }
-
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- protected void releaseIpExtPortMapping(long segmentId, SessionAddress address, NAPTEntryEvent.Protocol protocol) {
+ protected void releaseIpExtPortMapping(Uint32 segmentId, SessionAddress address, NAPTEntryEvent.Protocol protocol) {
String internalIpPort = address.getIpAddress() + ":" + address.getPortNumber();
SessionAddress existingIpPort = checkIpPortMap(segmentId, internalIpPort, protocol);
if (existingIpPort != null) {
try {
removeFromIpPortMapDS(segmentId, internalIpPort, protocol);
// Finally release port from idmanager
- removePortFromPool(internalIpPort, existingIpPort.getIpAddress());
+ Uint32 releasedId = NatUtil.releaseId(idManager, existingIpPort.getIpAddress(), internalIpPort);
+ if (releasedId == NatConstants.INVALID_ID) {
+ LOG.error("releaseIpExtPortMapping : Unable to release ID for key {}",
+ existingIpPort.getIpAddress());
+ }
} catch (Exception e) {
LOG.error("releaseIpExtPortMapping : failed, Removal of ipportmap {} for "
+ "router {} failed", internalIpPort, segmentId, e);
*/
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public boolean removeMapping(long segmentId) {
+ public boolean removeMapping(Uint32 segmentId) {
try {
removeIpMappingForRouterID(segmentId);
removeIpPortMappingForRouterID(segmentId);
return false;
}
- protected InstanceIdentifier<IpMap> getIpMapIdentifier(long segid, String internal) {
+ protected InstanceIdentifier<IpMap> getIpMapIdentifier(Uint32 segid, String internal) {
return InstanceIdentifier.builder(IntextIpMap.class)
.child(IpMapping.class, new IpMappingKey(segid))
.child(IpMap.class, new IpMapKey(internal)).build();
}
- protected InstanceIdentifier<ExternalIpCounter> getExternalIpsIdentifier(long segmentId, String external) {
+ protected InstanceIdentifier<ExternalIpCounter> getExternalIpsIdentifier(Uint32 segmentId, String external) {
return InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(segmentId))
.child(ExternalIpCounter.class, new ExternalIpCounterKey(external)).build();
}
- @Nonnull
- public static List<IpMap> getIpMapList(DataBroker broker, Long routerId) {
+ @NonNull
+ public static List<IpMap> getIpMapList(DataBroker broker, Uint32 routerId) {
InstanceIdentifier<IpMapping> id = getIpMapList(routerId);
- return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
- LogicalDatastoreType.OPERATIONAL, id).toJavaUtil().map(IpMapping::getIpMap).orElse(
- Collections.emptyList());
+ return new ArrayList<IpMap>(SingleTransactionDataBroker
+ .syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(broker,
+ LogicalDatastoreType.OPERATIONAL, id).map(IpMapping::getIpMap).orElse(
+ Collections.emptyMap()).values());
}
- protected static InstanceIdentifier<IpMapping> getIpMapList(long routerId) {
+ protected static InstanceIdentifier<IpMapping> getIpMapList(Uint32 routerId) {
return InstanceIdentifier.builder(
IntextIpMap.class).child(IpMapping.class, new IpMappingKey(routerId)).build();
}
- protected InstanceIdentifier<IpPortMap> getIpPortMapIdentifier(long segid, String internal,
+ protected InstanceIdentifier<IpPortMap> getIpPortMapIdentifier(Uint32 segid, String internal,
NAPTEntryEvent.Protocol protocol) {
ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
return InstanceIdentifier.builder(IntextIpPortMap.class)
}
@Nullable
- private SessionAddress checkIpPortMap(long segmentId, String internalIpPort,
+ private SessionAddress checkIpPortMap(Uint32 segmentId, String internalIpPort,
NAPTEntryEvent.Protocol protocol) {
LOG.debug("checkIpPortMap : called with segmentId {} and internalIpPort {}",
segmentId, internalIpPort);
.child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
.child(IpPortMap.class, new IpPortMapKey(internalIpPort));
InstanceIdentifier<IpPortMap> id = idBuilder.build();
- Optional<IpPortMap> ipPortMapType =
- MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<IpPortMap> ipPortMapType = Optional.empty();
+ try {
+ ipPortMapType = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkIpPortMap: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIpPort {} protocol {}", segmentId, internalIpPort, protocol, e);
+ }
if (ipPortMapType.isPresent()) {
LOG.debug("checkIpPortMap : {}", ipPortMapType.get());
SessionAddress externalIpPort = new SessionAddress(ipPortMapType.get().getIpPortExternal().getIpAddress(),
- ipPortMapType.get().getIpPortExternal().getPortNum());
+ ipPortMapType.get().getIpPortExternal().getPortNum().toJava());
LOG.debug("checkIpPortMap : returning successfully externalIP {} and port {}",
externalIpPort.getIpAddress(), externalIpPort.getPortNumber());
return externalIpPort;
}
@Nullable
- protected String checkIpMap(long segmentId, String internalIp) {
+ protected String checkIpMap(Uint32 segmentId, String internalIp) {
LOG.debug("checkIpMap : called with segmentId {} and internalIp {}", segmentId, internalIp);
String externalIp;
// check if ip-map node is there
InstanceIdentifierBuilder<IpMapping> idBuilder =
InstanceIdentifier.builder(IntextIpMap.class).child(IpMapping.class, new IpMappingKey(segmentId));
InstanceIdentifier<IpMapping> id = idBuilder.build();
- Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMapping> ipMapping = Optional.empty();
+ try {
+ ipMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("checkIpMap: Exception while reading IpMapping DS for the segmentId {} internalIp {}",
+ segmentId, internalIp, e);
+ }
if (ipMapping.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMapping.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap().values()) {
if (Objects.equals(ipMap.getInternalIp(), internalIp)) {
LOG.debug("checkIpMap : IpMap : {}", ipMap);
externalIp = ipMap.getExternalIp();
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- protected void removeSnatIntIpPortDS(long segmentId, SessionAddress address, ProtocolTypes protocolType) {
+ protected void removeSnatIntIpPortDS(Uint32 segmentId, SessionAddress address, ProtocolTypes protocolType) {
LOG.trace("removeSnatIntIpPortDS : method called for IntIpport {} of router {} ",
address, segmentId);
- List<Integer> portList =
+ List<Uint16> portList =
NatUtil.getInternalIpPortListInfo(dataBroker, segmentId, address.getIpAddress(), protocolType);
- if (portList.isEmpty() || !portList.contains(address.getPortNumber())) {
+ if (portList.isEmpty() || !portList.contains(Uint16.valueOf(address.getPortNumber()))) {
LOG.error("removeSnatIntIpPortDS : Internal IP {} for port {} entry not found in SnatIntIpPort DS",
address.getIpAddress(), address.getPortNumber());
return;
LOG.trace("removeSnatIntIpPortDS : PortList {} retrieved for InternalIp {} of router {}",
portList, address.getIpAddress(), segmentId);
Integer port = address.getPortNumber();
- portList.remove(port);
+ portList.remove(Uint16.valueOf(port));
IntIpProtoTypeBuilder builder = new IntIpProtoTypeBuilder();
IntIpProtoType intIpProtocolType =
address.getIpAddress(), address.getPortNumber(), segmentId);
}
- protected void removeFromSnatIpPortDS(long segmentId, String internalIp) {
+ protected void removeFromSnatIpPortDS(Uint32 segmentId, String internalIp) {
InstanceIdentifier<IpPort> intIp = InstanceIdentifier.builder(SnatintIpPortMap.class)
.child(IntipPortMap.class, new IntipPortMapKey(segmentId))
.child(IpPort.class, new IpPortKey(internalIp)).build();
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, intIp);
}
- protected void removeFromIpPortMapDS(long segmentId, String internalIpPort, NAPTEntryEvent.Protocol protocol) {
+ protected void removeFromIpPortMapDS(Uint32 segmentId, String internalIpPort, NAPTEntryEvent.Protocol protocol) {
ProtocolTypes protocolType = NatUtil.getProtocolType(protocol);
removeFromIpPortMapDS(segmentId, internalIpPort, protocolType);
}
- protected void removeFromIpPortMapDS(long segmentId, String internalIpPort, ProtocolTypes protocolType) {
+ protected void removeFromIpPortMapDS(Uint32 segmentId, String internalIpPort, ProtocolTypes protocolType) {
InstanceIdentifierBuilder<IpPortMap> idBuilder = InstanceIdentifier.builder(IntextIpPortMap.class)
.child(IpPortMapping.class, new IpPortMappingKey(segmentId))
.child(IntextIpProtocolType.class, new IntextIpProtocolTypeKey(protocolType))
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
}
- protected void removeFromIpMapDS(long segmentId, String internalIp) {
+ protected void removeFromIpMapDS(Uint32 segmentId, String internalIp) {
InstanceIdentifierBuilder<IpMap> idBuilder = InstanceIdentifier.builder(IntextIpMap.class)
.child(IpMapping.class, new IpMappingKey(segmentId))
.child(IpMap.class, new IpMapKey(internalIp));
InstanceIdentifier<IpMap> id = idBuilder.build();
// Get externalIp and decrement the counter
String externalIp = null;
- Optional<IpMap> ipMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMap> ipMap = Optional.empty();
+ try {
+ ipMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeFromIpMapDS: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIp {}", segmentId, internalIp, e);
+ }
if (ipMap.isPresent()) {
externalIp = ipMap.get().getExternalIp();
LOG.debug("removeFromIpMapDS : externalIP is {}", externalIp);
}
}
- protected void removeIntExtIpMapDS(long segmentId, String internalIp) {
+ protected void removeIntExtIpMapDS(Uint32 segmentId, String internalIp) {
InstanceIdentifierBuilder<IpMap> idBuilder = InstanceIdentifier.builder(IntextIpMap.class)
.child(IpMapping.class, new IpMappingKey(segmentId))
.child(IpMap.class, new IpMapKey(internalIp));
}
@Nullable
- protected String getExternalIpAllocatedForSubnet(long segmentId, String internalIp) {
+ protected String getExternalIpAllocatedForSubnet(Uint32 segmentId, String internalIp) {
InstanceIdentifierBuilder<IpMap> idBuilder = InstanceIdentifier.builder(IntextIpMap.class)
.child(IpMapping.class, new IpMappingKey(segmentId))
.child(IpMap.class, new IpMapKey(internalIp));
InstanceIdentifier<IpMap> id = idBuilder.build();
- Optional<IpMap> ipMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMap> ipMap;
+ try {
+ ipMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("getExternalIpAllocatedForSubnet: Exception while reading IpMap DS for the segmentId {} "
+ + "internalIp {}", segmentId, internalIp, e);
+ return null;
+ }
if (ipMap.isPresent()) {
return ipMap.get().getExternalIp();
}
return null;
}
- private void removeIpMappingForRouterID(long segmentId) {
+ private void removeIpMappingForRouterID(Uint32 segmentId) {
InstanceIdentifierBuilder<IpMapping> idBuilder = InstanceIdentifier.builder(IntextIpMap.class)
.child(IpMapping.class, new IpMappingKey(segmentId));
InstanceIdentifier<IpMapping> id = idBuilder.build();
// Get all externalIps and decrement their counters before deleting the ipmap
- Optional<IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<IpMapping> ipMapping = Optional.empty();
+ try {
+ ipMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.OPERATIONAL, id);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIpMappingForRouterID: Exception while reading IpMapping DS for the segmentId {} ",
+ segmentId, e);
+ }
if (ipMapping.isPresent()) {
- for (IpMap ipMap : requireNonNullElse(ipMapping.get().getIpMap(), Collections.<IpMap>emptyList())) {
+ for (IpMap ipMap : ipMapping.get().nonnullIpMap().values()) {
String externalIp = ipMap.getExternalIp();
LOG.debug("removeIpMappingForRouterID : externalIP is {}", externalIp);
if (externalIp != null) {
}
}
- void removeIpPortMappingForRouterID(long segmentId) {
+ void removeIpPortMappingForRouterID(Uint32 segmentId) {
InstanceIdentifier<IpPortMapping> idBuilder = InstanceIdentifier.builder(IntextIpPortMap.class)
.child(IpPortMapping.class, new IpPortMappingKey(segmentId)).build();
- Optional<IpPortMapping> ipPortMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- idBuilder);
+ Optional<IpPortMapping> ipPortMapping = Optional.empty();
+ try {
+ ipPortMapping = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, idBuilder);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIpPortMappingForRouterID: Exception while reading IpPortMapping DS for the segmentId {} ",
+ segmentId, e);
+ }
if (ipPortMapping.isPresent()) {
// remove from IntExtIpPortmap DS
LOG.debug("removeIpPortMappingForRouterID : Removing IntExtIpPort map for router {} from datastore",
}
}
- void removeIntIpPortMappingForRouterID(long segmentId) {
+ void removeIntIpPortMappingForRouterID(Uint32 segmentId) {
InstanceIdentifier<IntipPortMap> intIp = InstanceIdentifier.builder(SnatintIpPortMap.class)
.child(IntipPortMap.class, new IntipPortMapKey(segmentId)).build();
- Optional<IntipPortMap> intIpPortMap = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, intIp);
+ Optional<IntipPortMap> intIpPortMap = Optional.empty();
+ try {
+ intIpPortMap = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, intIp);
+ } catch (ExecutionException | InterruptedException e) {
+ LOG.error("removeIntIpPortMappingForRouterID: Exception while reading IntipPortMap DS for the "
+ + "segmentId {} ", segmentId, e);
+ }
if (intIpPortMap.isPresent()) {
// remove from SnatIntIpPortmap DS
LOG.debug("removeIntIpPortMappingForRouterID : Removing SnatIntIpPort from datastore : {}", intIp);
}
void removePortFromPool(String internalIpPort, String externalIp) {
- LOG.debug("removePortFromPool : method called");
- ReleaseIdInput idInput = new ReleaseIdInputBuilder()
- .setPoolName(externalIp)
- .setIdKey(internalIpPort).build();
- try {
- RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
- if (!rpcResult.isSuccessful()) {
- LOG.error("removePortFromPool : idmanager failed to remove port from pool {}", rpcResult.getErrors());
- }
- LOG.debug("removePortFromPool : Removed port from pool for InternalIpPort {} with externalIp {}",
- internalIpPort, externalIp);
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("removePortFromPool : idmanager failed when removing entry in pool with key {} with Exception",
- internalIpPort, e);
+ if (NatUtil.releaseId(idManager, externalIp, internalIpPort) == NatConstants.INVALID_ID) {
+ LOG.error("Unable to release id {} from Pool {}", internalIpPort, externalIp);
}
}
- protected void initialiseExternalCounter(Routers routers, long routerId) {
+ protected void initialiseExternalCounter(Routers routers, Uint32 routerId) {
LOG.debug("initialiseExternalCounter : Initialise External IPs counter");
//update the new counter value for this externalIp
- for (ExternalIps externalIp : requireNonNullElse(routers.getExternalIps(),
- Collections.<ExternalIps>emptyList())) {
+ for (ExternalIps externalIp : routers.nonnullExternalIps().values()) {
String[] ipSplit = externalIp.getIpAddress().split("/");
String extIp = ipSplit[0];
String extPrefix = Short.toString(NatConstants.DEFAULT_PREFIX);
}
}
- protected void initialiseNewExternalIpCounter(long routerId, String externalIp) {
+ protected void initialiseNewExternalIpCounter(Uint32 routerId, String externalIp) {
ExternalIpCounter externalIpCounterData = new ExternalIpCounterBuilder()
.withKey(new ExternalIpCounterKey(externalIp)).setExternalIp(externalIp).setCounter((short) 0).build();
MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
getExternalIpsIdentifier(routerId, externalIp), externalIpCounterData);
}
- protected void removeExternalCounter(long routerId) {
+ protected void removeExternalCounter(Uint32 routerId) {
// Remove from external-counters model
InstanceIdentifier<ExternalCounters> id = InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(routerId)).build();
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
- protected void removeExternalIpCounter(long routerId, String externalIp) {
+ protected void removeExternalIpCounter(Uint32 routerId, String externalIp) {
// Remove from external-counters model
InstanceIdentifier<ExternalIpCounter> id = InstanceIdentifier.builder(ExternalIpsCounter.class)
.child(ExternalCounters.class, new ExternalCountersKey(routerId))
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
- private static ReentrantLock lockFor(final long segmentId, String ipAddress, final ProtocolTypes protocolType) {
+ private static ReentrantLock lockFor(final Uint32 segmentId, String ipAddress, final ProtocolTypes protocolType) {
// FIXME: use an Identifier class instead?
String lockName = new StringBuilder()
.append(segmentId)
Code Review / netvirt.git / blobdiff