import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.HashSet;
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.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.service.ServiceTypes;
import org.opendaylight.transportpce.pce.PceComplianceCheck;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220118.PathComputationRequestInput;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220114.mc.capabilities.McCapabilities;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1;
-//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.opendaylight.transportpce.pce.rev220808.PathComputationRequestInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.path.computation.reroute.request.input.Endpoints;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.mc.capabilities.McCapabilities;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Link1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
-//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.http.org.openroadm.network.types.rev230526.OpenroadmLinkType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.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;
public class PceCalculation {
/* Logging. */
private static final Logger LOG = LoggerFactory.getLogger(PceCalculation.class);
- private NetworkTransactionService networkTransactionService = null;
+ private NetworkTransactionService networkTransactionService;
///////////// data parsed from Input/////////////////
private PathComputationRequestInput input;
///////////// Intermediate data/////////////////
private List<PceLink> addLinks = new ArrayList<>();
private List<PceLink> dropLinks = new ArrayList<>();
- private HashSet<NodeId> azSrgs = new HashSet<>();
+ private List<NodeId> azSrgs = new ArrayList<>();
private PceNode aendPceNode = null;
private PceNode zendPceNode = null;
// this List serves calculation of ZtoA path description
// TODO maybe better solution is possible
private Map<LinkId, PceLink> allPceLinks = new HashMap<>();
- private Set<LinkId> linksToExclude = new HashSet<>();
+ private List<LinkId> linksToExclude = new ArrayList<>();
private PceResult returnStructure;
private PortMapping portMapping;
+ // Define the termination points whose reservation status is not taken into account during the pruning process
+ private Endpoints endpoints;
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,
- PortMapping portMapping) {
+ 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;
+ this.endpoints = null;
+ parseInput();
+ }
+ public PceCalculation(PathComputationRequestInput input, NetworkTransactionService networkTransactionService,
+ PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc,
+ PortMapping portMapping, Endpoints endpoints) {
+ this.input = input;
+ this.networkTransactionService = networkTransactionService;
+ this.returnStructure = rc;
this.pceHardConstraints = pceHardConstraints;
this.mappingUtils = new MappingUtilsImpl(networkTransactionService.getDataBroker());
this.portMapping = portMapping;
+ this.endpoints = endpoints;
parseInput();
}
public void retrievePceNetwork() {
- LOG.info("In PceCalculation retrieveNetwork: ");
+ LOG.debug("In PceCalculation retrieveNetwork");
if (!readMdSal()) {
returnStructure.setRC(ResponseCodes.RESPONSE_FAILED);
printNodesInfo(allPceNodes);
returnStructure.setRC(ResponseCodes.RESPONSE_OK);
- return;
}
private boolean parseInput() {
input.getServiceAEnd().getTxDirection().getPort().getPortName())
: null);
- LOG.info("parseInput: A and Z :[{}] and [{}]", anodeId, znodeId);
+ LOG.debug("parseInput: A and Z :[{}] and [{}]", anodeId, znodeId);
getAZnodeId();
case StringConstants.SERVICE_TYPE_OTUC2:
case StringConstants.SERVICE_TYPE_OTUC3:
case StringConstants.SERVICE_TYPE_OTUC4:
- LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
+ LOG.debug("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
break;
case StringConstants.SERVICE_TYPE_ODUC4:
case StringConstants.SERVICE_TYPE_10GE:
case StringConstants.SERVICE_TYPE_1GE:
- LOG.info("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
+ LOG.debug("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID))).build();
break;
Optional<Network> nwOptional =
networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get();
if (nwOptional.isPresent()) {
- nw = nwOptional.get();
+ nw = nwOptional.orElseThrow();
LOG.debug("readMdSal: network nodes: nwOptional.isPresent = true {}", nw);
- networkTransactionService.close();
}
} catch (InterruptedException | ExecutionException e) {
LOG.error("readMdSal: Error reading topology {}", nwInstanceIdentifier);
- networkTransactionService.close();
returnStructure.setRC(ResponseCodes.RESPONSE_FAILED);
- throw new RuntimeException(
- "readMdSal: Error reading from operational store, topology : " + nwInstanceIdentifier + " :" + e);
}
return nw;
}
}
private boolean validateLink(Link link) {
- LOG.info("validateLink: link {} ", link);
+ LOG.debug("validateLink: link {} ", link);
NodeId sourceId = link.getSource().getSourceNode();
NodeId destId = link.getDestination().getDestNode();
}
private void validateNode(Node node) {
- LOG.info("validateNode: node {} ", node);
+ LOG.debug("validateNode: node {} ", node);
// PceNode will be used in Graph algorithm
Node1 node1 = node.augmentation(Node1.class);
if (node1 == null) {
deviceNodeId = node.getNodeId().getValue();
}
- LOG.info("Device node id {} for {}", deviceNodeId, node);
+ LOG.debug("Device node id {} for {}", deviceNodeId, node);
PceOpticalNode pceNode = new PceOpticalNode(deviceNodeId, this.serviceType, portMapping, node, nodeType,
mappingUtils.getOpenRoadmVersion(deviceNodeId), getSlotWidthGranularity(deviceNodeId, node.getNodeId()),
getCentralFreqGranularity(deviceNodeId, node.getNodeId()));
+ if (endpoints != null) {
+ pceNode.setEndpoints(endpoints);
+ }
pceNode.validateAZxponder(anodeId, znodeId, input.getServiceAEnd().getServiceFormat());
pceNode.initFrequenciesBitSet();
if (!pceNode.isValid()) {
- LOG.warn(" validateNode: Node is ignored");
+ LOG.debug(" validateNode: Node {} is ignored", node.getNodeId().getValue());
return;
}
if (validateNodeConstraints(pceNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
List<Link> links = this.allLinks.stream()
.filter(x -> x.getSource().getSourceNode().getValue().contains(pceNode.getNodeId().getValue()))
.collect(Collectors.toList());
- if (links.size() > 0) {
+ if (!links.isEmpty()) {
this.aendPceNode = pceNode;
}
}
List<Link> links = this.allLinks.stream()
.filter(x -> x.getDestination().getDestNode().getValue().contains(pceNode.getNodeId().getValue()))
.collect(Collectors.toList());
- if (links.size() > 0) {
+ if (!links.isEmpty()) {
this.zendPceNode = pceNode;
}
}
allPceNodes.put(pceNode.getNodeId(), pceNode);
LOG.debug("validateNode: node is saved {}", pceNode.getNodeId().getValue());
- return;
}
@SuppressWarnings("fallthrough")
}
allPceNodes.put(pceOtnNode.getNodeId(), pceOtnNode);
LOG.info("validateOtnNode: node {} is saved", node.getNodeId().getValue());
- return;
}
private ConstraintTypes validateNodeConstraints(PceNode pcenode) {
return ConstraintTypes.NONE;
}
if (pceHardConstraints.getExcludeSupNodes().contains(pcenode.getSupNetworkNodeId())) {
- LOG.info("validateNodeConstraints: {}", pcenode.getNodeId().getValue());
+ LOG.debug("validateNodeConstraints: {}", pcenode.getNodeId().getValue());
return ConstraintTypes.HARD_EXCLUDE;
}
if (pceHardConstraints.getExcludeCLLI().contains(pcenode.getSupClliNodeId())) {
- LOG.info("validateNodeConstraints: {}", pcenode.getNodeId().getValue());
+ LOG.debug("validateNodeConstraints: {}", pcenode.getNodeId().getValue());
return ConstraintTypes.HARD_EXCLUDE;
}
return ConstraintTypes.NONE;
List<Long> constraints = new ArrayList<>(pceHardConstraints.getExcludeSRLG());
constraints.retainAll(link.getsrlgList());
if (!constraints.isEmpty()) {
- LOG.info("validateLinkConstraints: {}", link.getLinkId().getValue());
+ LOG.debug("validateLinkConstraints: {}", link.getLinkId().getValue());
return ConstraintTypes.HARD_EXCLUDE;
}
pceNode.initXndrTps(input.getServiceAEnd().getServiceFormat());
break;
default:
- LOG.warn("endPceNode: Node {} is not SRG or XPONDER !", nodeId);
+ LOG.debug("endPceNode: Node {} is not SRG or XPONDER !", nodeId);
return false;
}
pcelink.getlinkType(), pcelink);
break;
case ADDLINK:
- pcelink.setClient(
+ pcelink.setClientA(
source.getRdmSrgClient(pcelink.getSourceTP().getValue(), StringConstants.SERVICE_DIRECTION_AZ));
addLinks.add(pcelink);
LOG.debug("validateLink: ADD-LINK saved {}", pcelink);
break;
case DROPLINK:
- pcelink.setClient(
+ pcelink.setClientZ(
dest.getRdmSrgClient(pcelink.getDestTP().getValue(), StringConstants.SERVICE_DIRECTION_ZA));
dropLinks.add(pcelink);
LOG.debug("validateLink: DROP-LINK saved {}", pcelink);
return false;
}
if (dest.getXpdrClient(pcelink.getDestTP().getValue()) != null) {
- pcelink.setClient(dest.getXpdrClient(pcelink.getDestTP().getValue()));
+ pcelink.setClientZ(dest.getXpdrClient(pcelink.getDestTP().getValue()));
}
allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
return false;
}
if (source.getXpdrClient(pcelink.getSourceTP().getValue()) != null) {
- pcelink.setClient(source.getXpdrClient(pcelink.getSourceTP().getValue()));
+ pcelink.setClientA(source.getXpdrClient(pcelink.getSourceTP().getValue()));
}
allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
switch (pceOtnLink.getlinkType()) {
case OTNLINK:
if (source.getXpdrClient(pceOtnLink.getSourceTP().getValue()) != null) {
- pceOtnLink.setClient(source.getXpdrClient(pceOtnLink.getSourceTP().getValue()));
+ pceOtnLink.setClientA(source.getXpdrClient(pceOtnLink.getSourceTP().getValue()));
}
if (dest.getXpdrClient(pceOtnLink.getDestTP().getValue()) != null) {
- pceOtnLink.setClient(dest.getXpdrClient(pceOtnLink.getDestTP().getValue()));
+ pceOtnLink.setClientZ(dest.getXpdrClient(pceOtnLink.getDestTP().getValue()));
}
allPceLinks.put(linkId, pceOtnLink);
source.addOutgoingLink(pceOtnLink);
- LOG.info("validateLink: OTN-LINK added to allPceLinks {}", pceOtnLink);
+ LOG.debug("validateLink: OTN-LINK added to allPceLinks {}", pceOtnLink);
break;
default:
LOG.warn("validateLink: link type is not supported {}", pceOtnLink);
private static void printNodesInfo(Map<NodeId, PceNode> allPceNodes) {
allPceNodes.forEach(((nodeId, pceNode) -> {
- LOG.info("In printNodes in node {} : outgoing links {} ", pceNode.getNodeId().getValue(),
+ LOG.debug("In printNodes in node {} : outgoing links {} ", pceNode.getNodeId().getValue(),
pceNode.getOutgoingLinks());
}));
}
for (McCapabilities mcCapabitility : mcCapabilities) {
if (mcCapabitility.getMcNodeName().contains("XPDR")
&& mcCapabitility.getSlotWidthGranularity() != null) {
- return mcCapabitility.getSlotWidthGranularity().getValue();
+ return mcCapabitility.getSlotWidthGranularity().getValue().decimalValue();
}
if (mcCapabitility.getMcNodeName().contains(moduleName)
&& mcCapabitility.getSlotWidthGranularity() != null) {
- return mcCapabitility.getSlotWidthGranularity().getValue();
+ return mcCapabitility.getSlotWidthGranularity().getValue().decimalValue();
}
}
return GridConstant.SLOT_WIDTH_50;
for (McCapabilities mcCapabitility : mcCapabilities) {
if (mcCapabitility.getMcNodeName().contains("XPDR")
&& mcCapabitility.getCenterFreqGranularity() != null) {
- return mcCapabitility.getCenterFreqGranularity().getValue();
+ return mcCapabitility.getCenterFreqGranularity().getValue().decimalValue();
}
if (mcCapabitility.getMcNodeName().contains(moduleName)
&& mcCapabitility.getCenterFreqGranularity() != null) {
- return mcCapabitility.getCenterFreqGranularity().getValue();
+ return mcCapabitility.getCenterFreqGranularity().getValue().decimalValue();
}
}
return GridConstant.SLOT_WIDTH_50;