package org.opendaylight.transportpce.pce.graph;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import org.jgrapht.GraphPath;
import org.opendaylight.transportpce.common.ResponseCodes;
+import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.transportpce.pce.constraints.PceConstraints.ResourcePair;
import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
import org.opendaylight.transportpce.pce.networkanalyzer.PceResult;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PostAlgoPathValidator {
/* Logging. */
- private static final Logger LOG = LoggerFactory.getLogger(PceGraph.class);
+ private static final Logger LOG = LoggerFactory.getLogger(PostAlgoPathValidator.class);
- // TODO hard-coded 96
private static final int MAX_WAWELENGTH = 96;
private static final double MIN_OSNR_W100G = 17;
private static final double TRX_OSNR = 33;
public static final Long CONST_OSNR = 1L;
public static final double SYS_MARGIN = 0;
- public PceResult checkPath(GraphPath<String, PceGraphEdge> path,
- Map<NodeId, PceNode> allPceNodes, PceResult pceResult, PceConstraints pceHardConstraints) {
+ @SuppressFBWarnings(
+ value = "SF_SWITCH_FALLTHROUGH",
+ justification = "intentional fallthrough")
+ public PceResult checkPath(GraphPath<String, PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes,
+ PceResult pceResult, PceConstraints pceHardConstraints, String serviceType) {
- //check if the path is empty
- if (path.getEdgeList().size() == 0) {
+ // check if the path is empty
+ if (path.getEdgeList().isEmpty()) {
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
return pceResult;
}
- //Choose wavelength available in all nodes of the path
- Long waveL = chooseWavelength(path, allPceNodes);
- if (waveL < 0) {
- pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
- pceResult.setLocalCause(PceResult.LocalCause.NO_PATH_EXISTS);
- return pceResult;
- }
- pceResult.setResultWavelength(waveL);
- LOG.info("In PostAlgoPathValidator: chooseWavelength WL found {} {}", waveL, path.toString());
+ int tribSlotNb = 1;
+ //variable to deal with 1GE (Nb=1) and 10GE (Nb=10) cases
+ switch (serviceType) {
+
+ case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_OTU4:
+ // choose wavelength available in all nodes of the path
+ Long waveL = chooseWavelength(path, allPceNodes);
+ pceResult.setServiceType(serviceType);
+ if (waveL < 0) {
+ pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
+ pceResult.setLocalCause(PceResult.LocalCause.NO_PATH_EXISTS);
+ return pceResult;
+ }
+ pceResult.setResultWavelength(waveL);
+ LOG.info("In PostAlgoPathValidator: chooseWavelength WL found {} {}", waveL, path);
+
+ // Check the OSNR
+ if (!checkOSNR(path)) {
+ pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
+ pceResult.setLocalCause(PceResult.LocalCause.OUT_OF_SPEC_OSNR);
+ return pceResult;
+ }
+
+ // Check if MaxLatency is defined in the hard constraints
+ if ((pceHardConstraints.getMaxLatency() != -1)
+ && (!checkLatency(pceHardConstraints.getMaxLatency(), path))) {
+ pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
+ pceResult.setLocalCause(PceResult.LocalCause.TOO_HIGH_LATENCY);
+ return pceResult;
+ }
- // TODO here other post algo validations can be added
- // more data can be sent to PceGraph module via PceResult structure if required
+ // Check if nodes are included in the hard constraints
+ if (!checkInclude(path, pceHardConstraints)) {
+ pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
+ pceResult.setLocalCause(PceResult.LocalCause.HD_NODE_INCLUDE);
+ return pceResult;
+ }
- //Check the OSNR
- if (!checkOSNR(path)) {
- pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
- pceResult.setLocalCause(PceResult.LocalCause.OUT_OF_SPEC_OSNR);
- return pceResult;
- }
+ // TODO here other post algo validations can be added
+ // more data can be sent to PceGraph module via PceResult structure if required
+
+ pceResult.setRC(ResponseCodes.RESPONSE_OK);
+ pceResult.setLocalCause(PceResult.LocalCause.NONE);
- //Check if MaxLatency is defined in the hard constraints
- if (pceHardConstraints.getMaxLatency() != -1) {
- if (!checkLatency(pceHardConstraints.getMaxLatency(), path)) {
+ break;
+
+ case StringConstants.SERVICE_TYPE_10GE:
+ tribSlotNb = 8;
+ //fallthrough
+ case StringConstants.SERVICE_TYPE_1GE:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
- pceResult.setLocalCause(PceResult.LocalCause.TOO_HIGH_LATENCY);
- return pceResult;
- }
- }
+ pceResult.setServiceType(serviceType);
+ Map<String, Uint16> tribPort = chooseTribPort(path, allPceNodes);
+ Map<String, List<Uint16>> tribSlot = chooseTribSlot(path, allPceNodes, tribSlotNb);
+
+ if (tribPort != null && tribSlot != null) {
+ pceResult.setResultTribPort(tribPort);
+ pceResult.setResultTribSlot(tribSlot);
+ pceResult.setResultTribSlotNb(tribSlotNb);
+ pceResult.setRC(ResponseCodes.RESPONSE_OK);
+ LOG.info("In PostAlgoPathValidator: found TribPort {} - tribSlot {} - tribSlotNb {}",
+ tribPort, tribSlot, tribSlotNb);
+ }
+ break;
- //Check if nodes are included in the hard constraints
- if (!checkInclude(path, pceHardConstraints)) {
- pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
- pceResult.setLocalCause(PceResult.LocalCause.HD_NODE_INCLUDE);
- return pceResult;
+ case StringConstants.SERVICE_TYPE_ODU4:
+ pceResult.setRC(ResponseCodes.RESPONSE_OK);
+ LOG.info("In PostAlgoPathValidator: ODU4 path found {}", path);
+ break;
+
+ default:
+ pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
+ LOG.warn("In PostAlgoPathValidator checkPath: unsupported serviceType {} found {}",
+ serviceType, path);
+ break;
}
- pceResult.setRC(ResponseCodes.RESPONSE_OK);
return pceResult;
}
- //Choose the first available wavelength from the source to the destination
+ // Choose the first available wavelength from the source to the destination
private Long chooseWavelength(GraphPath<String, PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes) {
Long wavelength = -1L;
-
for (long i = 1; i <= MAX_WAWELENGTH; i++) {
boolean completed = true;
- LOG.debug("In chooseWavelength: {} {}", path.getLength(), path.toString());
+ LOG.debug("In chooseWavelength: {} {}", path.getLength(), path);
for (PceGraphEdge edge : path.getEdgeList()) {
- LOG.debug("In chooseWavelength: source {} ", edge.link().getSourceId().toString());
+ LOG.debug("In chooseWavelength: source {} ", edge.link().getSourceId());
PceNode pceNode = allPceNodes.get(edge.link().getSourceId());
if (!pceNode.checkWL(i)) {
completed = false;
return wavelength;
}
- //Check the latency
+ // Check the latency
private boolean checkLatency(Long maxLatency, GraphPath<String, PceGraphEdge> path) {
double latency = 0;
for (PceGraphEdge edge : path.getEdgeList()) {
try {
latency += edge.link().getLatency();
- LOG.debug("- In checkLatency: latency of {} = {} units", edge.link().getLinkId().getValue(),latency);
+ LOG.debug("- In checkLatency: latency of {} = {} units", edge.link().getLinkId().getValue(), latency);
} catch (NullPointerException e) {
LOG.warn("- In checkLatency: the link {} does not contain latency field",
edge.link().getLinkId().getValue());
}
}
- if (latency > maxLatency) {
- return false;
- }
- return true;
+ return (latency < maxLatency);
}
- //Check the inclusion if it is defined in the hard constraints
+ // Check the inclusion if it is defined in the hard constraints
private boolean checkInclude(GraphPath<String, PceGraphEdge> path, PceConstraints pceHardConstraintsInput) {
List<ResourcePair> listToInclude = pceHardConstraintsInput.getListToInclude();
if (listToInclude.isEmpty()) {
List<PceGraphEdge> pathEdges = path.getEdgeList();
LOG.debug(" in checkInclude vertex list: [{}]", path.getVertexList());
- List<String> listOfElementsSubNode = new ArrayList<String>();
- listOfElementsSubNode.add(pathEdges.get(0).link().getsourceSupNodeId());
+ List<String> listOfElementsSubNode = new ArrayList<>();
+ listOfElementsSubNode.add(pathEdges.get(0).link().getsourceNetworkSupNodeId());
listOfElementsSubNode.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.NODE,
pceHardConstraintsInput));
- List<String> listOfElementsCLLI = new ArrayList<String>();
+ List<String> listOfElementsCLLI = new ArrayList<>();
listOfElementsCLLI.add(pathEdges.get(0).link().getsourceCLLI());
listOfElementsCLLI.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.CLLI,
pceHardConstraintsInput));
- List<String> listOfElementsSRLG = new ArrayList<String>();
+ List<String> listOfElementsSRLG = new ArrayList<>();
// first link is XPONDEROUTPUT, no SRLG for it
listOfElementsSRLG.add("NONE");
listOfElementsSRLG.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.SRLG,
private List<String> listOfElementsBuild(List<PceGraphEdge> pathEdges, PceConstraints.ResourceType type,
PceConstraints pceHardConstraints) {
- List<String> listOfElements = new ArrayList<String>();
- for (PceGraphEdge link: pathEdges) {
+ List<String> listOfElements = new ArrayList<>();
+ for (PceGraphEdge link : pathEdges) {
switch (type) {
case NODE:
- listOfElements.add(link.link().getdestSupNodeId());
+ listOfElements.add(link.link().getdestNetworkSupNodeId());
break;
case CLLI:
listOfElements.add(link.link().getdestCLLI());
listOfElements.add("NONE");
break;
}
-
- // srlg of link is List<Long>. But in this algo we need string representation of one SRLG
- // this should be any SRLG mentioned in include constraints if any of them if mentioned
+ // srlg of link is List<Long>. But in this algo we need string representation of
+ // one SRLG
+ // this should be any SRLG mentioned in include constraints if any of them if
+ // mentioned
boolean found = false;
for (Long srlg : link.link().getsrlgList()) {
String srlgStr = String.valueOf(srlg);
if (pceHardConstraints.getSRLGnames().contains(srlgStr)) {
listOfElements.add(srlgStr);
- LOG.info("listOfElementsBuild. FOUND SRLG {} in link {}", srlgStr, link.link().toString());
+ LOG.info("listOfElementsBuild. FOUND SRLG {} in link {}", srlgStr, link.link());
found = true;
- continue;
}
}
if (!found) {
return listOfElements;
}
- //Check the path OSNR
+ private Map<String, Uint16> chooseTribPort(GraphPath<String,
+ PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes) {
+ LOG.info("In choosetribPort: edgeList = {} ", path.getEdgeList());
+ Map<String, Uint16> tribPortMap = new HashMap<>();
+
+ for (PceGraphEdge edge : path.getEdgeList()) {
+ NodeId linkSrcNode = edge.link().getSourceId();
+ String linkSrcTp = edge.link().getSourceTP().toString();
+ NodeId linkDestNode = edge.link().getDestId();
+ String linkDestTp = edge.link().getDestTP().toString();
+ PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
+ PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
+ List<Uint16> srcTpnPool = pceOtnNodeSrc.getAvailableTribPorts().get(linkSrcTp);
+ List<Uint16> destTpnPool = pceOtnNodeDest.getAvailableTribPorts().get(linkDestTp);
+ List<Uint16> commonEdgeTpnPool = new ArrayList<>();
+ for (Uint16 integer : srcTpnPool) {
+ if (destTpnPool.contains(integer)) {
+ commonEdgeTpnPool.add(integer);
+ }
+ }
+ Collections.sort(commonEdgeTpnPool);
+ if (!commonEdgeTpnPool.isEmpty()) {
+ tribPortMap.put(edge.link().getLinkId().getValue(), commonEdgeTpnPool.get(0));
+ }
+ }
+ tribPortMap.forEach((k,v) -> LOG.info("TribPortMap : k = {}, v = {}", k, v));
+ return tribPortMap;
+ }
+
+ private Map<String, List<Uint16>> chooseTribSlot(GraphPath<String,
+ PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, int nbSlot) {
+ LOG.info("In choosetribSlot: edgeList = {} ", path.getEdgeList());
+ Map<String, List<Uint16>> tribSlotMap = new HashMap<>();
+
+ for (PceGraphEdge edge : path.getEdgeList()) {
+ NodeId linkSrcNode = edge.link().getSourceId();
+ String linkSrcTp = edge.link().getSourceTP().toString();
+ NodeId linkDestNode = edge.link().getDestId();
+ String linkDestTp = edge.link().getDestTP().toString();
+ PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
+ PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
+ List<Uint16> srcTsPool = pceOtnNodeSrc.getAvailableTribSlots().get(linkSrcTp);
+ List<Uint16> destTsPool = pceOtnNodeDest.getAvailableTribSlots().get(linkDestTp);
+ List<Uint16> commonEdgeTsPool = new ArrayList<>();
+ List<Uint16> tribSlotList = new ArrayList<>();
+ for (Uint16 integer : srcTsPool) {
+ if (destTsPool.contains(integer)) {
+ commonEdgeTsPool.add(integer);
+ }
+ }
+ Collections.sort(commonEdgeTsPool);
+ boolean discontinue = true;
+ int index = 0;
+ while (discontinue && (commonEdgeTsPool.size() - index >= nbSlot)) {
+ discontinue = false;
+ Integer val = commonEdgeTsPool.get(index).toJava();
+ for (int i = 0; i < nbSlot; i++) {
+ if (commonEdgeTsPool.get(index + i).equals(Uint16.valueOf(val + i))) {
+ tribSlotList.add(commonEdgeTsPool.get(index + i));
+ } else {
+ discontinue = true;
+ tribSlotList.clear();
+ index += i;
+ break;
+ }
+ }
+ }
+ tribSlotMap.put(edge.link().getLinkId().getValue(), tribSlotList);
+ }
+ tribSlotMap.forEach((k,v) -> LOG.info("TribSlotMap : k = {}, v = {}", k, v));
+ return tribSlotMap;
+ }
+
+ // Check the path OSNR
private boolean checkOSNR(GraphPath<String, PceGraphEdge> path) {
double linkOsnrDb;
double osnrDb = 0;
}
try {
osnrDb = getOsnrDb(1 / inverseLocalOsnr);
- }
- catch (ArithmeticException e) {
+ } catch (ArithmeticException e) {
LOG.debug("In checkOSNR: OSNR is equal to 0 and the number of links is: {}", path.getEdgeList().size());
return false;
}
LOG.info("In checkOSNR: OSNR of the path is {} dB", osnrDb);
- if ((osnrDb + SYS_MARGIN) < MIN_OSNR_W100G) {
- return false;
- }
- return true;
+ return ((osnrDb + SYS_MARGIN) > MIN_OSNR_W100G);
}
private double getOsnrDb(double osnrLu) {
return (CONST_OSNR / linkOsnrLu);
}
-}
\ No newline at end of file
+}
Code Review / transportpce.git / blobdiff