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