X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=pce%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fpce%2Fnetworkanalyzer%2FPceCalculation.java;h=113135541659e803c9345e7c1fe5a3c00a66dc9a;hb=66ccddbe00692f230350a19e1a222f09d6abd9a7;hp=80c1cc2d070551043fa742894ba94b4157649b01;hpb=a70240770a8f2b4fc01e005df07cdf4155bf59c0;p=transportpce.git diff --git a/pce/src/main/java/org/opendaylight/transportpce/pce/networkanalyzer/PceCalculation.java b/pce/src/main/java/org/opendaylight/transportpce/pce/networkanalyzer/PceCalculation.java index 80c1cc2d0..113135541 100644 --- a/pce/src/main/java/org/opendaylight/transportpce/pce/networkanalyzer/PceCalculation.java +++ b/pce/src/main/java/org/opendaylight/transportpce/pce/networkanalyzer/PceCalculation.java @@ -5,25 +5,28 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.transportpce.pce; -import com.google.common.base.Optional; +package org.opendaylight.transportpce.pce.networkanalyzer; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Optional; +import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.transportpce.common.NetworkUtils; import org.opendaylight.transportpce.common.ResponseCodes; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.pce.constraints.PceConstraints; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev190624.PathComputationRequestInput; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType; import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks; @@ -41,66 +44,74 @@ import org.slf4j.LoggerFactory; public class PceCalculation { /* Logging. */ private static final Logger LOG = LoggerFactory.getLogger(PceCalculation.class); - private DataBroker dataBroker = null; + private NetworkTransactionService networkTransactionService = null; + ///////////// data parsed from Input///////////////// private PathComputationRequestInput input; private String anodeId = ""; private String znodeId = ""; + private PceConstraints pceHardConstraints; - private PceConstraints pceSoftConstraints; + ///////////// Intermediate data///////////////// private List addLinks = new ArrayList(); private List dropLinks = new ArrayList(); private HashSet azSrgs = new HashSet(); + private PceNode aendPceNode = null; private PceNode zendPceNode = null; + private List allLinks = null; private List allNodes = null; + // this List serves graph calculation private Map allPceNodes = new HashMap(); - // this List serves calculation of ZtoA path descritopn + // this List serves calculation of ZtoA path description // TODO maybe better solution is possible private Map allPceLinks = new HashMap(); + private Set linksToExclude = new HashSet(); private PceResult returnStructure; - public PceResult getReturnStructure() { - return this.returnStructure; - } - - public enum NodeConstraint { + private enum ConstraintTypes { NONE, HARD_EXCLUDE, HARD_INCLUDE, HARD_DIVERSITY, SOFT_EXCLUDE, SOFT_INCLUDE, SOFT_DIVERSITY; } - public PceCalculation(PathComputationRequestInput input, DataBroker dataBroker, PceConstraints pceHardConstraints, - PceConstraints pceSoftConstraints, PceResult rc) { + public PceCalculation(PathComputationRequestInput input, NetworkTransactionService networkTransactionService, + PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc) { this.input = input; - this.dataBroker = dataBroker; + this.networkTransactionService = networkTransactionService; this.returnStructure = rc; + this.pceHardConstraints = pceHardConstraints; - this.pceSoftConstraints = pceSoftConstraints; parseInput(); } - // apply constraints to get applicable result public void calcPath() { + LOG.info("In PceCalculation calcPath: "); + if (!readMdSal()) { - this.returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); + returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); return; } + + MapUtils.mapDiversityConstraints(allNodes, allLinks, pceHardConstraints); + if (!analyzeNw()) { - this.returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); + returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); return; } - this.returnStructure.setRC(ResponseCodes.RESPONSE_OK); + printNodesInfo(allPceNodes); + + returnStructure.setRC(ResponseCodes.RESPONSE_OK); return; } private boolean parseInput() { - this.anodeId = this.input.getServiceAEnd().getNodeId(); - this.znodeId = this.input.getServiceZEnd().getNodeId(); - LOG.info("parseInput: A and Z :[{}] and [{}]", this.anodeId, this.znodeId); - this.returnStructure.setRate(this.input.getServiceAEnd().getServiceRate()); + anodeId = input.getServiceAEnd().getNodeId(); + znodeId = input.getServiceZEnd().getNodeId(); + LOG.info("parseInput: A and Z :[{}] and [{}]", anodeId, znodeId); + returnStructure.setRate(input.getServiceAEnd().getServiceRate()); return true; } @@ -108,266 +119,330 @@ public class PceCalculation { LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID); InstanceIdentifier nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class) .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build(); - ReadOnlyTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction(); Network nw = null; try { Optional nwOptional = - readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get(); + networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get(); if (nwOptional.isPresent()) { nw = nwOptional.get(); LOG.debug("readMdSal: network nodes: nwOptional.isPresent = true {}", nw.toString()); } - } catch (ExecutionException | InterruptedException e) { + } catch (InterruptedException | ExecutionException e) { LOG.error("readMdSal: Error reading topology {}", nwInstanceIdentifier); - readOnlyTransaction.close(); - this.returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); + networkTransactionService.close(); + returnStructure.setRC(ResponseCodes.RESPONSE_FAILED); throw new RuntimeException( "readMdSal: Error reading from operational store, topology : " + nwInstanceIdentifier + " :" + e); } - readOnlyTransaction.close(); + networkTransactionService.close(); + if (nw == null) { LOG.error("readMdSal: network is null: {}", nwInstanceIdentifier); return false; } - this.allNodes = nw.getNode().stream() - .sorted((node1, node2) -> node1.getNodeId().getValue().compareTo(node2.getNodeId().getValue())) - .collect(Collectors.toList()); + allNodes = nw.getNode().stream().sorted((n1, n2) -> n1.getNodeId().getValue().compareTo(n2.getNodeId() + .getValue())).collect(Collectors.toList()); Network1 nw1 = nw.augmentation(Network1.class); - this.allLinks = nw1.getLink(); - if ((this.allNodes == null) || this.allNodes.isEmpty()) { + + allLinks = nw1.getLink().stream().sorted((l1, l2) -> l1.getSource().getSourceTp().toString().compareTo(l2 + .getSource().getSourceTp().toString())).collect(Collectors.toList()); + if (allNodes == null || allNodes.isEmpty()) { LOG.error("readMdSal: no nodes "); return false; } - LOG.info("readMdSal: network nodes: {} nodes added", this.allNodes.size()); - if ((this.allLinks == null) || this.allLinks.isEmpty()) { + LOG.info("readMdSal: network nodes: {} nodes added", allNodes.size()); + LOG.debug("readMdSal: network nodes: {} nodes added", allNodes.toString()); + + if (allLinks == null || allLinks.isEmpty()) { LOG.error("readMdSal: no links "); return false; } - LOG.info("readMdSal: network links: {} links added", this.allLinks.size()); + LOG.info("readMdSal: network links: {} links added", allLinks.size()); + LOG.debug("readMdSal: network links: {} links added", allLinks.toString()); + return true; } private boolean analyzeNw() { - LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", this.allNodes.size(), this.allLinks.size()); - for (Node node : this.allNodes) { + + LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", allNodes.size(), allLinks.size()); + + for (Node node : allNodes) { validateNode(node); } - LOG.debug("analyzeNw: allPceNodes size {} : {}", this.allPceNodes.size(), this.allPceNodes.toString()); - if ((this.aendPceNode == null) || (this.zendPceNode == null)) { + LOG.debug("analyzeNw: allPceNodes size {}", allPceNodes.size()); + + if (aendPceNode == null || zendPceNode == null) { LOG.error("analyzeNw: Error in reading nodes: A or Z do not present in the network"); return false; } - for (Link link : this.allLinks) { + + for (Link link : allLinks) { validateLink(link); } - LOG.debug("analyzeNw: AddLinks size {}, DropLinks size {}", this.addLinks.size(), this.dropLinks.size()); + + LOG.debug("analyzeNw: addLinks size {}, dropLinks size {}", addLinks.size(), dropLinks.size()); + // debug prints - LOG.info("analyzeNw: AZSrgs size = {}", this.azSrgs.size()); - for (NodeId srg : this.azSrgs) { - LOG.info("analyzeNw: A/Z Srgs SRG = {}", srg.getValue()); + LOG.debug("analyzeNw: azSrgs size = {}", azSrgs.size()); + for (NodeId srg : azSrgs) { + LOG.debug("analyzeNw: A/Z Srgs SRG = {}", srg.getValue()); } // debug prints - for (PceLink link : this.addLinks) { - filterAddLinks(link); + + for (PceLink link : addLinks) { + filteraddLinks(link); } - for (PceLink link : this.dropLinks) { - filterDropLinks(link); + for (PceLink link : dropLinks) { + filterdropLinks(link); } - LOG.info("analyzeNw: allPceNodes size {}, allPceLinks size {}", this.allPceNodes.size(), this.allPceLinks - .size()); + + LOG.info("analyzeNw: allPceNodes size {}, allPceLinks size {}", allPceNodes.size(), allPceLinks.size()); + + if ((allPceNodes.size() == 0) || (allPceLinks.size() == 0)) { + return false; + } + + LOG.debug("analyzeNw: allPceNodes {}", allPceNodes.toString()); + LOG.debug("analyzeNw: allPceLinks {}", allPceLinks.toString()); + return true; } - private boolean filterAddLinks(PceLink pcelink) { + private boolean filteraddLinks(PceLink pcelink) { + NodeId nodeId = pcelink.getSourceId(); - if (this.azSrgs.contains(nodeId)) { - this.allPceLinks.put(pcelink.getLinkId(), pcelink); - this.allPceNodes.get(nodeId).addOutgoingLink(pcelink); - LOG.info("analyzeNw: Add_LINK added to source and to allPceLinks {}", pcelink.getLinkId().toString()); + + if (azSrgs.contains(nodeId)) { + allPceLinks.put(pcelink.getLinkId(), pcelink); + allPceNodes.get(nodeId).addOutgoingLink(pcelink); + LOG.debug("analyzeNw: Add_LINK added to source and to allPceLinks {}", pcelink.getLinkId().toString()); return true; } + // remove the SRG from PceNodes, as it is not directly connected to A/Z - this.allPceNodes.remove(nodeId); + allPceNodes.remove(nodeId); LOG.debug("analyzeNw: SRG removed {}", nodeId.getValue()); + return false; } - private boolean filterDropLinks(PceLink pcelink) { + private boolean filterdropLinks(PceLink pcelink) { + NodeId nodeId = pcelink.getDestId(); - if (this.azSrgs.contains(nodeId)) { - this.allPceLinks.put(pcelink.getLinkId(), pcelink); - this.allPceNodes.get(nodeId).addOutgoingLink(pcelink); - LOG.info("analyzeNw: Drop_LINK added to dest and to allPceLinks {}", pcelink.getLinkId().toString()); + + if (azSrgs.contains(nodeId)) { + allPceLinks.put(pcelink.getLinkId(), pcelink); + allPceNodes.get(nodeId).addOutgoingLink(pcelink); + LOG.debug("analyzeNw: Drop_LINK added to dest and to allPceLinks {}", pcelink.getLinkId().toString()); return true; } + // remove the SRG from PceNodes, as it is not directly connected to A/Z - this.allPceNodes.remove(pcelink.getDestId()); + allPceNodes.remove(pcelink.getDestId()); LOG.debug("analyzeNw: SRG removed {}", nodeId.getValue()); + return false; } private boolean validateLink(Link link) { - LOG.info("validateLink: link {} ", link.toString()); + + LOG.debug("validateLink: link {} ", link.toString()); + + if (linksToExclude.contains(link.getLinkId())) { + LOG.info("validateLink: Link is ignored due opposite link problem - {}", link.getLinkId().getValue()); + return false; + } + NodeId sourceId = link.getSource().getSourceNode(); NodeId destId = link.getDestination().getDestNode(); - PceNode source = this.allPceNodes.get(sourceId); - PceNode dest = this.allPceNodes.get(destId); + PceNode source = allPceNodes.get(sourceId); + PceNode dest = allPceNodes.get(destId); + if (source == null) { - LOG.warn("validateLink: source node is rejected by node validation - {}", link.getSource().getSourceNode() - .getValue()); + LOG.debug("validateLink: Link is ignored due source node is rejected by node validation - {}", + link.getSource().getSourceNode().getValue()); return false; } if (dest == null) { - LOG.warn("validateLink: dest node is rejected by node validation - {}", link.getDestination().getDestNode() - .getValue()); + LOG.debug("validateLink: Link is ignored due dest node is rejected by node validation - {}", + link.getDestination().getDestNode().getValue()); return false; } - PceLink pcelink = new PceLink(link); + + PceLink pcelink = new PceLink(link, source, dest); if (!pcelink.isValid()) { - LOG.error(" validateLink: Link is ignored due errors in network data "); + dropOppositeLink(link); + LOG.error(" validateLink: Link is ignored due errors in network data or in opposite link"); return false; } + LinkId linkId = pcelink.getLinkId(); - switch (pcelink.getLinkType()) { + + switch (validateLinkConstraints(pcelink)) { + case HARD_EXCLUDE : + dropOppositeLink(link); + LOG.debug("validateLink: constraints : link is ignored == {}", linkId.getValue()); + return false; + default: + break; + } + + switch (pcelink.getlinkType()) { case ROADMTOROADM : - this.allPceLinks.put(linkId, pcelink); + allPceLinks.put(linkId, pcelink); source.addOutgoingLink(pcelink); - LOG.info("validateLink: ROADMTOROADM-LINK added to allPceLinks {}", pcelink.toString()); + LOG.debug("validateLink: ROADMTOROADM-LINK added to allPceLinks {}", pcelink.toString()); break; case EXPRESSLINK : - this.allPceLinks.put(linkId, pcelink); + allPceLinks.put(linkId, pcelink); source.addOutgoingLink(pcelink); - LOG.info("validateLink: EXPRESS-LINK added to allPceLinks {}", pcelink.toString()); + LOG.debug("validateLink: EXPRESS-LINK added to allPceLinks {}", pcelink.toString()); break; case ADDLINK : pcelink.setClient(source.getRdmSrgClient(pcelink.getSourceTP().toString(), true)); - this.addLinks.add(pcelink); - LOG.info("validateLink: ADD-LINK saved {}", pcelink.toString()); + addLinks.add(pcelink); + LOG.debug("validateLink: ADD-LINK saved {}", pcelink.toString()); break; case DROPLINK : pcelink.setClient(dest.getRdmSrgClient(pcelink.getDestTP().toString(), false)); - this.dropLinks.add(pcelink); - LOG.info("validateLink: DROP-LINK saved {}", pcelink.toString()); + dropLinks.add(pcelink); + LOG.debug("validateLink: DROP-LINK saved {}", pcelink.toString()); break; case XPONDERINPUT : - this.azSrgs.add(sourceId); - // store separately all SRG links directly connected to A/Z + // store separately all SRG links directly + azSrgs.add(sourceId); + // connected to A/Z if (!dest.checkTP(pcelink.getDestTP().toString())) { LOG.debug("validateLink: XPONDER-INPUT is rejected as NW port is busy - {} ", pcelink.toString()); return false; } - pcelink.setClient(dest.getXpdrClient(pcelink.getDestTP().toString())); - this.allPceLinks.put(linkId, pcelink); + pcelink.setClient(dest.getClient(pcelink.getDestTP().toString())); + allPceLinks.put(linkId, pcelink); source.addOutgoingLink(pcelink); - LOG.info("validateLink: XPONDER-INPUT link added to allPceLinks {}", pcelink.toString()); + LOG.debug("validateLink: XPONDER-INPUT link added to allPceLinks {}", pcelink.toString()); break; + // does it mean XPONDER==>>SRG ? case XPONDEROUTPUT : - // does it mean XPONDER==>>SRG ? - this.azSrgs.add(destId); - // store separately all SRG links directly connected to A/Z + // store separately all SRG links directly + azSrgs.add(destId); + // connected to A/Z if (!source.checkTP(pcelink.getSourceTP().toString())) { LOG.debug("validateLink: XPONDER-OUTPUT is rejected as NW port is busy - {} ", pcelink.toString()); return false; } - pcelink.setClient(source.getXpdrClient(pcelink.getSourceTP().toString())); - this.allPceLinks.put(linkId, pcelink); + pcelink.setClient(source.getClient(pcelink.getSourceTP().toString())); + allPceLinks.put(linkId, pcelink); source.addOutgoingLink(pcelink); - LOG.info("validateLink: XPONDER-OUTPUT link added to allPceLinks {}", pcelink.toString()); + LOG.debug("validateLink: XPONDER-OUTPUT link added to allPceLinks {}", pcelink.toString()); break; default: LOG.warn("validateLink: link type is not supported {}", pcelink.toString()); + } + return true; } private boolean validateNode(Node node) { - String supNodeId = ""; - OpenroadmNodeType nodeType = null; - NodeId nodeId = null; - if (node == null) { - LOG.error("validateNode: node is null, ignored "); - return false; + LOG.debug("validateNode: node {} ", node.toString()); + + // PceNode will be used in Graph algorithm + Node1 node1 = node.augmentation(Node1.class); + if (node1 == null) { + LOG.error("getNodeType: no Node1 (type) Augmentation for node: [{}]. Node is ignored", node.getNodeId()); } - try { - // TODO: supporting IDs exist as a List. this code takes just the first element - nodeId = node.getNodeId(); - supNodeId = node.getSupportingNode().get(0).getNodeRef().getValue(); - if (supNodeId.equals("")) { - LOG.error("validateNode: Supporting node for node: [{}]. Node is ignored", nodeId.getValue()); - return false; - } - // extract node type - Node1 node1 = node.augmentation(Node1.class); - if (node1 == null) { - LOG.error("validateNode: no Node1 (type) Augmentation for node: [{}]. Node is ignored", nodeId - .getValue()); - return false; - } - nodeType = node1.getNodeType(); - /** Catch exception 'RuntimeException' is not allowed. [IllegalCatch]. */ - } catch (NullPointerException e) { - LOG.error("validateNode: Error reading supporting node or node type for node '{}'", nodeId, e); + OpenroadmNodeType nodeType = node1.getNodeType(); + + PceNode pceNode = new PceNode(node,nodeType,node.getNodeId()); + pceNode.validateAZxponder(anodeId, znodeId); + pceNode.initWLlist(); + + if (!pceNode.isValid()) { + LOG.warn(" validateNode: Node is ignored"); return false; } - if (nodeType == OpenroadmNodeType.XPONDER) { - // Detect A and Z - if (supNodeId.equals(this.anodeId) || (supNodeId.equals(this.znodeId))) { - LOG.info("validateNode: A or Z node detected == {}", node.getNodeId().getValue()); - } else { - LOG.warn("validateNode: XPONDER is ignored == {}", node.getNodeId().getValue()); - return false; - } - } - switch (validateNodeConstraints(nodeId.getValue(), supNodeId)) { + + switch (validateNodeConstraints(pceNode)) { case HARD_EXCLUDE : - LOG.info("validateNode: constraints : node is ignored == {}", nodeId.getValue()); return false; - default: + + default : break; } - PceNode pceNode = new PceNode(node, nodeType, nodeId); - if (!pceNode.isValid()) { - LOG.error(" validateNode: Node is ignored due errors in network data "); - return false; - } - if (supNodeId.equals(this.anodeId)) { - if (this.aendPceNode == null) { - if (endPceNode(nodeType, nodeId, pceNode, true)) { - if (!pceNode.isValid()) { - LOG.error("validateNode: There are no available wavelengths in node {}", nodeId.getValue()); - return false; - } - this.aendPceNode = pceNode; - } - } else { - LOG.warn("aendPceNode already gets: {}", this.aendPceNode); + + if (pceNode.getSupNodeIdPceNode().equals(this.anodeId)) { + if (this.aendPceNode != null) { + LOG.debug("aendPceNode already gets: {}", this.aendPceNode); + } else if (endPceNode(nodeType,pceNode.getNodeId(), pceNode)) { + this.aendPceNode = pceNode; } + // returning false otherwise would break E2E test } - if (supNodeId.equals(this.znodeId)) { - if (this.zendPceNode == null) { - if (endPceNode(nodeType, nodeId, pceNode, false)) { - if (!pceNode.isValid()) { - LOG.error("validateNode: There are no available wavelengths in node {}", nodeId.getValue()); - return false; - } - this.zendPceNode = pceNode; - } - } else { - LOG.warn("zendPceNode already gets: {}", this.zendPceNode); + if (pceNode.getSupNodeIdPceNode().equals(this.znodeId)) { + if (this.zendPceNode != null) { + LOG.debug("zendPceNode already gets: {}", this.zendPceNode); + } else if (endPceNode(nodeType,pceNode.getNodeId(), pceNode)) { + this.zendPceNode = pceNode; } + // returning false otherwise would break E2E test } - pceNode.initWLlist(); - if (!pceNode.isValid()) { - LOG.error("validateNode: There are no available wavelengths in node {}", nodeId.getValue()); - return false; - } - this.allPceNodes.put(nodeId, pceNode); - LOG.debug("validateNode: node is saved {}", nodeId.getValue()); + + allPceNodes.put(pceNode.getNodeId(), pceNode); + LOG.debug("validateNode: node is saved {}", pceNode.getNodeId().getValue()); return true; } - private Boolean endPceNode(OpenroadmNodeType openroadmNodeType, NodeId nodeId, PceNode pceNode, Boolean aend) { - Boolean add = true; + private ConstraintTypes validateNodeConstraints(PceNode pcenode) { + + if (pceHardConstraints.getExcludeSupNodes().isEmpty() && pceHardConstraints.getExcludeCLLI().isEmpty()) { + return ConstraintTypes.NONE; + } + + if (pceHardConstraints.getExcludeSupNodes().contains(pcenode.getSupNodeIdPceNode())) { + LOG.info("validateNodeConstraints: {}", pcenode.getNodeId().getValue()); + return ConstraintTypes.HARD_EXCLUDE; + } + if (pceHardConstraints.getExcludeCLLI().contains(pcenode.getCLLI())) { + LOG.info("validateNodeConstraints: {}", pcenode.getNodeId().getValue()); + return ConstraintTypes.HARD_EXCLUDE; + } + + return ConstraintTypes.NONE; + } + + private ConstraintTypes validateLinkConstraints(PceLink link) { + if (pceHardConstraints.getExcludeSRLG().isEmpty()) { + return ConstraintTypes.NONE; + } + + // for now SRLG is the only constraint for link + if (link.getlinkType() != OpenroadmLinkType.ROADMTOROADM) { + return ConstraintTypes.NONE; + } + + List constraints = new ArrayList(pceHardConstraints.getExcludeSRLG()); + constraints.retainAll(link.getsrlgList()); + if (!constraints.isEmpty()) { + LOG.info("validateLinkConstraints: {}", link.getLinkId().getValue()); + return ConstraintTypes.HARD_EXCLUDE; + } + + return ConstraintTypes.NONE; + } + + private void dropOppositeLink(Link link) { + LinkId opplink = MapUtils.extractOppositeLink(link); + + PceLink oppPceLink = allPceLinks.get(opplink); + if (oppPceLink != null) { + allPceLinks.remove(oppPceLink); + } else { + linksToExclude.add(opplink); + } + } + + private Boolean endPceNode(OpenroadmNodeType openroadmNodeType, NodeId nodeId, PceNode pceNode) { switch (openroadmNodeType) { case SRG : pceNode.initSrgTps(); @@ -377,35 +452,23 @@ public class PceCalculation { pceNode.initXndrTps(); break; default: - add = false; LOG.warn("endPceNode: Node {} is not SRG or XPONDER !", nodeId); - break; + return false; } - return add; - } - private NodeConstraint validateNodeConstraints(String nodeId, String supNodeId) { - if (this.pceHardConstraints.getExcludeNodes().contains(nodeId)) { - return NodeConstraint.HARD_EXCLUDE; - } - if (this.pceHardConstraints.getExcludeNodes().contains(supNodeId)) { - return NodeConstraint.HARD_EXCLUDE; - } - if (this.pceHardConstraints.getIncludeNodes().contains(nodeId)) { - return NodeConstraint.HARD_INCLUDE; - } - if (this.pceHardConstraints.getIncludeNodes().contains(supNodeId)) { - return NodeConstraint.HARD_INCLUDE; + if (!pceNode.isValid()) { + LOG.error("validateNode : there are no availaible wavelengths in node {}", pceNode.getNodeId().getValue()); + return false; } - return NodeConstraint.NONE; + return true; } - public PceNode getaPceNode() { - return this.aendPceNode; + public PceNode getaendPceNode() { + return aendPceNode; } - public PceNode getzPceNode() { - return this.zendPceNode; + public PceNode getzendPceNode() { + return zendPceNode; } public Map getAllPceNodes() { @@ -415,4 +478,25 @@ public class PceCalculation { public Map getAllPceLinks() { return this.allPceLinks; } + + public PceResult getReturnStructure() { + return returnStructure; + } + + private static void printNodesInfo(Map allpcenodes) { + Iterator> nodes = allpcenodes.entrySet().iterator(); + while (nodes.hasNext()) { + PceNode pcenode = nodes.next().getValue(); + List links = pcenode.getOutgoingLinks(); + LOG.info("In printNodes in node {} : outgoing links {} ", pcenode.getNodeId().getValue(), links.toString()); + } + } + + /*private static void printLinksInfo(Map allpcelinks) { + Iterator> links = allpcelinks.entrySet().iterator(); + while (links.hasNext()) { + LOG.info("In printLinksInfo link {} : ", links.next().getValue().toString()); + } + }*/ + }