* 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;
+
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
+
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;
/* Logging. */
private static final Logger LOG = LoggerFactory.getLogger(PceCalculation.class);
private DataBroker dataBroker = null;
-
///////////// data parsed from Input/////////////////
private PathComputationRequestInput input;
private String anodeId = "";
private String znodeId = "";
-
private PceConstraints pceHardConstraints;
private PceConstraints pceSoftConstraints;
-
///////////// Intermediate data/////////////////
private List<PceLink> addLinks = new ArrayList<PceLink>();
private List<PceLink> dropLinks = new ArrayList<PceLink>();
private HashSet<NodeId> azSrgs = new HashSet<NodeId>();
-
private PceNode aendPceNode = null;
private PceNode zendPceNode = null;
-
private List<Link> allLinks = null;
private List<Node> allNodes = null;
-
// this List serves graph calculation
private Map<NodeId, PceNode> allPceNodes = new HashMap<NodeId, PceNode>();
// this List serves calculation of ZtoA path descritopn
// TODO maybe better solution is possible
private Map<LinkId, PceLink> allPceLinks = new HashMap<LinkId, PceLink>();
-
private PceResult returnStructure;
public PceResult getReturnStructure() {
NONE, HARD_EXCLUDE, HARD_INCLUDE, HARD_DIVERSITY, SOFT_EXCLUDE, SOFT_INCLUDE, SOFT_DIVERSITY;
}
- //private static final String NETWORK_ID = "Transport Overlay";
-
- public PceCalculation(PathComputationRequestInput input, DataBroker dataBroker,
- PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc) {
+ // private static final String NETWORK_ID = "Transport Overlay";
+ public PceCalculation(PathComputationRequestInput input, DataBroker dataBroker, PceConstraints pceHardConstraints,
+ PceConstraints pceSoftConstraints, PceResult rc) {
this.input = input;
this.dataBroker = dataBroker;
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);
return;
}
-
if (!analyzeNw()) {
this.returnStructure.setRC(ResponseCodes.RESPONSE_FAILED);
return;
}
-
this.returnStructure.setRC(ResponseCodes.RESPONSE_OK);
return;
}
private boolean readMdSal() {
LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
-
InstanceIdentifier<Network> nwInstanceIdentifier = InstanceIdentifier
.builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
-
ReadOnlyTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction();
-
Network nw = null;
try {
- Optional<Network> nwOptional = readOnlyTransaction
- .read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get();
+ Optional<Network> nwOptional =
+ readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get();
if (nwOptional.isPresent()) {
nw = nwOptional.get();
LOG.debug("readMdSal: network nodes: nwOptional.isPresent = true {}", nw.toString());
throw new RuntimeException(
"readMdSal: Error reading from operational store, topology : " + nwInstanceIdentifier + " :" + e);
}
-
readOnlyTransaction.close();
-
if (nw == null) {
LOG.error("readMdSal: network is null: {}", nwInstanceIdentifier);
return false;
}
this.allNodes = nw.getNode();
Network1 nw1 = nw.augmentation(Network1.class);
-
this.allLinks = nw1.getLink();
if ((this.allNodes == null) || this.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.error("readMdSal: no links ");
return false;
}
LOG.info("readMdSal: network links: {} links added", this.allLinks.size());
-
return true;
}
private boolean analyzeNw() {
-
LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", this.allNodes.size(), this.allLinks.size());
-
for (Node node : this.allNodes) {
validateNode(node);
}
- LOG.debug("analyzeNw: allPceNodes size {}", this.allPceNodes.size());
-
+ LOG.info("analyzeNw: allPceNodes size {} : {}", this.allPceNodes.size(), this.allPceNodes.toString());
if ((this.aendPceNode == null) || (this.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) {
validateLink(link);
}
-
LOG.debug("analyzeNw: AddLinks size {}, DropLinks size {}", this.addLinks.size(), this.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());
}
// debug prints
-
for (PceLink link : this.addLinks) {
filterAddLinks(link);
}
for (PceLink link : this.dropLinks) {
filterDropLinks(link);
}
-
- LOG.info("analyzeNw: allPceNodes size {}, allPceLinks size {}", this.allPceNodes.size(),
- this.allPceLinks.size());
-
+ LOG.info("analyzeNw: allPceNodes size {}, allPceLinks size {}", this.allPceNodes.size(), this.allPceLinks
+ .size());
return true;
}
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());
return true;
}
-
// remove the SRG from PceNodes, as it is not directly connected to A/Z
this.allPceNodes.remove(nodeId);
- LOG.debug("analyzeNw: SRG removed {}", nodeId.getValue());
-
+ LOG.info("analyzeNw: SRG removed {}", nodeId.getValue());
return false;
}
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());
return true;
}
-
// remove the SRG from PceNodes, as it is not directly connected to A/Z
this.allPceNodes.remove(pcelink.getDestId());
- LOG.debug("analyzeNw: SRG removed {}", nodeId.getValue());
-
+ LOG.info("analyzeNw: SRG removed {}", nodeId.getValue());
return false;
}
private boolean validateLink(Link link) {
-
- LOG.debug("validateLink: link {} ", link.toString());
-
+ LOG.info("validateLink: link {} ", link.toString());
NodeId sourceId = link.getSource().getSourceNode();
NodeId destId = link.getDestination().getDestNode();
PceNode source = this.allPceNodes.get(sourceId);
PceNode dest = this.allPceNodes.get(destId);
-
if (source == null) {
- LOG.debug("validateLink: source node is rejected by node validation - {}",
- link.getSource().getSourceNode().getValue());
+ LOG.warn("validateLink: source node is rejected by node validation - {}", link.getSource().getSourceNode()
+ .getValue());
return false;
}
if (dest == null) {
- LOG.debug("validateLink: dest node is rejected by node validation - {}",
- link.getDestination().getDestNode().getValue());
+ LOG.warn("validateLink: dest node is rejected by node validation - {}", link.getDestination().getDestNode()
+ .getValue());
return false;
}
-
PceLink pcelink = new PceLink(link);
if (!pcelink.isValid()) {
LOG.error(" validateLink: Link is ignored due errors in network data ");
return false;
}
LinkId linkId = pcelink.getLinkId();
-
switch (pcelink.getLinkType()) {
- case ROADMTOROADM:
+ case ROADMTOROADM :
this.allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
LOG.info("validateLink: ROADMTOROADM-LINK added to allPceLinks {}", pcelink.toString());
break;
-
- case EXPRESSLINK:
+ case EXPRESSLINK :
this.allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
LOG.info("validateLink: EXPRESS-LINK added to allPceLinks {}", pcelink.toString());
break;
-
- case ADDLINK:
+ case ADDLINK :
+ pcelink.setClient(source.getRdmSrgClient(pcelink.getSourceTP().toString()));
this.addLinks.add(pcelink);
LOG.debug("validateLink: ADD-LINK saved {}", pcelink.toString());
break;
-
- case DROPLINK:
+ case DROPLINK :
+ pcelink.setClient(dest.getRdmSrgClient(pcelink.getDestTP().toString()));
this.dropLinks.add(pcelink);
- LOG.debug("validateLink: DROP-LINK saved {}", pcelink.toString());
+ LOG.info("validateLink: DROP-LINK saved {}", pcelink.toString());
break;
-
- case XPONDERINPUT:
+ case XPONDERINPUT :
this.azSrgs.add(sourceId);
// store separately all SRG links directly 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.getClient(pcelink.getDestTP().toString()));
+ pcelink.setClient(dest.getXpdrClient(pcelink.getDestTP().toString()));
this.allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
LOG.info("validateLink: XPONDER-INPUT link added to allPceLinks {}", pcelink.toString());
-
break;
-
- case XPONDEROUTPUT:
- // 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
-
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.getClient(pcelink.getSourceTP().toString()));
+ pcelink.setClient(source.getXpdrClient(pcelink.getSourceTP().toString()));
this.allPceLinks.put(linkId, pcelink);
source.addOutgoingLink(pcelink);
LOG.info("validateLink: XPONDER-OUTPUT link added to allPceLinks {}", pcelink.toString());
-
break;
-
default:
LOG.warn("validateLink: link type is not supported {}", pcelink.toString());
-
}
-
return true;
}
LOG.error("validateNode: node is null, ignored ");
return false;
}
-
try {
// TODO: supporting IDs exist as a List. this code takes just the first element
nodeId = node.getNodeId();
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());
+ 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);
+ LOG.error("validateNode: Error reading supporting node or node type for node '{}'", nodeId, e);
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.debug("validateNode: XPONDER is ignored == {}", node.getNodeId().getValue());
+ LOG.warn("validateNode: XPONDER is ignored == {}", node.getNodeId().getValue());
return false;
-
}
}
-
switch (validateNodeConstraints(nodeId.getValue(), supNodeId)) {
- case HARD_EXCLUDE:
+ case HARD_EXCLUDE :
LOG.info("validateNode: constraints : node is ignored == {}", nodeId.getValue());
return false;
-
default:
break;
}
-
PceNode pceNode = new PceNode(node, nodeType, nodeId);
- if (! pceNode.isValid()) {
+ if (!pceNode.isValid()) {
LOG.error(" validateNode: Node is ignored due errors in network data ");
return false;
}
-
if (supNodeId.equals(this.anodeId)) {
- pceNode.initXndrTps();
- if (!pceNode.isValid()) {
- LOG.error("validateNode: A doesn't have free network ports");
- return false;
+ if (endPceNode(nodeType, nodeId, pceNode)) {
+ if (!pceNode.isValid()) {
+ LOG.error("validateNode: There are no available wavelengths in node {}", nodeId.getValue());
+ return false;
+ }
+ this.aendPceNode = pceNode;
}
- this.aendPceNode = pceNode;
}
if (supNodeId.equals(this.znodeId)) {
- pceNode.initXndrTps();
- if (!pceNode.isValid()) {
- LOG.error("validateNode: Z doesn't have free network ports");
- return false;
+ if (endPceNode(nodeType, nodeId, pceNode)) {
+ if (!pceNode.isValid()) {
+ LOG.error("validateNode: There are no available wavelengths in node {}", nodeId.getValue());
+ return false;
+ }
+ this.zendPceNode = pceNode;
}
- this.zendPceNode = pceNode;
}
-
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());
+ LOG.info("validateNode: node is saved {}", nodeId.getValue());
return true;
}
- private NodeConstraint validateNodeConstraints(String nodeId, String supNodeId) {
+ private Boolean endPceNode(OpenroadmNodeType openroadmNodeType, NodeId nodeId, PceNode pceNode) {
+ Boolean add = true;
+ switch (openroadmNodeType) {
+ case SRG :
+ pceNode.initRdmSrgTps();
+ this.azSrgs.add(nodeId);
+ break;
+ case XPONDER :
+ pceNode.initXndrTps();
+ break;
+ default:
+ add = false;
+ LOG.warn("endPceNode: Node {} is not SRG or XPONDER !", nodeId);
+ break;
+ }
+ 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;
}
-
-
return NodeConstraint.NONE;
}
public Map<LinkId, PceLink> getAllPceLinks() {
return this.allPceLinks;
}
-
-
}
* 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 java.util.ArrayList;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.cp.attributes.UsedWavelengths;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmTpType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NodeId;
import org.slf4j.LoggerFactory;
public class PceNode {
-
/* Logging. */
private static final Logger LOG = LoggerFactory.getLogger(PceCalculation.class);
-
////////////////////////// NODES ///////////////////////////
/*
*/
-
private boolean valid = true;
-
private final Node node;
private final NodeId nodeId;
private final OpenroadmNodeType nodeType;
-
// wavelength calculation per node type
private List<Long> availableWLindex = new ArrayList<Long>();
+ private Set<String> availableSrgPp = new TreeSet<String>();
private List<String> usedXpndrNWTps = new ArrayList<String>();
-
+ private List<String> usedRdmCpTps = new ArrayList<String>();
private List<PceLink> outgoingLinks = new ArrayList<PceLink>();
-
private Map<String, String> clientPerNwTp = new HashMap<String, String>();
+ private Map<String, String> clientPerPpTp = new HashMap<String, String>();
public PceNode(Node node, OpenroadmNodeType nodeType, NodeId nodeId) {
this.node = node;
this.nodeId = nodeId;
this.nodeType = nodeType;
-
if ((node == null) || (nodeId == null) || (nodeType == null)) {
LOG.error("PceNode: one of parameters is not populated : nodeId, node type");
this.valid = false;
}
}
- public void initWLlist() {
+ public void initSrgPpList() {
+ this.availableSrgPp.clear();
+ if (!isValid()) {
+ return;
+ }
+ LOG.info("getting SRG-PP tps from ROADM node {}", this.nodeId);
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1 nodeTp =
+ this.node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology
+ .rev150608.Node1.class);
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
+ .TerminationPoint> allTps = nodeTp.getTerminationPoint();
+ if (allTps == null) {
+ LOG.error("initXndrTps: ROADM TerminationPoint list is empty for node {}", this.toString());
+ this.valid = false;
+ return;
+ }
+ for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
+ .TerminationPoint tp : allTps) {
+ TerminationPoint1 tp1 = tp.augmentation(TerminationPoint1.class);
+ if (tp1.getTpType() == OpenroadmTpType.SRGTXRXPP) {
+ this.availableSrgPp.add(tp.getTpId().getValue());
+ }
+ }
+ if (this.availableSrgPp.isEmpty()) {
+ LOG.error("initSrgPpList: ROADM SRG PP TerminationPoint list is empty for node {}", this.toString());
+ this.valid = false;
+ return;
+ }
+ LOG.info("initSrgPpList: availableSrgPp size = {} in {}", this.availableSrgPp.size(), this.toString());
+ return;
+ }
+ public void initWLlist() {
this.availableWLindex.clear();
-
if (!isValid()) {
return;
}
-
Node1 node1 = this.node.augmentation(Node1.class);
-
switch (this.nodeType) {
- case SRG:
+ case SRG :
List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes
.AvailableWavelengths> srgAvailableWL = node1.getSrgAttributes().getAvailableWavelengths();
-
if (srgAvailableWL == null) {
this.valid = false;
LOG.error("initWLlist: SRG AvailableWavelengths is empty for node {}", this.toString());
return;
}
-
for (org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes
- .AvailableWavelengths awl : srgAvailableWL) {
+ .AvailableWavelengths awl : srgAvailableWL) {
this.availableWLindex.add(awl.getIndex());
- LOG.debug("initWLlist: SRG next = {} in {}" , awl.getIndex() , this.toString());
+ LOG.debug("initWLlist: SRG next = {} in {}", awl.getIndex(), this.toString());
}
-
break;
-
- case DEGREE:
+ case DEGREE :
List<org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes
- .AvailableWavelengths> degAvailableWL = node1.getDegreeAttributes().getAvailableWavelengths();
-
+ .AvailableWavelengths> degAvailableWL =
+ node1.getDegreeAttributes().getAvailableWavelengths();
if (degAvailableWL == null) {
this.valid = false;
LOG.error("initWLlist: DEG AvailableWavelengths is empty for node {}", this.toString());
return;
}
-
for (org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes
- .AvailableWavelengths awl : degAvailableWL) {
+ .AvailableWavelengths awl : degAvailableWL) {
this.availableWLindex.add(awl.getIndex());
LOG.debug("initWLlist: DEGREE next = {} in {}", awl.getIndex(), this.toString());
}
-
break;
-
- case XPONDER:
-
+ case XPONDER :
// HARD CODED 96
for (long i = 1; i <= 96; i++) {
this.availableWLindex.add(i);
}
-
break;
-
default:
- LOG.error("initWLlist: unsupported node type {} in node {}" , this.nodeType, this.toString());
+ LOG.error("initWLlist: unsupported node type {} in node {}", this.nodeType, this.toString());
break;
}
-
if (this.availableWLindex.size() == 0) {
LOG.debug("initWLlist: There are no available wavelengths in node {}", this.toString());
this.valid = false;
}
- LOG.debug("initWLlist: availableWLindex size = {} in {}" , this.availableWLindex.size(), this.toString());
-
+ LOG.debug("initWLlist: availableWLindex size = {} in {}", this.availableWLindex.size(), this.toString());
return;
}
public void initXndrTps() {
-
+ LOG.info("initXndrTps for node : {}", this.nodeId);
if (!isValid()) {
return;
}
-
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1 nodeTp =
- this.node.augmentation(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1.class);
-
+ this.node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology
+ .rev150608.Node1.class);
List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
.TerminationPoint> allTps = nodeTp.getTerminationPoint();
-
if (allTps == null) {
this.valid = false;
LOG.error("initXndrTps: XPONDER TerminationPoint list is empty for node {}", this.toString());
return;
}
-
this.valid = false;
-
for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
- .TerminationPoint tp : allTps) {
-
+ .TerminationPoint tp : allTps) {
TerminationPoint1 tp1 = tp.augmentation(TerminationPoint1.class);
-
if (tp1.getTpType() == OpenroadmTpType.XPONDERNETWORK) {
-
if (tp1.getXpdrNetworkAttributes().getWavelength() != null) {
this.usedXpndrNWTps.add(tp.getTpId().getValue());
- LOG.debug("initWLlist: XPONDER tp = {} is used", tp.getTpId().getValue());
+ LOG.debug("initXndrTps: XPONDER tp = {} is used", tp.getTpId().getValue());
} else {
this.valid = true;
}
-
// find Client of this network TP
String client = tp1.getXpdrNetworkAttributes().getTailEquipmentId();
if ((client.equals("")) || (client == null)) {
- LOG.error("initXndrTps: XPONDER {} NW TP doesn't have defined Client {}",
- this.toString(),tp.getTpId().getValue());
+ LOG.error("initXndrTps: XPONDER {} NW TP doesn't have defined Client {}", this.toString(), tp
+ .getTpId().getValue());
this.valid = false;
}
this.clientPerNwTp.put(tp.getTpId().getValue(), client);
-
}
}
if (!isValid()) {
LOG.error("initXndrTps: XPONDER doesn't have available wavelengths for node {}", this.toString());
return;
}
+ }
+ public void initRdmSrgTps() {
+ LOG.info("initRdmSrgTps for node : {}", this.nodeId);
+ initSrgPpList();
+ if (!isValid()) {
+ return;
+ }
+ LOG.info("initRdmSrgTps: getting terminationPoint list for node {}", this.toString());
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1 nodeTp =
+ this.node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology
+ .rev150608.Node1.class);
+ List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
+ .TerminationPoint> allTps = nodeTp.getTerminationPoint();
+ if (allTps == null) {
+ this.valid = false;
+ LOG.error("initRdmSrgTps: SRG TerminationPoint list is empty for node {}", this.toString());
+ return;
+ }
+ this.valid = false;
+ for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node
+ .TerminationPoint tp : allTps) {
+ TerminationPoint1 tp1 = tp.augmentation(TerminationPoint1.class);
+ if (tp1.getTpType() == OpenroadmTpType.SRGTXRXCP) {
+ try {
+ List<UsedWavelengths> usedWavelengths = tp1.getCpAttributes().getUsedWavelengths();
+ if (!usedWavelengths.isEmpty()) {
+ this.usedRdmCpTps.add(tp.getTpId().getValue());
+ LOG.warn("initRdmSrgTps: SRG-CP tp = {} is used", tp.getTpId().getValue());
+ } else {
+ LOG.info("initRdmSrgTps: SRG-CP tp = {} found", tp.getTpId().getValue());
+ this.valid = true;
+ }
+ } catch (NullPointerException e) {
+ LOG.warn("'usedWavelengths' for tp={} is null !", tp.getTpId().getValue());
+ this.valid = true;
+ }
+ }
+ if (tp1.getTpType() == OpenroadmTpType.SRGTXRXCP) {
+ // Find an available PP of this CP
+ if (!this.availableSrgPp.isEmpty()) {
+ LOG.info("finding PP for CP {}", tp.getTpId().getValue());
+ Iterator<String> iterator = this.availableSrgPp.iterator();
+ while (iterator.hasNext()) {
+ String client = iterator.next();
+ if ((client.equals("")) || (client == null)) {
+ LOG.error("initRdmSrgTps: ROADM {} doesn't have defined Client {}", this.toString(), tp
+ .getTpId().getValue());
+ this.valid = false;
+ } else {
+ this.valid = true;
+ this.clientPerPpTp.put(tp.getTpId().getValue(), client);
+ LOG.info("initRdmSrgTps: client PP {} for CP {} found !", client, tp.getTpId().getValue());
+ iterator.remove();
+ break;
+ }
+ }
+ } else {
+ LOG.error("initRdmSrgTps: ROADM {} doesn't have available PP", this.nodeId.getValue());
+ this.valid = false;
+ return;
+ }
+ }
+ }
+ if (!isValid()) {
+ LOG.error("initRdmSrgTps: SRG doesn't have available wavelengths for node {}", this.toString());
+ return;
+ }
+ }
+ public void initNodeTps() {
+ if (!isValid()) {
+ return;
+ }
+ switch (this.nodeType) {
+ case SRG :
+ initSrgPpList();
+ initRdmSrgTps();
+ break;
+ case XPONDER :
+ initXndrTps();
+ break;
+ default:
+ this.valid = true;
+ LOG.warn("initNodeTps: Node TerminationPoints list is not SRG or XPONDER or DEGREE!");
+ break;
+ }
}
public boolean checkTP(String tp) {
return this.outgoingLinks;
}
- public String getClient(String tp) {
+ public String getXpdrClient(String tp) {
return this.clientPerNwTp.get(tp);
}
+ public String getRdmSrgClient(String tp) {
+ LOG.info("Getting ROADM Client PP for CP {}", tp, this.clientPerPpTp.get(tp));
+ return this.clientPerPpTp.get(tp);
+ }
+
@Override
public String toString() {
return "PceNode type=" + this.nodeType + " ID=" + this.nodeId.getValue();
}
-
}
Code Review / transportpce.git / commitdiff