pce/src/main/java/org/opendaylight/transportpce/pce/networkanalyzer/PceOtnNode.java

   1 /*
   2  * Copyright © 2019 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.pce.networkanalyzer;
  10
  11 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  12 import java.math.BigDecimal;
  13 import java.util.ArrayList;
  14 import java.util.BitSet;
  15 import java.util.Comparator;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.TreeMap;
  20 import java.util.stream.Collectors;
  21 import org.opendaylight.transportpce.common.StringConstants;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.networks.network.node.termination.point.XpdrNetworkAttributes;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPools;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmTpType;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODTU4TsAllocated;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODTUCnTs;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.Node1;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.networks.network.node.termination.point.XpdrTpPortConnectionAttributes;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.If100GEODU4;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.If10GEODU2e;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.If1GEODU0;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.IfOCHOTU4ODU4;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.IfOtsiOtsigroup;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.SupportedIfCapability;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev230526.xpdr.otn.tp.attributes.OdtuTpnPool;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  46 import org.opendaylight.yangtools.yang.common.Uint16;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 public class PceOtnNode implements PceNode {
  51     ////////////////////////// OTN NODES ///////////////////////////
  52     /*
  53      * For This Class the node passed shall be at the otn-openroadm Layer
  54      */
  55
  56     private static final Logger LOG = LoggerFactory.getLogger(PceOtnNode.class);
  57     private static final List<String> SERVICE_TYPE_ODU_LIST = List.of(
  58         StringConstants.SERVICE_TYPE_ODU4,
  59         StringConstants.SERVICE_TYPE_ODUC4,
  60         StringConstants.SERVICE_TYPE_ODUC3,
  61         StringConstants.SERVICE_TYPE_ODUC2);
  62     private static final List<OpenroadmNodeType> VALID_NODETYPES_LIST = List.of(
  63         OpenroadmNodeType.MUXPDR,
  64         OpenroadmNodeType.SWITCH,
  65         OpenroadmNodeType.TPDR);
  66     private static final Map<String, SupportedIfCapability> SERVICE_TYPE_ETH_CLASS_MAP = Map.of(
  67         StringConstants.SERVICE_TYPE_1GE, If1GEODU0.VALUE,
  68         StringConstants.SERVICE_TYPE_10GE, If10GEODU2e.VALUE,
  69         StringConstants.SERVICE_TYPE_100GE_M, If100GEODU4.VALUE,
  70         StringConstants.SERVICE_TYPE_100GE_S, If100GEODU4.VALUE);
  71     private static final Map<String, Integer> SERVICE_TYPE_ETH_TS_NB_MAP = Map.of(
  72         StringConstants.SERVICE_TYPE_1GE, 1,
  73         StringConstants.SERVICE_TYPE_10GE, 10,
  74         StringConstants.SERVICE_TYPE_100GE_M, 20);
  75     private static final Map<String, String> SERVICE_TYPE_ETH_ODU_STRING_MAP = Map.of(
  76         StringConstants.SERVICE_TYPE_1GE, "ODU0",
  77         StringConstants.SERVICE_TYPE_10GE, "ODU2e",
  78         StringConstants.SERVICE_TYPE_100GE_M, "ODU4");
  79     private static final String INTERMEDIATE_MODETYPE = "intermediate";
  80     private static final String AZ_MODETYPE = "AZ";
  81
  82     private boolean valid = true;
  83
  84     private final Node node;
  85     private final NodeId nodeId;
  86     private final OpenroadmNodeType nodeType;
  87     private final String pceNodeType;
  88     private final String otnServiceType;
  89     private String modeType;
  90     // TODO: not adding state check in this class as otn topology has not been modified
  91     private final AdminStates adminStates;
  92     private final State state;
  93
  94     private Map<String, List<Uint16>> tpAvailableTribPort = new TreeMap<>();
  95     private Map<String, List<Uint16>> tpAvailableTribSlot = new TreeMap<>();
  96     private Map<String, OpenroadmTpType> availableXponderTp = new TreeMap<>();
  97     private List<String> usedXpdrNWTps = new ArrayList<>();
  98     private List<TpId> availableXpdrNWTps;
  99     private List<TpId> usableXpdrNWTps;
 100     private List<String> usedXpdrClientTps = new ArrayList<>();
 101     private List<TpId> availableXpdrClientTps;
 102     private List<TpId> usableXpdrClientTps;
 103
 104     private List<PceLink> outgoingLinks = new ArrayList<>();
 105     private Map<String, String> clientPerNwTp = new HashMap<>();
 106     private String clientPort;
 107
 108     @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR",
 109         justification = "need to initialise available tribport and tribslt")
 110     public PceOtnNode(Node node, OpenroadmNodeType nodeType, NodeId nodeId, String pceNodeType, String serviceType,
 111                       String clientPort) {
 112         this.node = node;
 113         this.nodeId = nodeId;
 114         this.nodeType = nodeType;
 115         this.pceNodeType = pceNodeType;
 116         this.otnServiceType = serviceType;
 117         this.tpAvailableTribSlot.clear();
 118         this.usedXpdrNWTps.clear();
 119         this.availableXpdrNWTps = new ArrayList<>();
 120         this.usableXpdrNWTps = new ArrayList<>();
 121         this.usedXpdrClientTps.clear();
 122         this.availableXpdrClientTps = new ArrayList<>();
 123         this.usableXpdrClientTps = new ArrayList<>();
 124         this.adminStates = node
 125             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 126             .getAdministrativeState();
 127         this.state = node
 128             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 129             .getOperationalState();
 130         this.tpAvailableTribPort.clear();
 131         checkAvailableTribPort();
 132         this.tpAvailableTribSlot.clear();
 133         checkAvailableTribSlot();
 134         this.clientPort = clientPort;
 135         if (node == null
 136                 || nodeId == null
 137                 || nodeType == null
 138                 || !VALID_NODETYPES_LIST.contains(nodeType)) {
 139             LOG.error("PceOtnNode: one of parameters is not populated : nodeId, node type");
 140             this.valid = false;
 141         }
 142         if (!SERVICE_TYPE_ETH_CLASS_MAP.containsKey(serviceType)
 143                 && !SERVICE_TYPE_ODU_LIST.contains(serviceType)) {
 144             LOG.error("PceOtnNode: unsupported OTN Service Type {}", serviceType);
 145             this.valid = false;
 146         }
 147     }
 148
 149     public void initXndrTps(String mode) {
 150         LOG.debug("PceOtnNode: initXndrTps for node {}", this.nodeId.getValue());
 151         this.availableXponderTp.clear();
 152         this.modeType = mode;
 153         List<TerminationPoint> allTps =
 154             new ArrayList<>(
 155                 this.node.augmentation(
 156                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 157                         .Node1.class)
 158                 .nonnullTerminationPoint()
 159                 .values());
 160         this.valid = false;
 161         if (allTps.isEmpty()) {
 162             LOG.error("PceOtnNode: initXndrTps: XPONDER TerminationPoint list is empty for node {}", this);
 163             return;
 164         }
 165         for (TerminationPoint tp : allTps) {
 166             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
 167                     .TerminationPoint1 ocnTp1
 168                 = tp.augmentation(
 169                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
 170                         .TerminationPoint1.class);
 171             if (ocnTp1 == null) {
 172                 LOG.warn("null ocn TP {}", tp);
 173                 continue;
 174             }
 175             TerminationPoint1 ontTp1 = tp.augmentation(TerminationPoint1.class);
 176             if (ontTp1 == null) {
 177                 continue;
 178             }
 179             //TODO many nested structures below, this needs to be reworked
 180             switch (ocnTp1.getTpType()) {
 181                 case XPONDERNETWORK:
 182                     String notCreatedServiceType = xpdrNetTpCreation(ontTp1);
 183                     if (notCreatedServiceType == null) {
 184                         LOG.debug("TP {} of XPONDER {} is validated",
 185                             tp.getTpId().getValue(),
 186                             node.getNodeId().getValue());
 187                         this.availableXpdrNWTps.add(tp.getTpId());
 188                     } else {
 189                         LOG.error("TP {} of {} does not allow {} termination creation",
 190                             tp.getTpId().getValue(),
 191                             node.getNodeId().getValue(),
 192                             notCreatedServiceType);
 193                     }
 194                     break;
 195                 case XPONDERCLIENT:
 196                     if (!SERVICE_TYPE_ETH_CLASS_MAP.containsKey(this.otnServiceType)) {
 197                         continue;
 198                     }
 199                     if (checkClientTp(ontTp1)) {
 200                         LOG.debug("TP {} of XPONDER {} is validated",
 201                             tp.getTpId(),
 202                             node.getNodeId().getValue());
 203                         this.availableXpdrClientTps.add(tp.getTpId());
 204                     } else {
 205                         LOG.error("TP {} of {} does not allow lo-ODU (ODU2e or ODU0) termination creation",
 206                             tp.getTpId().getValue(),
 207                             node.getNodeId().getValue());
 208                     }
 209                     break;
 210
 211                 default:
 212                     LOG.debug("unsupported ocn TP type {}", ocnTp1.getTpType());
 213             }
 214         }
 215         this.valid = checkSwPool(availableXpdrNWTps, availableXpdrClientTps);
 216     }
 217
 218     private String xpdrNetTpCreation(TerminationPoint1 ontTp1) {
 219         if (SERVICE_TYPE_ODU_LIST.contains(this.otnServiceType)
 220                 || StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)) {
 221                 // TODO verify the capability of network port to support ODU4 CTP interface creation
 222             if (checkTpForOdtuTermination(ontTp1)) {
 223                 //success
 224                 return null;
 225             }
 226             return "ODU4";
 227         }
 228         if (SERVICE_TYPE_ETH_TS_NB_MAP.containsKey(this.otnServiceType)) {
 229             if (checkOdtuTTPforLoOduCreation(
 230                     ontTp1,
 231                     SERVICE_TYPE_ETH_TS_NB_MAP.get(this.otnServiceType))) {
 232                 //success
 233                 return null;
 234             }
 235             return SERVICE_TYPE_ETH_ODU_STRING_MAP.get(this.otnServiceType);
 236         }
 237         //failure
 238         return "any";
 239     }
 240
 241     private boolean checkSwPool(List<TpId> netwTps, List<TpId> clientTps) {
 242
 243         if (SERVICE_TYPE_ODU_LIST.contains(this.otnServiceType)) {
 244             return true;
 245         }
 246         if (!SERVICE_TYPE_ETH_CLASS_MAP.containsKey(this.otnServiceType)) {
 247             return false;
 248         }
 249         if (netwTps == null) {
 250             return false;
 251         }
 252         Node1 node1 = node.augmentation(Node1.class);
 253         if (node1 == null) {
 254             return false;
 255         }
 256         List<NonBlockingList> nblList = new ArrayList<>(
 257                 node1.getSwitchingPools().nonnullOduSwitchingPools()
 258                         .values().stream().findFirst().orElseThrow()
 259                                 .getNonBlockingList().values());
 260         netwTps.sort(Comparator.comparing(TpId::getValue));
 261
 262         switch (modeType) {
 263
 264             case INTERMEDIATE_MODETYPE:
 265                 return checkIntermediateSwPool(nblList, netwTps);
 266
 267             case AZ_MODETYPE:
 268                 if (clientTps == null) {
 269                     return false;
 270                 }
 271                 clientTps.sort(Comparator.comparing(TpId::getValue));
 272                 return checkAzSwPool(nblList, netwTps, clientTps);
 273
 274             default:
 275                 LOG.error("Unsupported mode type {}", modeType);
 276                 return false;
 277         }
 278     }
 279
 280
 281     private boolean checkIntermediateSwPool(List<NonBlockingList> nblList, List<TpId> netwTps) {
 282         for (NonBlockingList nbl: nblList) {
 283             for (TpId nwTp : netwTps) {
 284                 if (nbl.getTpList().contains(nwTp)) {
 285                     usableXpdrNWTps.add(nwTp);
 286                 }
 287                 if (usableXpdrNWTps.size() >= 2) {
 288                     return true;
 289                 }
 290             }
 291         }
 292         return false;
 293     }
 294
 295
 296     private boolean checkAzSwPool(List<NonBlockingList> nblList, List<TpId> netwTps, List<TpId> clientTps) {
 297         for (NonBlockingList nbl: nblList) {
 298             for (TpId nwTp : netwTps) {
 299                 for (TpId clTp : clientTps) {
 300                     if (nbl.getTpList().contains(clTp)
 301                             && nbl.getTpList().contains(nwTp)) {
 302                         usableXpdrClientTps.add(clTp);
 303                         usableXpdrNWTps.add(nwTp);
 304                     }
 305                     if (usableXpdrClientTps.size() >= 1
 306                             && usableXpdrNWTps.size() >= 1
 307                             && (this.clientPort == null || this.clientPort.equals(clTp.getValue()))) {
 308                         clientPerNwTp.put(nwTp.getValue(), clTp.getValue());
 309                         return true;
 310                     }
 311                 }
 312             }
 313         }
 314         return false;
 315     }
 316
 317     private boolean checkTpForOdtuTermination(TerminationPoint1 ontTp1) {
 318         for (SupportedInterfaceCapability sic :
 319                 ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability().values()) {
 320             LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 321             if ((sic.getIfCapType().equals(IfOCHOTU4ODU4.VALUE)
 322                     || sic.getIfCapType().equals(IfOtsiOtsigroup.VALUE))
 323                     && (ontTp1.getXpdrTpPortConnectionAttributes() == null
 324                         || ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() == null)) {
 325                 return true;
 326             }
 327         }
 328         return false;
 329     }
 330
 331     private boolean checkOdtuTTPforLoOduCreation(TerminationPoint1 ontTp1, int tsNb) {
 332         XpdrTpPortConnectionAttributes portConAttr = ontTp1.getXpdrTpPortConnectionAttributes();
 333         if (portConAttr == null
 334                 || portConAttr.getTsPool() == null
 335                 || portConAttr.getTsPool().size() < tsNb
 336                 || portConAttr.getOdtuTpnPool() == null) {
 337             return false;
 338         }
 339         return checkFirstOdtuTpn(portConAttr.getOdtuTpnPool().values().stream().findFirst().orElseThrow());
 340     }
 341
 342     private boolean checkFirstOdtuTpn(OdtuTpnPool otPool) {
 343         return (otPool.getOdtuType().equals(ODTU4TsAllocated.VALUE))
 344                 || otPool.getOdtuType().equals(ODTUCnTs.VALUE)
 345             && !otPool.getTpnPool().isEmpty();
 346     }
 347
 348     private boolean checkClientTp(TerminationPoint1 ontTp1) {
 349         for (SupportedInterfaceCapability sic :
 350                 ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability().values()) {
 351             LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 352             // we could also check the administrative status of the tp
 353             if (SERVICE_TYPE_ETH_CLASS_MAP.get(otnServiceType).equals(sic.getIfCapType())) {
 354                 return true;
 355             }
 356         }
 357         return false;
 358     }
 359
 360     public void validateXponder(String anodeId, String znodeId) {
 361         if (!isValid()) {
 362             return;
 363         }
 364         if (this.nodeId.getValue().equals(anodeId)
 365                 || (this.nodeId.getValue().equals(znodeId))) {
 366             initXndrTps(AZ_MODETYPE);
 367         } else if (OpenroadmNodeType.SWITCH.equals(this.nodeType)) {
 368             initXndrTps(INTERMEDIATE_MODETYPE);
 369         } else {
 370             LOG.warn("validateAZxponder: XPONDER is ignored == {}", nodeId.getValue());
 371             valid = false;
 372         }
 373     }
 374
 375     public boolean validateSwitchingPoolBandwidth(TerminationPoint tp1, TerminationPoint tp2, Long neededBW) {
 376         if (this.nodeType != OpenroadmNodeType.TPDR) {
 377             return true;
 378         }
 379         for (OduSwitchingPools ospx :
 380                 node.augmentation(Node1.class)
 381                     .getSwitchingPools()
 382                     .nonnullOduSwitchingPools().values()) {
 383             for (NonBlockingList nbll : ospx.nonnullNonBlockingList().values()) {
 384                 if (nbll.getAvailableInterconnectBandwidth().toJava() >= neededBW
 385                         && nbll.getTpList() != null
 386                         && nbll.getTpList().contains(tp1.getTpId())
 387                         && nbll.getTpList().contains(tp2.getTpId())) {
 388                     LOG.debug("validateSwitchingPoolBandwidth: couple  of tp {} x {} valid for crossconnection",
 389                         tp1.getTpId(), tp2.getTpId());
 390                     return true;
 391                 }
 392             }
 393         }
 394         LOG.debug("validateSwitchingPoolBandwidth: No valid Switching pool for crossconnecting tp {} and {}",
 395             tp1.getTpId(), tp2.getTpId());
 396         return false;
 397     }
 398
 399     public void validateIntermediateSwitch() {
 400         if (!isValid()) {
 401             return;
 402         }
 403         if (this.nodeType != OpenroadmNodeType.SWITCH) {
 404             return;
 405         }
 406         // Validate switch for use as an intermediate XPONDER on the path
 407         initXndrTps(INTERMEDIATE_MODETYPE);
 408         if (this.valid) {
 409             LOG.debug("validateIntermediateSwitch: Switch usable for transit == {}", nodeId.getValue());
 410         } else {
 411             LOG.debug("validateIntermediateSwitch: Switch unusable for transit == {}", nodeId.getValue());
 412         }
 413     }
 414
 415     public void checkAvailableTribPort() {
 416         for (TerminationPoint tp :
 417             node.augmentation(
 418                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 419                         .Node1.class)
 420                 .getTerminationPoint().values().stream()
 421                 .filter(type -> type
 422                     .augmentation(
 423                         org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
 424                             .TerminationPoint1.class)
 425                     .getTpType()
 426                     .equals(OpenroadmTpType.XPONDERNETWORK))
 427                 .collect(Collectors.toList())) {
 428             XpdrTpPortConnectionAttributes portConAttr =
 429                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 430             if (portConAttr != null && portConAttr.getOdtuTpnPool() != null) {
 431                 OdtuTpnPool otPool = portConAttr.getOdtuTpnPool().values().stream().findFirst().orElseThrow();
 432                 if (checkFirstOdtuTpn(otPool)) {
 433                     tpAvailableTribPort.put(tp.getTpId().getValue(), new ArrayList<>(otPool.getTpnPool()));
 434                 }
 435             }
 436         }
 437     }
 438
 439     public void checkAvailableTribSlot() {
 440         for (TerminationPoint tp :
 441             node.augmentation(
 442                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 443                     .Node1.class)
 444             .getTerminationPoint().values().stream()
 445             .filter(type -> type
 446                 .augmentation(
 447                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
 448                         .TerminationPoint1.class)
 449                 .getTpType().equals(OpenroadmTpType.XPONDERNETWORK))
 450             .collect(Collectors.toList())
 451         ) {
 452             XpdrTpPortConnectionAttributes portConAttr =
 453                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 454             if (portConAttr != null && portConAttr.getTsPool() != null) {
 455                 tpAvailableTribSlot.put(tp.getTpId().getValue(), new ArrayList<>(portConAttr.getTsPool()));
 456             }
 457         }
 458     }
 459
 460     public boolean isValid() {
 461         if (nodeId == null
 462                 || nodeType == null
 463                 || this.getSupNetworkNodeId() == null
 464                 || this.getSupClliNodeId() == null) {
 465             LOG.error("PceNode: one of parameters is not populated : nodeId, node type, supporting nodeId");
 466             valid = false;
 467         }
 468         return valid;
 469     }
 470
 471     @Override
 472     public void addOutgoingLink(PceLink outLink) {
 473         this.outgoingLinks.add(outLink);
 474     }
 475
 476     @Override
 477     public List<PceLink> getOutgoingLinks() {
 478         return outgoingLinks;
 479     }
 480
 481     @Override
 482     public AdminStates getAdminStates() {
 483         return adminStates;
 484     }
 485
 486     @Override
 487     public State getState() {
 488         return state;
 489     }
 490
 491     @Override
 492     public String getXpdrClient(String tp) {
 493         return this.clientPerNwTp.get(tp);
 494     }
 495
 496     @Override
 497     public String toString() {
 498         return "PceNode type=" + nodeType + " ID=" + nodeId.getValue() + " CLLI=" + this.getSupClliNodeId();
 499     }
 500
 501     public void printLinksOfNode() {
 502         LOG.info(" outgoing links of node {} : {} ", nodeId.getValue(), this.getOutgoingLinks());
 503     }
 504
 505     @Override
 506     public Map<String, List<Uint16>> getAvailableTribPorts() {
 507         return tpAvailableTribPort;
 508     }
 509
 510     @Override
 511     public Map<String, List<Uint16>> getAvailableTribSlots() {
 512         return tpAvailableTribSlot;
 513     }
 514
 515     public List<TpId> getUsableXpdrNWTps() {
 516         return usableXpdrNWTps;
 517     }
 518
 519     public List<TpId> getUsableXpdrClientTps() {
 520         return usableXpdrClientTps;
 521     }
 522
 523     @Override
 524     public String getPceNodeType() {
 525         return this.pceNodeType;
 526     }
 527
 528     @Override
 529     public String getSupNetworkNodeId() {
 530         return MapUtils.getSupNetworkNode(this.node);
 531     }
 532
 533     @Override
 534     public String getSupClliNodeId() {
 535         return MapUtils.getSupClliNode(this.node);
 536     }
 537
 538     @Override
 539     public String getRdmSrgClient(String tp, String direction) {
 540         return null;
 541     }
 542
 543     @Override
 544     public NodeId getNodeId() {
 545         return nodeId;
 546     }
 547
 548     @Override
 549     public boolean checkTP(String tp) {
 550         return false;
 551     }
 552
 553     /*
 554     * (non-Javadoc)
 555     *
 556     * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getVersion()
 557     */
 558     @Override
 559     public String getVersion() {
 560         // TODO Auto-generated method stub
 561         return null;
 562     }
 563
 564     @Override
 565     public BitSet getBitSetData() {
 566         // TODO Auto-generated method stub
 567         return null;
 568     }
 569
 570     @Override
 571     public String getXponderOperationalMode(XpdrNetworkAttributes tp) {
 572         return null;
 573     }
 574
 575     @Override
 576     public String getOperationalMode() {
 577         return null;
 578     }
 579
 580     @Override
 581     public OpenroadmNodeType getORNodeType() {
 582         return this.nodeType;
 583     }
 584
 585     /*
 586     * (non-Javadoc)
 587     *
 588     * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getSlotWidthGranularity()
 589     */
 590     @Override
 591     public BigDecimal getSlotWidthGranularity() {
 592         return null;
 593     }
 594
 595     /*
 596      * (non-Javadoc)
 597      *
 598      * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getCentralFreqGranularity()
 599      */
 600     @Override
 601     public BigDecimal getCentralFreqGranularity() {
 602         return null;
 603     }
 604 }