import org.immutables.value.Value;
import org.opendaylight.genius.infra.OpenDaylightImmutableStyle;
+import org.opendaylight.yangtools.yang.common.Uint64;
@Value.Immutable
@OpenDaylightImmutableStyle
public interface TunnelEndPointInfo {
- String getSrcEndPointInfo();
+ Uint64 getSrcEndPointInfo();
- String getDstEndPointInfo();
+ Uint64 getDstEndPointInfo();
+
+ @Value.Lazy
+ default String getSrcEndPointName() {
+ return getSrcEndPointInfo().toString();
+ }
+
+ @Value.Lazy
+ default String getDstEndPointName() {
+ return getDstEndPointInfo().toString();
+ }
}
@Override
protected void added(InstanceIdentifier<DPNTEPsInfo> path, DPNTEPsInfo dpnTepsInfo) {
- LOG.info("DPNTepsInfo Add Received for {}", dpnTepsInfo.getDPNID());
- String dpnId = dpnTepsInfo.getDPNID().toString();
+ final Uint64 dpnId = dpnTepsInfo.getDPNID();
+ final String dpnIdStr = dpnId.toString();
+ LOG.info("DPNTepsInfo Add Received for {}", dpnIdStr);
Collection<TunnelStateInfo> tunnelStateInfoList;
- try (Acquired lock = directTunnelUtils.lockTunnel(dpnId)) {
- tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnId);
+ try (Acquired lock = directTunnelUtils.lockTunnel(dpnIdStr)) {
+ tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnIdStr);
}
if (tunnelStateInfoList != null) {
dstDpnTepsInfo = tsInfo.getDstDpnTepsInfo();
if (dstDpnTepsInfo == null) {
// Check if the destination End Point has come
- try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getDstEndPointInfo())) {
+ final String dstEndpoint = tunnelEndPointInfo.getDstEndPointName();
+ try (Acquired lock = directTunnelUtils.lockTunnel(dstEndpoint)) {
Optional<DPNTEPsInfo> dstInfoOpt = getDPNTepFromDPNId(
- Uint64.valueOf(tunnelEndPointInfo.getDstEndPointInfo()));
+ tunnelEndPointInfo.getDstEndPointInfo());
if (dstInfoOpt.isPresent()) {
dstDpnTepsInfo = dstInfoOpt.get();
} else {
.setNodeConnectorInfo(tsInfo.getNodeConnectorInfo())
.setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
.setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
- .setSrcDpnTepsInfo(srcDpnTepsInfo).build();
+ .setSrcDpnTepsInfo(srcDpnTepsInfo)
+ .build();
LOG.trace("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
- interfaceName, tunnelEndPointInfo.getDstEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo
- .getDstEndPointInfo(), tunnelStateInfoNew);
+ interfaceName, dstEndpoint);
+ unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfoNew);
}
}
}
srcDpnTepsInfo = tsInfo.getSrcDpnTepsInfo();
// Check if the destination End Point has come
if (srcDpnTepsInfo == null) {
- try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getSrcEndPointInfo())) {
+ final String srcEndpoint = tunnelEndPointInfo.getSrcEndPointName();
+ try (Acquired lock = directTunnelUtils.lockTunnel(srcEndpoint)) {
Optional<DPNTEPsInfo> srcInfoOpt = getDPNTepFromDPNId(
- Uint64.valueOf(tunnelEndPointInfo.getSrcEndPointInfo()));
+ tunnelEndPointInfo.getSrcEndPointInfo());
if (srcInfoOpt.isPresent()) {
srcDpnTepsInfo = srcInfoOpt.get();
} else {
- TunnelStateInfo tunnelStateInfoNew = new TunnelStateInfoBuilder().setNodeConnectorInfo(
- tsInfo.getNodeConnectorInfo())
- .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
- .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
- .setDstDpnTepsInfo(dstDpnTepsInfo).build();
+ TunnelStateInfo tunnelStateInfoNew = new TunnelStateInfoBuilder()
+ .setNodeConnectorInfo(tsInfo.getNodeConnectorInfo())
+ .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
+ .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
+ .setDstDpnTepsInfo(dstDpnTepsInfo)
+ .build();
LOG.trace("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
interfaceName,
tsInfo.getTunnelEndPointInfo().getSrcEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo.getSrcEndPointInfo(),
- tunnelStateInfoNew);
+ unprocessedNodeConnectorEndPointCache.add(srcEndpoint, tunnelStateInfoNew);
}
}
}
.setRemoteDPN(remoteDpns.getDestinationDpnId()).build();
dpnTepInterfaceMap.put(dpn, value);
- addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), dpnsTeps.getSourceDpnId().toString(),
- remoteDpns.getDestinationDpnId().toString());
+ addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), dpnsTeps.getSourceDpnId(),
+ remoteDpns.getDestinationDpnId());
//Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorCache
if (tunnelStateInfo != null) {
LOG.debug("Processing the Unprocessed NodeConnector for Tunnel {}", remoteDpns.getTunnelName());
- TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId().toString(),
- remoteDpns.getDestinationDpnId().toString());
+ TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId(),
+ remoteDpns.getDestinationDpnId());
TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder()
.setNodeConnectorInfo(tunnelStateInfo.getNodeConnectorInfo()).setDpnTepInterfaceInfo(value)
.setTunnelEndPointInfo(tunnelEndPtInfo);
tunnelStateInfoNew = builder.build();
if (tunnelStateInfoNew.getSrcDpnTepsInfo() == null) {
- String srcDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getSrcEndPointInfo();
+ String srcDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getSrcEndPointName();
try (Acquired lock = directTunnelUtils.lockTunnel(srcDpnId)) {
LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
remoteDpns.getTunnelName(), srcDpnId);
}
if (tunnelStateInfoNew.getDstDpnTepsInfo() == null) {
- String dstDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getDstEndPointInfo();
+ String dstDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getDstEndPointName();
try (Acquired lock = directTunnelUtils.lockTunnel(dstDpnId)) {
LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
remoteDpns.getTunnelName(), dstDpnId);
}
}
- private DpnTepInterfaceInfo getDpnTepInterface(String srcDpnId, String dstDpnId) {
- return getDpnTepInterface(Uint64.valueOf(srcDpnId), Uint64.valueOf(dstDpnId));
- }
-
public DpnTepInterfaceInfo getDpnTepInterface(Uint64 srcDpnId, Uint64 dstDpnId) {
DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
if (dpnTepInterfaceInfo == null) {
.setRemoteDPN(remoteDpns.getDestinationDpnId()).build();
dpnTepInterfaceMap.putIfAbsent(getDpnId(srcDpnId, remoteDpns.getDestinationDpnId()), value);
addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(),
- teps.getSourceDpnId().toString(), remoteDpns.getDestinationDpnId().toString());
+ teps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
}
);
}
public Interface getInterfaceFromCache(String tunnelName) {
TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
- Uint64 srcDpnId = Uint64.valueOf(endPointInfo.getSrcEndPointInfo());
- Uint64 dstDpnId = Uint64.valueOf(endPointInfo.getDstEndPointInfo());
+ Uint64 srcDpnId = endPointInfo.getSrcEndPointInfo();
+ Uint64 dstDpnId = endPointInfo.getDstEndPointInfo();
Interface iface = null ;
int monitoringInt = 1000;
DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(srcDpnId, dstDpnId);
}
//Start: TunnelEndPoint Cache accessors
- private void addTunnelEndPointInfoToCache(String tunnelName, String srcEndPtInfo, String dstEndPtInfo) {
+ private void addTunnelEndPointInfoToCache(String tunnelName, Uint64 srcEndPtInfo, Uint64 dstEndPtInfo) {
tunnelEndpointMap.put(tunnelName, getTunnelEndPointInfo(srcEndPtInfo,dstEndPtInfo));
}
- private TunnelEndPointInfo getTunnelEndPointInfo(String srcEndPtInfo, String dstEndPtInfo) {
- return
- new TunnelEndPointInfoBuilder().setSrcEndPointInfo(srcEndPtInfo).setDstEndPointInfo(dstEndPtInfo).build();
+ private static TunnelEndPointInfo getTunnelEndPointInfo(Uint64 srcEndPtInfo, Uint64 dstEndPtInfo) {
+ return new TunnelEndPointInfoBuilder()
+ .setSrcEndPointInfo(srcEndPtInfo)
+ .setDstEndPointInfo(dstEndPtInfo)
+ .build();
}
public TunnelEndPointInfo getTunnelEndPointInfoFromCache(String tunnelName) {
if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) {
tunnelEndPtInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(portName);
TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo);
- dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getSrcEndPointInfo()))
+ dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getSrcEndPointInfo())
.ifPresent(builder::setSrcDpnTepsInfo);
- dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getDstEndPointInfo()))
+ dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getDstEndPointInfo())
.ifPresent(builder::setDstDpnTepsInfo);
tunnelStateInfo = builder.setTunnelEndPointInfo(tunnelEndPtInfo)
.setDpnTepInterfaceInfo(dpnTepStateCache.getTunnelFromCache(portName)).build();
if (tunnelStateInfo.getSrcDpnTepsInfo() == null) {
- try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPtInfo.getSrcEndPointInfo())) {
+ final String srcEndpoint = tunnelEndPtInfo.getSrcEndPointName();
+ try (Acquired lock = directTunnelUtils.lockTunnel(srcEndpoint)) {
LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
portName, tunnelEndPtInfo.getSrcEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPtInfo.getSrcEndPointInfo(), tunnelStateInfo);
+ unprocessedNodeConnectorEndPointCache.add(srcEndpoint, tunnelStateInfo);
}
}
if (tunnelStateInfo.getDstDpnTepsInfo() == null) {
- try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPtInfo.getDstEndPointInfo())) {
+ final String dstEndpoint = tunnelEndPtInfo.getDstEndPointName();
+ try (Acquired lock = directTunnelUtils.lockTunnel(dstEndpoint)) {
LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
portName, tunnelEndPtInfo.getDstEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPtInfo.getDstEndPointInfo(), tunnelStateInfo);
+ unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfo);
}
}
}
tunnelType = dpnTepInfo.getTunnelType();
final SrcInfoBuilder srcInfoBuilder =
- new SrcInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getSrcEndPointInfo());
+ new SrcInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getSrcEndPointName());
final DstInfoBuilder dstInfoBuilder =
- new DstInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointInfo());
+ new DstInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointName());
LOG.trace("Source Dpn TEP Info {}",srcDpnTepsInfo);
TunnelEndPoints srcEndPtInfo = srcDpnTepsInfo.getTunnelEndPoints().get(0);
srcInfoBuilder.setTepIp(srcEndPtInfo.getIpAddress());
.builder(DpnEndpoints.class)
.child(DPNTEPsInfo.class, new DPNTEPsInfoKey(
// FIXME: the cache should be caching this value, not just as a String
- Uint64.valueOf(dpnTepStateCache.getTunnelEndPointInfoFromCache(
- interfaceInfo.getTunnelName()).getDstEndPointInfo())))
- .build());
+ dpnTepStateCache.getTunnelEndPointInfoFromCache(
+ interfaceInfo.getTunnelName()).getDstEndPointInfo())).build());
Integer dstId;
if (dpntePsInfoOptional.isPresent()) {
dstId = dpntePsInfoOptional.get().getDstId();
return Futures.immediateFuture(new GetEgressActionsForTunnelOutputBuilder()
.setAction(result.stream().map(ActionInfo::buildAction).collect(Collectors.toList())).build());
+
}
}