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