import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.ResponseCodes;
+import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.common.mapping.MappingUtils;
+import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
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.rev200128.PathComputationRequestInput;
-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.http.org.openroadm.common.network.rev200529.Node1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.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;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-//import org.opendaylight.yangtools.yang.common.Decimal64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
NONE, HARD_EXCLUDE, HARD_INCLUDE, HARD_DIVERSITY, SOFT_EXCLUDE, SOFT_INCLUDE, SOFT_DIVERSITY;
}
+ private MappingUtils mappingUtils;
+
public PceCalculation(PathComputationRequestInput input, NetworkTransactionService networkTransactionService,
PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc) {
this.input = input;
this.returnStructure = rc;
this.pceHardConstraints = pceHardConstraints;
+ this.mappingUtils = new MappingUtilsImpl(networkTransactionService.getDataBroker());
parseInput();
}
}
private boolean parseInput() {
- anodeId = input.getServiceAEnd().getNodeId();
- znodeId = input.getServiceZEnd().getNodeId();
if (input.getServiceAEnd().getServiceFormat() == null || input.getServiceZEnd().getServiceFormat() == null
|| input.getServiceAEnd().getServiceRate() == null) {
LOG.error("Service Format and Service Rate are required for a path calculation");
switch (serviceFormatA) {
case "Ethernet":
case "OC":
- serviceType = "100GE";
+ serviceType = StringConstants.SERVICE_TYPE_100GE;
break;
case "OTU":
- serviceType = "OTU4";
+ serviceType = StringConstants.SERVICE_TYPE_OTU4;
break;
case "ODU":
- serviceType = "ODU4";
+ serviceType = StringConstants.SERVICE_TYPE_ODU4;
break;
default:
LOG.debug("parseInput: unsupported service type: Format {} Rate 100L", serviceFormatA);
} else if ("Ethernet".equals(serviceFormatA)) {
//only rate 100L is currently supported except in Ethernet
if (serviceRate == 10L) {
- serviceType = "10GE";
+ serviceType = StringConstants.SERVICE_TYPE_10GE;
} else if (serviceRate == 1L) {
- serviceType = "1GE";
+ serviceType = StringConstants.SERVICE_TYPE_1GE;
} else {
LOG.debug("parseInput: unsupported service type: Format Ethernet Rate {}", serviceRate);
}
LOG.debug("parseInput: unsupported service type: Format {} Rate {}",
serviceFormatA, serviceRate);
}
+ if (StringConstants.SERVICE_TYPE_ODU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_10GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_1GE.equals(serviceType)) {
+ anodeId = input.getServiceAEnd().getTxDirection().getPort().getPortDeviceName();
+ znodeId = input.getServiceZEnd().getTxDirection().getPort().getPortDeviceName();
+ } else {
+ anodeId = input.getServiceAEnd().getNodeId();
+ znodeId = input.getServiceZEnd().getNodeId();
+ }
returnStructure.setRate(input.getServiceAEnd().getServiceRate().toJava());
returnStructure.setServiceFormat(input.getServiceAEnd().getServiceFormat());
LOG.error("readMdSal: network is null: {}", nwInstanceIdentifier);
return false;
}
- allNodes = nw.getNode().stream().sorted((n1, n2) -> n1.getNodeId().getValue().compareTo(n2.getNodeId()
- .getValue())).collect(Collectors.toList());
+ allNodes = nw.nonnullNode().values().stream().sorted((n1, n2)
+ -> n1.getNodeId().getValue().compareTo(n2.getNodeId().getValue())).collect(Collectors.toList());
Network1 nw1 = nw.augmentation(Network1.class);
if (nw1 != null) {
- allLinks = nw1.getLink().stream().sorted((l1, l2) -> l1.getSource().getSourceTp().toString().compareTo(l2
- .getSource().getSourceTp().toString())).collect(Collectors.toList());
+ allLinks = nw1.nonnullLink().values().stream().sorted((l1, l2)
+ -> l1.getSource().getSourceTp().toString().compareTo(l2.getSource().getSourceTp().toString()))
+ .collect(Collectors.toList());
} else {
LOG.warn("no otn links in otn-topology");
}
LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", allNodes.size(), allLinks.size());
- if (("100GE".equals(serviceType)) || ("OTU4".equals(serviceType))) {
+ if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
+ || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
// 100GE service and OTU4 service are handled at the openroadm-topology layer
for (Node node : allNodes) {
validateNode(node);
return false;
}
- if (("100GE".equals(serviceType)) || ("OTU4".equals(serviceType))) {
+ if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
+ || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
// 100GE or OTU4 services are handled at WDM Layer
PceLink pcelink = new PceLink(link, source, dest);
if (!pcelink.isValid()) {
}
return true;
- } else if (("ODU4".equals(serviceType)) || ("10GE".equals(serviceType)) || ("1GE".equals(serviceType))) {
+ } else if ((StringConstants.SERVICE_TYPE_ODU4.equals(serviceType))
+ || (StringConstants.SERVICE_TYPE_10GE.equals(serviceType))
+ || (StringConstants.SERVICE_TYPE_1GE.equals(serviceType))) {
// ODU4, 1GE and 10GE services relying on ODU2, ODU2e or ODU0 services are handled at OTN layer
PceLink pceOtnLink = new PceLink(link, source, dest);
private boolean validateNode(Node node) {
LOG.debug("validateNode: node {} ", node);
-
// PceNode will be used in Graph algorithm
Node1 node1 = node.augmentation(Node1.class);
if (node1 == null) {
return false;
}
OpenroadmNodeType nodeType = node1.getNodeType();
-
- PceOpticalNode pceNode = new PceOpticalNode(node, nodeType, node.getNodeId(),
- input.getServiceAEnd().getServiceFormat(), "optical");
- pceNode.validateAZxponder(anodeId, znodeId);
+ String deviceNodeId = MapUtils.getSupNetworkNode(node);
+ // Should never happen but because of existing topology test files
+ // we have to manage this case
+ if (deviceNodeId == null || deviceNodeId.isBlank()) {
+ deviceNodeId = node.getNodeId().getValue();
+ }
+ LOG.info("Device node id {} for {}", deviceNodeId, node);
+ PceOpticalNode pceNode = new PceOpticalNode(node, nodeType, mappingUtils.getOpenRoadmVersion(deviceNodeId));
+ pceNode.validateAZxponder(anodeId, znodeId, input.getServiceAEnd().getServiceFormat());
pceNode.initWLlist();
if (!pceNode.isValid()) {
LOG.warn(" validateNode: Node is ignored");
return false;
}
-
if (validateNodeConstraints(pceNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
return false;
}
- if ((pceNode.getSupNetworkNodeId().equals(anodeId) && (this.aendPceNode == null))
- && (Boolean.TRUE.equals(endPceNode(nodeType, pceNode.getNodeId(), pceNode)))) {
+ if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.aendPceNode == null
+ && isAZendPceNode(this.serviceFormatA, pceNode, anodeId, "A")) {
this.aendPceNode = pceNode;
}
- if ((pceNode.getSupNetworkNodeId().equals(znodeId) && (this.zendPceNode == null))
- && (Boolean.TRUE.equals(endPceNode(nodeType, pceNode.getNodeId(), pceNode)))) {
+ if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.zendPceNode == null
+ && isAZendPceNode(this.serviceFormatZ, pceNode, znodeId, "Z")) {
this.zendPceNode = pceNode;
}
return true;
}
- private boolean validateOtnNode(Node node) {
+ private boolean isAZendPceNode(String serviceFormat, PceOpticalNode pceNode, String azNodeId, String azEndPoint) {
+ switch (serviceFormat) {
+ case "Ethernet":
+ case "OC":
+ if (pceNode.getSupNetworkNodeId().equals(azNodeId)) {
+ return true;
+ }
+ return false;
+ case "OTU":
+ if ("A".equals(azEndPoint) && pceNode.getNodeId().getValue()
+ .equals(this.input.getServiceAEnd().getRxDirection().getPort().getPortDeviceName())) {
+ return true;
+ }
+ if ("Z".equals(azEndPoint) && pceNode.getNodeId().getValue()
+ .equals(this.input.getServiceZEnd().getRxDirection().getPort().getPortDeviceName())) {
+ return true;
+ }
+ return false;
+ default:
+ LOG.debug("Unsupported service Format {} for node {}", serviceFormat, pceNode.getNodeId().getValue());
+ return false;
+ }
+ }
+ private boolean validateOtnNode(Node node) {
LOG.info("validateOtnNode: {} ", node.getNodeId().getValue());
// PceOtnNode will be used in Graph algorithm
if (node.augmentation(Node1.class) != null) {
LOG.error("ValidateOtnNode: no node-type augmentation. Node {} is ignored", node.getNodeId().getValue());
return false;
}
-
-// if (mode == "AZ") {
-// pceOtnNode.validateAZxponder(anodeId, znodeId);
-// } else if (mode == "intermediate") {
-// pceOtnNode.validateIntermediateSwitch();
-// } else {
-// LOG.error("validateOtnNode: unproper mode passed to the method : {} not supported", mode);
-// return null;
-// }
}
private ConstraintTypes validateNodeConstraints(PceNode pcenode) {
this.azSrgs.add(nodeId);
break;
case XPONDER:
- pceNode.initXndrTps();
+ pceNode.initXndrTps(input.getServiceAEnd().getServiceFormat());
break;
default:
LOG.warn("endPceNode: Node {} is not SRG or XPONDER !", nodeId);
Code Review / transportpce.git / blobdiff