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