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