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.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  43 import org.opendaylight.yangtools.yang.common.Uint16;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 public class PceOtnNode implements PceNode {
  48     /* Logging. */
  49     private static final Logger LOG = LoggerFactory.getLogger(PceOtnNode.class);
  50     ////////////////////////// OTN NODES ///////////////////////////
  51     /*
  52      * For This Class the node passed shall be at the otn-openroadm Layer
  53      */
  54
  55     private static List<String> serviceTypeOduList = 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 Map<String,
  61             Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.SupportedIfCapability>>
  62                 serviceTypeEthClassMap = Map.of(
  63         StringConstants.SERVICE_TYPE_1GE, If1GEODU0.class,
  64         StringConstants.SERVICE_TYPE_10GE, If10GEODU2e.class,
  65         StringConstants.SERVICE_TYPE_100GE_T, If100GEODU4.class,
  66         StringConstants.SERVICE_TYPE_100GE_M, If100GEODU4.class,
  67         StringConstants.SERVICE_TYPE_100GE_S, If100GEODU4.class);
  68     private static Map<String, Integer> serviceTypeEthTsNbMap = Map.of(
  69         StringConstants.SERVICE_TYPE_1GE, 1,
  70         StringConstants.SERVICE_TYPE_10GE, 10,
  71         StringConstants.SERVICE_TYPE_100GE_M, 20);
  72     private static Map<String, String> serviceTypeEthOduStringMap = Map.of(
  73         StringConstants.SERVICE_TYPE_1GE, "ODU0",
  74         StringConstants.SERVICE_TYPE_10GE, "ODU2e",
  75         StringConstants.SERVICE_TYPE_100GE_M, "ODU4");
  76
  77     private boolean valid = true;
  78
  79     private final Node node;
  80     private final NodeId nodeId;
  81     private final OpenroadmNodeType nodeType;
  82     private final String pceNodeType;
  83     private final String otnServiceType;
  84     private String modeType;
  85     // TODO: not adding state check in this class as otn topology has not been modified
  86     private final AdminStates adminStates;
  87     private final State state;
  88
  89     private Map<String, List<Uint16>> tpAvailableTribPort = new TreeMap<>();
  90     private Map<String, List<Uint16>> tpAvailableTribSlot = new TreeMap<>();
  91     private Map<String, OpenroadmTpType> availableXponderTp = new TreeMap<>();
  92     private List<String> usedXpdrNWTps = new ArrayList<>();
  93     private List<TpId> availableXpdrNWTps;
  94     private List<TpId> usableXpdrNWTps;
  95     private List<String> usedXpdrClientTps = new ArrayList<>();
  96     private List<TpId> availableXpdrClientTps;
  97     private List<TpId> usableXpdrClientTps;
  98
  99     private List<PceLink> outgoingLinks = new ArrayList<>();
 100     private Map<String, String> clientPerNwTp = new HashMap<>();
 101     private String clientPort;
 102
 103     public PceOtnNode(Node node, OpenroadmNodeType nodeType, NodeId nodeId, String pceNodeType, String serviceType,
 104             String clientPort) {
 105         this.node = node;
 106         this.nodeId = nodeId;
 107         this.nodeType = nodeType;
 108         this.pceNodeType = pceNodeType;
 109         this.otnServiceType = serviceType;
 110         this.tpAvailableTribSlot.clear();
 111         this.usedXpdrNWTps.clear();
 112         this.availableXpdrNWTps = new ArrayList<>();
 113         this.usableXpdrNWTps = new ArrayList<>();
 114         this.usedXpdrClientTps.clear();
 115         this.availableXpdrClientTps = new ArrayList<>();
 116         this.usableXpdrClientTps = new ArrayList<>();
 117         this.adminStates = node
 118             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
 119             .getAdministrativeState();
 120         this.state = node
 121             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
 122             .getOperationalState();
 123         this.tpAvailableTribPort.clear();
 124         checkAvailableTribPort();
 125         this.tpAvailableTribSlot.clear();
 126         checkAvailableTribSlot();
 127         this.clientPort = clientPort;
 128         if (node == null || nodeId == null || nodeType != OpenroadmNodeType.MUXPDR
 129                 && nodeType != OpenroadmNodeType.SWITCH && nodeType != OpenroadmNodeType.TPDR) {
 130             LOG.error("PceOtnNode: one of parameters is not populated : nodeId, node type");
 131             this.valid = false;
 132         }
 133     }
 134
 135     public void initXndrTps(String mode) {
 136         LOG.info("PceOtnNode: initXndrTps for node {}", this.nodeId.getValue());
 137         this.availableXponderTp.clear();
 138         this.modeType = mode;
 139         List<TerminationPoint> allTps =
 140             new ArrayList<>(
 141                 this.node.augmentation(
 142                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 143                         .Node1.class)
 144                 .nonnullTerminationPoint()
 145                 .values());
 146         this.valid = false;
 147         if (allTps.isEmpty()) {
 148             LOG.error("PceOtnNode: initXndrTps: XPONDER TerminationPoint list is empty for node {}", this);
 149             return;
 150         }
 151         for (TerminationPoint tp : allTps) {
 152             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1 ocnTp1
 153                 = tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
 154                         .TerminationPoint1.class);
 155             if (ocnTp1 == null) {
 156                 LOG.warn("null ocn TP {}", tp);
 157                 continue;
 158             }
 159             //TODO many nested structures below, this needs to be reworked
 160             switch (ocnTp1.getTpType()) {
 161                 case XPONDERNETWORK:
 162                     if (tp.augmentation(TerminationPoint1.class) == null) {
 163                         continue;
 164                     }
 165                     TerminationPoint1 ontTp1 = tp.augmentation(TerminationPoint1.class);
 166                     if (serviceTypeOduList.contains(this.otnServiceType)
 167                             || StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)) {
 168                             // TODO verify the capability of network port to support ODU4 CTP interface creation
 169                         if (!checkTpForOdtuTermination(ontTp1)) {
 170                             LOG.error("TP {} of {} does not allow ODU4 termination creation",
 171                                 tp.getTpId().getValue(), node.getNodeId().getValue());
 172                             continue;
 173                         }
 174                     } else if (serviceTypeEthTsNbMap.containsKey(this.otnServiceType)) {
 175                         if (!checkOdtuTTPforLoOduCreation(ontTp1, serviceTypeEthTsNbMap.get(this.otnServiceType))) {
 176                             LOG.error("TP {} of {} does not allow {} termination creation",
 177                                 tp.getTpId().getValue(),
 178                                 serviceTypeEthOduStringMap.get(this.otnServiceType),
 179                                 node.getNodeId().getValue());
 180                             continue;
 181                         }
 182                     // TODO what about SERVICE_TYPE_100GE_T ?
 183                     } else {
 184                         LOG.error("TP {} of {} does not allow any termination creation",
 185                             tp.getTpId().getValue(), node.getNodeId().getValue());
 186                         continue;
 187                     }
 188                     LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
 189                     this.availableXpdrNWTps.add(tp.getTpId());
 190                     break;
 191
 192                 case XPONDERCLIENT:
 193                     if (serviceTypeEthClassMap.containsKey(otnServiceType)
 194                             && !StringConstants.SERVICE_TYPE_100GE_T.equals(this.otnServiceType)) {
 195                             // TODO should we really exclude SERVICE_TYPE_100GE_T ?
 196                         if (tp.augmentation(TerminationPoint1.class) == null) {
 197                             continue;
 198                         }
 199                         if (checkClientTp(tp.augmentation(TerminationPoint1.class))) {
 200                             LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
 201                             this.availableXpdrClientTps.add(tp.getTpId());
 202                         } else {
 203                             LOG.error("TP {} of {} does not allow lo-ODU (ODU2e or ODU0) termination creation",
 204                                 tp.getTpId().getValue(), node.getNodeId().getValue());
 205                         }
 206                     }
 207                     break;
 208
 209                 default:
 210                     LOG.debug("unsupported ocn TP type {}", ocnTp1.getTpType());
 211             }
 212         }
 213         this.valid = serviceTypeOduList.contains(this.otnServiceType)
 214                 || (serviceTypeEthTsNbMap.containsKey(this.otnServiceType)
 215                     && ((mode.equals("AZ") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 1, 1))
 216                      || (mode.equals("intermediate") && checkSwPool(null, availableXpdrNWTps, 0, 2)))
 217                     )
 218                 || (StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)
 219                     && ((mode.equals("AZ") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 1, 1)))
 220                      || (mode.equals("intermediate") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 0, 2))
 221                     );
 222                 //TODO checks very similar to isIntermediate and isAz methods - they should be mutualized
 223                 //     perhaps even with isOtnServiceTypeValid method
 224     }
 225
 226     private boolean checkSwPool(List<TpId> clientTps, List<TpId> netwTps, int nbClient, int nbNetw) {
 227         if (clientTps != null && netwTps != null && nbClient == 1 && nbNetw == 1) {
 228             clientTps.sort(Comparator.comparing(TpId::getValue));
 229             netwTps.sort(Comparator.comparing(TpId::getValue));
 230             for (TpId nwTp : netwTps) {
 231                 for (TpId clTp : clientTps) {
 232                     for (NonBlockingList nbl : new ArrayList<>(node.augmentation(Node1.class).getSwitchingPools()
 233                             .nonnullOduSwitchingPools().values().stream().findFirst().get()
 234                                 .getNonBlockingList().values())) {
 235                         if (nbl.getTpList().contains(clTp) && nbl.getTpList().contains(nwTp)) {
 236                             usableXpdrClientTps.add(clTp);
 237                             usableXpdrNWTps.add(nwTp);
 238                         }
 239                         if (usableXpdrClientTps.size() >= nbClient && usableXpdrNWTps.size() >= nbNetw) {
 240                             if (this.clientPort == null || this.clientPort.equals(clTp.getValue())) {
 241                                 clientPerNwTp.put(nwTp.getValue(), clTp.getValue());
 242                                 return true;
 243                             }
 244                         }
 245                     }
 246                 }
 247             }
 248         }
 249         if (netwTps != null && nbClient == 0 && nbNetw == 2) {
 250             netwTps.sort(Comparator.comparing(TpId::getValue));
 251             for (NonBlockingList nbl : new ArrayList<>(node.augmentation(Node1.class).getSwitchingPools()
 252                     .nonnullOduSwitchingPools().values().stream().findFirst().get()
 253                         .getNonBlockingList().values())) {
 254                 for (TpId nwTp : netwTps) {
 255                     if (nbl.getTpList().contains(nwTp)) {
 256                         usableXpdrNWTps.add(nwTp);
 257                     }
 258                     if (usableXpdrNWTps.size() >= nbNetw) {
 259                         return true;
 260                     }
 261                 }
 262             }
 263         }
 264         return false;
 265     }
 266
 267     private boolean checkTpForOdtuTermination(TerminationPoint1 ontTp1) {
 268         for (SupportedInterfaceCapability sic : ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability()
 269                 .values()) {
 270             LOG.info("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 271             if ((sic.getIfCapType().equals(IfOCHOTU4ODU4.class) || sic.getIfCapType().equals(IfOtsiOtsigroup.class))
 272                 && (ontTp1.getXpdrTpPortConnectionAttributes() == null
 273                     || ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() == null)) {
 274                 return true;
 275             }
 276         }
 277         return false;
 278     }
 279
 280     private boolean checkOdtuTTPforLoOduCreation(TerminationPoint1 ontTp1, int tsNb) {
 281         XpdrTpPortConnectionAttributes portConAttr = ontTp1.getXpdrTpPortConnectionAttributes();
 282         return portConAttr != null
 283             && portConAttr.getTsPool() != null
 284             && portConAttr.getTsPool().size() >= tsNb
 285             && portConAttr.getOdtuTpnPool() != null
 286             && (portConAttr.getOdtuTpnPool().values()
 287                         .stream().findFirst().get().getOdtuType()
 288                     .equals(ODTU4TsAllocated.class)
 289                 ||
 290                 portConAttr.getOdtuTpnPool().values()
 291                         .stream().findFirst().get().getOdtuType()
 292                     .equals(ODTUCnTs.class))
 293             && !portConAttr.getOdtuTpnPool().values()
 294                         .stream().findFirst().get().getTpnPool()
 295                     .isEmpty();
 296             //TODO a dedicated method for OdtuTpnPool first value would probably be welcome
 297     }
 298
 299     private boolean checkClientTp(TerminationPoint1 ontTp1) {
 300         for (SupportedInterfaceCapability sic : ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability()
 301                 .values()) {
 302             LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
 303             // we could also check the administrative status of the tp
 304             if (serviceTypeEthClassMap.containsKey(otnServiceType)
 305                     && sic.getIfCapType().equals(serviceTypeEthClassMap.get(otnServiceType))) {
 306                 return true;
 307             }
 308         }
 309         return false;
 310     }
 311
 312     public void validateXponder(String anodeId, String znodeId) {
 313         if (!isValid()) {
 314             return;
 315         }
 316         if (this.nodeId.getValue().equals(anodeId) || (this.nodeId.getValue().equals(znodeId))) {
 317             initXndrTps("AZ");
 318         } else if (OpenroadmNodeType.SWITCH.equals(this.nodeType)) {
 319             initXndrTps("intermediate");
 320         } else {
 321             LOG.info("validateAZxponder: XPONDER is ignored == {}", nodeId.getValue());
 322             valid = false;
 323         }
 324     }
 325
 326     public boolean validateSwitchingPoolBandwidth(TerminationPoint tp1, TerminationPoint tp2, Long neededBW) {
 327         if (this.nodeType != OpenroadmNodeType.TPDR) {
 328             return true;
 329         }
 330         Node1 node1 = node.augmentation(Node1.class);
 331         SwitchingPools sp = node1.getSwitchingPools();
 332         List<OduSwitchingPools> osp = new ArrayList<>(sp.nonnullOduSwitchingPools().values());
 333         for (OduSwitchingPools ospx : osp) {
 334             List<NonBlockingList> nbl = new ArrayList<>(ospx.nonnullNonBlockingList().values());
 335             for (NonBlockingList nbll : nbl) {
 336                 if (nbll.getAvailableInterconnectBandwidth().toJava() >= neededBW && nbll.getTpList() != null
 337                         && nbll.getTpList().contains(tp1.getTpId()) && nbll.getTpList().contains(tp2.getTpId())) {
 338                     LOG.debug("validateSwitchingPoolBandwidth: couple  of tp {} x {} valid for crossconnection",
 339                         tp1.getTpId(), tp2.getTpId());
 340                     return true;
 341                 }
 342             }
 343         }
 344         LOG.debug("validateSwitchingPoolBandwidth: No valid Switching pool for crossconnecting tp {} and {}",
 345             tp1.getTpId(), tp2.getTpId());
 346         return false;
 347     }
 348
 349     public void validateIntermediateSwitch() {
 350         if (!isValid()) {
 351             return;
 352         }
 353         if (this.nodeType != OpenroadmNodeType.SWITCH) {
 354             return;
 355         }
 356         // Validate switch for use as an intermediate XPONDER on the path
 357         initXndrTps("intermediate");
 358         if (this.valid) {
 359             LOG.info("validateIntermediateSwitch: Switch usable for transit == {}", nodeId.getValue());
 360         } else {
 361             LOG.debug("validateIntermediateSwitch: Switch unusable for transit == {}", nodeId.getValue());
 362         }
 363     }
 364
 365     public void checkAvailableTribPort() {
 366         for (TerminationPoint tp :
 367             node.augmentation(
 368                     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 369                         .Node1.class)
 370                 .getTerminationPoint().values().stream()
 371                 .filter(type -> type
 372                     .augmentation(
 373                         org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
 374                             .TerminationPoint1.class)
 375                     .getTpType()
 376                     .equals(OpenroadmTpType.XPONDERNETWORK))
 377                 .collect(Collectors.toList())) {
 378             XpdrTpPortConnectionAttributes portConAttr =
 379                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 380             if (portConAttr != null
 381                 && portConAttr.getOdtuTpnPool() != null
 382                 && (portConAttr.getOdtuTpnPool().values().stream().findFirst().get().getOdtuType()
 383                         .equals(ODTU4TsAllocated.class)
 384                     || portConAttr.getOdtuTpnPool().values().stream().findFirst().get().getOdtuType()
 385                         .equals(ODTUCnTs.class))) {
 386             //TODO a dedicated method for OdtuTpnPool first value would probably be welcome
 387                 List<Uint16> tpnPool =
 388                     portConAttr.getOdtuTpnPool().values().stream().findFirst().get().getTpnPool();
 389                 if (tpnPool != null) {
 390                     tpAvailableTribPort.put(tp.getTpId().getValue(), tpnPool);
 391                 }
 392             }
 393         }
 394     }
 395
 396     public void checkAvailableTribSlot() {
 397         for (TerminationPoint tp :
 398             node.augmentation(
 399                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 400             .getTerminationPoint().values().stream()
 401             .filter(type -> type
 402                 .augmentation(
 403                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1.class)
 404                 .getTpType().equals(OpenroadmTpType.XPONDERNETWORK))
 405             .collect(Collectors.toList())
 406         ) {
 407             XpdrTpPortConnectionAttributes portConAttr =
 408                 tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
 409             if (portConAttr != null && portConAttr.getTsPool() != null) {
 410                 tpAvailableTribSlot.put(tp.getTpId().getValue(), portConAttr.getTsPool());
 411             }
 412         }
 413     }
 414
 415     public boolean isValid() {
 416         if (node == null || nodeId == null || nodeType == null || this.getSupNetworkNodeId() == null
 417                 || this.getSupClliNodeId() == null) {
 418             LOG.error("PceNode: one of parameters is not populated : nodeId, node type, supporting nodeId");
 419             valid = false;
 420         }
 421         return valid;
 422     }
 423
 424     public boolean isPceOtnNodeValid(final PceOtnNode pceOtnNode) {
 425         if (pceOtnNode == null || pceOtnNode.node == null || pceOtnNode.getNodeId() == null
 426                 || pceOtnNode.nodeType == null || pceOtnNode.getSupNetworkNodeId() == null
 427                 || pceOtnNode.getSupClliNodeId() == null || pceOtnNode.otnServiceType == null) {
 428             LOG.error(
 429                 "PceOtnNode: one of parameters is not populated : nodeId, node type, supporting nodeId, otnServiceType"
 430             );
 431             return false;
 432         }
 433         if (isNodeTypeValid(pceOtnNode)) {
 434             return isOtnServiceTypeValid(pceOtnNode);
 435         }
 436         LOG.error("PceOtnNode node type: node type is not one of MUXPDR or SWITCH or TPDR");
 437         return false;
 438     }
 439
 440     private boolean isOtnServiceTypeValid(PceOtnNode pceOtnNode) {
 441         if (pceOtnNode.modeType == null) {
 442             return false;
 443         }
 444         //Todo refactor Strings (mode and otnServiceType ) to enums
 445         if (pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_ODU4)
 446                 && pceOtnNode.modeType.equals("AZ")) {
 447             return true;
 448         }
 449         return (pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_10GE)
 450                 || pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_1GE)
 451                 || pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_100GE_S))
 452                 && (isAz(pceOtnNode) || isIntermediate(pceOtnNode));
 453         //TODO serviceTypeEthTsNbMap.containsKey(this.otnServiceType) might be more appropriate here
 454         //     but only SERVICE_TYPE_100GE_S is managed and not SERVICE_TYPE_100GE_M and _T
 455     }
 456
 457     private boolean isIntermediate(PceOtnNode pceOtnNode) {
 458         return pceOtnNode.modeType.equals("intermediate")
 459                 && checkSwPool(null, pceOtnNode.availableXpdrNWTps, 0, 2);
 460     }
 461
 462     private boolean isAz(PceOtnNode pceOtnNode) {
 463         return pceOtnNode.modeType.equals("AZ")
 464                 && checkSwPool(pceOtnNode.availableXpdrClientTps, pceOtnNode.availableXpdrNWTps, 1, 1);
 465     }
 466
 467     private boolean isNodeTypeValid(final PceOtnNode pceOtnNode) {
 468         return pceOtnNode.nodeType == OpenroadmNodeType.MUXPDR
 469                 || pceOtnNode.nodeType  == OpenroadmNodeType.SWITCH
 470                 || pceOtnNode.nodeType  == OpenroadmNodeType.TPDR;
 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 }