package org.opendaylight.transportpce.pce.networkanalyzer;
+import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.common.fixedflex.GridConstant;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
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.opendaylight.transportpce.portmapping.rev210315.mc.capabilities.McCapabilities;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
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;
private Map<LinkId, PceLink> allPceLinks = new HashMap<>();
private Set<LinkId> linksToExclude = new HashSet<>();
private PceResult returnStructure;
+ private PortMapping portMapping;
private enum ConstraintTypes {
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) {
+ PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc,
+ PortMapping portMapping) {
this.input = input;
this.networkTransactionService = networkTransactionService;
this.returnStructure = rc;
this.pceHardConstraints = pceHardConstraints;
this.mappingUtils = new MappingUtilsImpl(networkTransactionService.getDataBroker());
+ this.portMapping = portMapping;
parseInput();
}
//Maybe HashMap and similar options should also be considered here.
} else if ("Ethernet".equals(serviceFormatA)) {
//only rate 100L is currently supported except in Ethernet
- if (serviceRate == 10L) {
+ if (serviceRate == 400L) {
+ serviceType = StringConstants.SERVICE_TYPE_400GE;
+ } else if (serviceRate == 10L) {
serviceType = StringConstants.SERVICE_TYPE_10GE;
} else if (serviceRate == 1L) {
serviceType = StringConstants.SERVICE_TYPE_1GE;
private boolean readMdSal() {
InstanceIdentifier<Network> nwInstanceIdentifier = null;
Network nw = null;
- if (("OC".equals(serviceFormatA)) || ("OTU".equals(serviceFormatA)) || (("Ethernet".equals(serviceFormatA))
- && (serviceRate == 100L))) {
-
+ if (("OC".equals(serviceFormatA)) || ("OTU".equals(serviceFormatA))
+ || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 100L) || (serviceRate == 400L)))) {
LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
- } else if ("ODU".equals(serviceFormatA) || ("Ethernet".equals(serviceFormatA) && serviceRate == 10L)
- || ("Ethernet".equals(serviceFormatA) && serviceRate == 1L)) {
+ } else if ("ODU".equals(serviceFormatA)
+ || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 10L) || (serviceRate == 1L)))) {
LOG.info("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID))).build();
LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", allNodes.size(), allLinks.size());
- if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
+ if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
// 100GE service and OTU4 service are handled at the openroadm-topology layer
for (Node node : allNodes) {
validateNode(node);
NodeId destId = link.getDestination().getDestNode();
PceNode source = allPceNodes.get(sourceId);
PceNode dest = allPceNodes.get(destId);
+ State state = link.augmentation(Link1.class).getOperationalState();
if (source == null) {
LOG.debug("validateLink: Link is ignored due source node is rejected by node validation - {}",
return false;
}
- if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
- // 100GE or OTU4 services are handled at WDM Layer
+ if (State.OutOfService.equals(state)) {
+ LOG.debug("validateLink: Link is ignored due operational state - {}",
+ state.getName());
+ return false;
+ }
+
+ if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
+ // 100GE or 400GE or OTU4 services are handled at WDM Layer
PceLink pcelink = new PceLink(link, source, dest);
if (!pcelink.isValid()) {
dropOppositeLink(link);
}
- private boolean validateNode(Node node) {
+ private void validateNode(Node node) {
LOG.debug("validateNode: node {} ", node);
// 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());
- return false;
+ return;
+ }
+ if (State.OutOfService.equals(node1.getOperationalState())) {
+ LOG.error("getNodeType: node is ignored due to operational state - {}", node1.getOperationalState()
+ .getName());
+ return;
}
OpenroadmNodeType nodeType = node1.getNodeType();
String deviceNodeId = MapUtils.getSupNetworkNode(node);
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));
+ PceOpticalNode pceNode = new PceOpticalNode(deviceNodeId, this.serviceType, portMapping, node, nodeType,
+ mappingUtils.getOpenRoadmVersion(deviceNodeId), getSlotWidthGranularity(deviceNodeId, node.getNodeId()));
pceNode.validateAZxponder(anodeId, znodeId, input.getServiceAEnd().getServiceFormat());
pceNode.initFrequenciesBitSet();
if (!pceNode.isValid()) {
LOG.warn(" validateNode: Node is ignored");
- return false;
+ return;
}
if (validateNodeConstraints(pceNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
- return false;
+ return;
}
if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.aendPceNode == null
&& isAZendPceNode(this.serviceFormatA, pceNode, anodeId, "A")) {
allPceNodes.put(pceNode.getNodeId(), pceNode);
LOG.debug("validateNode: node is saved {}", pceNode.getNodeId().getValue());
- return true;
+ return;
}
private boolean isAZendPceNode(String serviceFormat, PceOpticalNode pceNode, String azNodeId, String azEndPoint) {
}
}
- private boolean validateOtnNode(Node node) {
+ private void validateOtnNode(Node node) {
LOG.info("validateOtnNode: {} ", node.getNodeId().getValue());
// PceOtnNode will be used in Graph algorithm
if (node.augmentation(Node1.class) != null) {
if (!pceOtnNode.isValid()) {
LOG.warn(" validateOtnNode: Node {} is ignored", node.getNodeId().getValue());
- return false;
+ return;
}
if (validateNodeConstraints(pceOtnNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
- return false;
+ return;
}
if (pceOtnNode.getNodeId().getValue().equals(anodeId) && this.aendPceNode == null) {
this.aendPceNode = pceOtnNode;
}
allPceNodes.put(pceOtnNode.getNodeId(), pceOtnNode);
LOG.info("validateOtnNode: node {} is saved", node.getNodeId().getValue());
- return true;
+ return;
} else {
LOG.error("ValidateOtnNode: no node-type augmentation. Node {} is ignored", node.getNodeId().getValue());
- return false;
+ return;
}
}
}
if (!pceNode.isValid()) {
- LOG.error("validateNode : there are no availaible wavelengths in node {}", pceNode.getNodeId().getValue());
+ LOG.error("validateNode : there are no available frequencies in node {}", pceNode.getNodeId().getValue());
return false;
}
return true;
pceNode.getOutgoingLinks());
}));
}
+
+ /**
+ * Get mc capability slot width granularity for device.
+ * @param deviceNodeId String
+ * @param nodeId NodeId
+ * @return slot width granularity
+ */
+ private BigDecimal getSlotWidthGranularity(String deviceNodeId, NodeId nodeId) {
+ // nodeId: openroadm-topology level node
+ // deviceNodeId: openroadm-network level node
+ List<McCapabilities> mcCapabilities = mappingUtils.getMcCapabilitiesForNode(deviceNodeId);
+ String[] params = nodeId.getValue().split("-");
+ // DEGX or SRGX
+ String rdmModuleName = params[params.length - 1];
+ for (McCapabilities mcCapabitility : mcCapabilities) {
+ if (mcCapabitility.getMcNodeName().contains(rdmModuleName)
+ && mcCapabitility.getSlotWidthGranularity() != null) {
+ return mcCapabitility.getSlotWidthGranularity().getValue();
+ }
+ }
+ return GridConstant.SLOT_WIDTH_50;
+ }
}