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 java.math.BigDecimal;
  12 import java.util.ArrayList;
  13 import java.util.BitSet;
  14 import java.util.Comparator;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.TreeMap;
  19 import java.util.stream.Collectors;
  20 import org.opendaylight.transportpce.common.StringConstants;
  21 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.OduSwitchingPools;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmNodeType;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTU4TsAllocated;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTUCnTs;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.XpdrTpPortConnectionAttributes;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If100GEODU4;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If10GEODU2e;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If1GEODU0;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCHOTU4ODU4;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOtsiOtsigroup;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.SupportedIfCapability;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPool;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  44 import org.opendaylight.yangtools.yang.common.Uint16;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public class PceOtnNode implements PceNode {
  49     ////////////////////////// OTN NODES ///////////////////////////
  50     /*
  51      * For This Class the node passed shall be at the otn-openroadm Layer
  52      */
  53
  54     private static final Logger LOG = LoggerFactory.getLogger(PceOtnNode.class);
  55     private static final List<String> SERVICE_TYPE_ODU_LIST = List.of(
  56         StringConstants.SERVICE_TYPE_ODU4,
  57         StringConstants.SERVICE_TYPE_ODUC4,
  58         StringConstants.SERVICE_TYPE_ODUC3,
  59         StringConstants.SERVICE_TYPE_ODUC2);
  60     private static final List<OpenroadmNodeType> VALID_NODETYPES_LIST = List.of(
  61         OpenroadmNodeType.MUXPDR,
  62         OpenroadmNodeType.SWITCH,
  63         OpenroadmNodeType.TPDR);
  64     private static final Map<String, Class<? extends SupportedIfCapability>> SERVICE_TYPE_ETH_CLASS_MAP = Map.of(
  65         StringConstants.SERVICE_TYPE_1GE, If1GEODU0.class,
  66         StringConstants.SERVICE_TYPE_10GE, If10GEODU2e.class,
  67         StringConstants.SERVICE_TYPE_100GE_M, If100GEODU4.class,
  68         StringConstants.SERVICE_TYPE_100GE_S, If100GEODU4.class);
  69     private static final Map<String, Integer> SERVICE_TYPE_ETH_TS_NB_MAP = Map.of(
  70         StringConstants.SERVICE_TYPE_1GE, 1,
  71         StringConstants.SERVICE_TYPE_10GE, 10,
  72         StringConstants.SERVICE_TYPE_100GE_M, 20);
  73     private static final Map<String, String> SERVICE_TYPE_ETH_ODU_STRING_MAP = Map.of(
  74         StringConstants.SERVICE_TYPE_1GE, "ODU0",
  75         StringConstants.SERVICE_TYPE_10GE, "ODU2e",
  76         StringConstants.SERVICE_TYPE_100GE_M, "ODU4");
  77
  78     private boolean valid = true;
  79
  80     private final Node node;
  81     private final NodeId nodeId;
  82     private final OpenroadmNodeType nodeType;
  83     private final String pceNodeType;
  84     private final String otnServiceType;
  85     private String modeType;
  86     // TODO: not adding state check in this class as otn topology has not been modified
  87     private final AdminStates adminStates;
  88     private final State state;
  89
  90     private Map<String, List<Uint16>> tpAvailableTribPort = new TreeMap<>();
  91     private Map<String, List<Uint16>> tpAvailableTribSlot = new TreeMap<>();
  92     private Map<String, OpenroadmTpType> availableXponderTp = new TreeMap<>();
  93     private List<String> usedXpdrNWTps = new ArrayList<>();
  94     private List<TpId> availableXpdrNWTps;
  95     private List<TpId> usableXpdrNWTps;
  96     private List<String> usedXpdrClientTps = new ArrayList<>();
  97     private List<TpId> availableXpdrClientTps;
  98     private List<TpId> usableXpdrClientTps;
  99
 100     private List<PceLink> outgoingLinks = new ArrayList<>();
 101     private Map<String, String> clientPerNwTp = new HashMap<>();
 102     private String clientPort;
 103
 104     public PceOtnNode(
 105             Node node,
 106             OpenroadmNodeType nodeType,
 107             NodeId nodeId,
 108             String pceNodeType,
 109             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.rev200529.Node1.class)
 125             .getAdministrativeState();
 126         this.state = node
 127             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.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.info("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.rev200529
 166                     .TerminationPoint1 ocnTp1
 167                 = tp.augmentation(
 168                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
 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.info("TP {} of XPONDER {} is validated",
 184                             tp.getTpId(),
 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
 195                 case XPONDERCLIENT:
 196                     if (!SERVICE_TYPE_ETH_CLASS_MAP.containsKey(this.otnServiceType)) {
 197                         continue;
 198                     }
 199                     if (checkClientTp(ontTp1)) {
 200                         LOG.info("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().get()
 259                                 .getNonBlockingList().values());
 260         if (nblList == null) {
 261             return false;
 262         }
 263         netwTps.sort(Comparator.comparing(TpId::getValue));
 264
 265         switch (modeType) {
 266
 267             case "intermediate":
 268                 return checkIntermediateSwPool(nblList, netwTps);
 269
 270             case "AZ":
 271                 if (clientTps == null) {
 272                     return false;
 273                 }
 274                 clientTps.sort(Comparator.comparing(TpId::getValue));
 275                 return checkAzSwPool(nblList, netwTps, clientTps);
 276
 277             default:
 278                 LOG.error("Unsupported mode type {}", modeType);
 279                 return false;
 280         }
 281     }
 282
 283
 284     private boolean checkIntermediateSwPool(List<NonBlockingList> nblList, List<TpId> netwTps) {
 285         for (NonBlockingList nbl: nblList) {
 286             for (TpId nwTp : netwTps) {
 287                 if (nbl.getTpList().contains(nwTp)) {
 288                     usableXpdrNWTps.add(nwTp);
 289                 }
 290                 if (usableXpdrNWTps.size() >= 2) {
 291                     return true;
 292                 }
 293             }
 294         }
 295         return false;
 296     }
 297
 298
 299     private boolean checkAzSwPool(List<NonBlockingList> nblList, List<TpId> netwTps, List<TpId> clientTps) {
 300         for (NonBlockingList nbl: nblList) {
 301             for (TpId nwTp : netwTps) {
 302                 for (TpId clTp : clientTps) {
 303                     if (nbl.getTpList().contains(clTp)
 304                             && nbl.getTpList().contains(nwTp)) {
 305                         usableXpdrClientTps.add(clTp);
 306                         usableXpdrNWTps.add(nwTp);
 307                     }
 308                     if (usableXpdrClientTps.size() >= 1
 309                             && usableXpdrNWTps.size() >= 1
 310                             && (this.clientPort == null || this.clientPort.equals(clTp.getValue()))) {
 311                         clientPerNwTp.put(nwTp.getValue(), clTp.getValue());
 312                         return true;
 313                     }
 314                 }
 315             }
 316         }
 317         return false;
 318     }
 319
 320     private boolean checkTpForOdtuTermination(TerminationPoint1 ontTp1) {
 321         for (SupportedInterfaceCapability sic :
 322                 ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability().values()) {
 323             LOG.info("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 324             if ((sic.getIfCapType().equals(IfOCHOTU4ODU4.class) || sic.getIfCapType().equals(IfOtsiOtsigroup.class))
 325                     && (ontTp1.getXpdrTpPortConnectionAttributes() == null
 326                         || ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() == null)) {
 327                 return true;
 328             }
 329         }
 330         return false;
 331     }
 332
 333     private boolean checkOdtuTTPforLoOduCreation(TerminationPoint1 ontTp1, int tsNb) {
 334         XpdrTpPortConnectionAttributes portConAttr = ontTp1.getXpdrTpPortConnectionAttributes();
 335         if (portConAttr == null
 336                 || portConAttr.getTsPool() == null
 337                 || portConAttr.getTsPool().size() < tsNb
 338                 || portConAttr.getOdtuTpnPool() == null) {
 339             return false;
 340         }
 341         return checkFirstOdtuTpn(portConAttr.getOdtuTpnPool().values().stream().findFirst().get());
 342     }
 343
 344     private boolean checkFirstOdtuTpn(OdtuTpnPool otPool) {
 345         return (otPool.getOdtuType().equals(ODTU4TsAllocated.class)
 346                 || otPool.getOdtuType().equals(ODTUCnTs.class))
 347             && !otPool.getTpnPool().isEmpty();
 348     }
 349
 350     private boolean checkClientTp(TerminationPoint1 ontTp1) {
 351         for (SupportedInterfaceCapability sic :
 352                 ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability().values()) {
 353             LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 354             // we could also check the administrative status of the tp
 355             if (sic.getIfCapType().equals(SERVICE_TYPE_ETH_CLASS_MAP.get(otnServiceType))) {
 356                 return true;
 357             }
 358         }
 359         return false;
 360     }
 361
 362     public void validateXponder(String anodeId, String znodeId) {
 363         if (!isValid()) {
 364             return;
 365         }
 366         if (this.nodeId.getValue().equals(anodeId)
 367                 || (this.nodeId.getValue().equals(znodeId))) {
 368             initXndrTps("AZ");
 369         } else if (OpenroadmNodeType.SWITCH.equals(this.nodeType)) {
 370             initXndrTps("intermediate");
 371         } else {
 372             LOG.info("validateAZxponder: XPONDER is ignored == {}", nodeId.getValue());
 373             valid = false;
 374         }
 375     }
 376
 377     public boolean validateSwitchingPoolBandwidth(TerminationPoint tp1, TerminationPoint tp2, Long neededBW) {
 378         if (this.nodeType != OpenroadmNodeType.TPDR) {
 379             return true;
 380         }
 381         for (OduSwitchingPools ospx :
 382                 node.augmentation(Node1.class)
 383                     .getSwitchingPools()
 384                     .nonnullOduSwitchingPools().values()) {
 385             for (NonBlockingList nbll : ospx.nonnullNonBlockingList().values()) {
 386                 if (nbll.getAvailableInterconnectBandwidth().toJava() >= neededBW
 387                         && nbll.getTpList() != null
 388                         && nbll.getTpList().contains(tp1.getTpId())
 389                         && nbll.getTpList().contains(tp2.getTpId())) {
 390                     LOG.debug("validateSwitchingPoolBandwidth: couple  of tp {} x {} valid for crossconnection",
 391                         tp1.getTpId(), tp2.getTpId());
 392                     return true;
 393                 }
 394             }
 395         }
 396         LOG.debug("validateSwitchingPoolBandwidth: No valid Switching pool for crossconnecting tp {} and {}",
 397             tp1.getTpId(), tp2.getTpId());
 398         return false;
 399     }
 400
 401     public void validateIntermediateSwitch() {
 402         if (!isValid()) {
 403             return;
 404         }
 405         if (this.nodeType != OpenroadmNodeType.SWITCH) {
 406             return;
 407         }
 408         // Validate switch for use as an intermediate XPONDER on the path
 409         initXndrTps("intermediate");
 410         if (this.valid) {
 411             LOG.info("validateIntermediateSwitch: Switch usable for transit == {}", nodeId.getValue());
 412         } else {
 413             LOG.debug("validateIntermediateSwitch: Switch unusable for transit == {}", nodeId.getValue());
 414         }
 415     }
 416
 417     public void checkAvailableTribPort() {
 418         for (TerminationPoint tp :
 419             node.augmentation(
 420                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 421                         .Node1.class)
 422                 .getTerminationPoint().values().stream()
 423                 .filter(type -> type
 424                     .augmentation(
 425                         org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
 426                             .TerminationPoint1.class)
 427                     .getTpType()
 428                     .equals(OpenroadmTpType.XPONDERNETWORK))
 429                 .collect(Collectors.toList())) {
 430             XpdrTpPortConnectionAttributes portConAttr =
 431                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 432             if (portConAttr != null && portConAttr.getOdtuTpnPool() != null) {
 433                 OdtuTpnPool otPool = portConAttr.getOdtuTpnPool().values().stream().findFirst().get();
 434                 if (checkFirstOdtuTpn(otPool)) {
 435                     tpAvailableTribPort.put(tp.getTpId().getValue(), otPool.getTpnPool());
 436                 }
 437             }
 438         }
 439     }
 440
 441     public void checkAvailableTribSlot() {
 442         for (TerminationPoint tp :
 443             node.augmentation(
 444                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 445                     .Node1.class)
 446             .getTerminationPoint().values().stream()
 447             .filter(type -> type
 448                 .augmentation(
 449                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
 450                         .TerminationPoint1.class)
 451                 .getTpType().equals(OpenroadmTpType.XPONDERNETWORK))
 452             .collect(Collectors.toList())
 453         ) {
 454             XpdrTpPortConnectionAttributes portConAttr =
 455                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 456             if (portConAttr != null && portConAttr.getTsPool() != null) {
 457                 tpAvailableTribSlot.put(tp.getTpId().getValue(), portConAttr.getTsPool());
 458             }
 459         }
 460     }
 461
 462     public boolean isValid() {
 463         if (nodeId == null
 464                 || nodeType == null
 465                 || this.getSupNetworkNodeId() == null
 466                 || this.getSupClliNodeId() == null) {
 467             LOG.error("PceNode: one of parameters is not populated : nodeId, node type, supporting nodeId");
 468             valid = false;
 469         }
 470         return valid;
 471     }
 472
 473     @Override
 474     public void addOutgoingLink(PceLink outLink) {
 475         this.outgoingLinks.add(outLink);
 476     }
 477
 478     @Override
 479     public List<PceLink> getOutgoingLinks() {
 480         return outgoingLinks;
 481     }
 482
 483     @Override
 484     public AdminStates getAdminStates() {
 485         return adminStates;
 486     }
 487
 488     @Override
 489     public State getState() {
 490         return state;
 491     }
 492
 493     @Override
 494     public String getXpdrClient(String tp) {
 495         return this.clientPerNwTp.get(tp);
 496     }
 497
 498     @Override
 499     public String toString() {
 500         return "PceNode type=" + nodeType + " ID=" + nodeId.getValue() + " CLLI=" + this.getSupClliNodeId();
 501     }
 502
 503     public void printLinksOfNode() {
 504         LOG.info(" outgoing links of node {} : {} ", nodeId.getValue(), this.getOutgoingLinks());
 505     }
 506
 507     @Override
 508     public Map<String, List<Uint16>> getAvailableTribPorts() {
 509         return tpAvailableTribPort;
 510     }
 511
 512     @Override
 513     public Map<String, List<Uint16>> getAvailableTribSlots() {
 514         return tpAvailableTribSlot;
 515     }
 516
 517     public List<TpId> getUsableXpdrNWTps() {
 518         return usableXpdrNWTps;
 519     }
 520
 521     public List<TpId> getUsableXpdrClientTps() {
 522         return usableXpdrClientTps;
 523     }
 524
 525     @Override
 526     public String getPceNodeType() {
 527         return this.pceNodeType;
 528     }
 529
 530     @Override
 531     public String getSupNetworkNodeId() {
 532         return MapUtils.getSupNetworkNode(this.node);
 533     }
 534
 535     @Override
 536     public String getSupClliNodeId() {
 537         return MapUtils.getSupClliNode(this.node);
 538     }
 539
 540     @Override
 541     public String getRdmSrgClient(String tp, String direction) {
 542         return null;
 543     }
 544
 545     @Override
 546     public NodeId getNodeId() {
 547         return nodeId;
 548     }
 549
 550     @Override
 551     public boolean checkTP(String tp) {
 552         return false;
 553     }
 554
 555     /*
 556     * (non-Javadoc)
 557     *
 558     * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getVersion()
 559     */
 560     @Override
 561     public String getVersion() {
 562         // TODO Auto-generated method stub
 563         return null;
 564     }
 565
 566     @Override
 567     public BitSet getBitSetData() {
 568         // TODO Auto-generated method stub
 569         return null;
 570     }
 571
 572     /*
 573     * (non-Javadoc)
 574     *
 575     * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getSlotWidthGranularity()
 576     */
 577     @Override
 578     public BigDecimal getSlotWidthGranularity() {
 579         return null;
 580     }
 581
 582     /*
 583      * (non-Javadoc)
 584      *
 585      * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getCentralFreqGranularity()
 586      */
 587     @Override
 588     public BigDecimal getCentralFreqGranularity() {
 589         return null;
 590     }
 591 }