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