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