tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiFullTopo.java

   1 /*
   2  * Copyright © 2021 Nokia.  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 package org.opendaylight.transportpce.tapi.topology;
   9
  10 import java.nio.charset.Charset;
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19 import java.util.stream.Collectors;
  20 import org.opendaylight.transportpce.tapi.TapiStringConstants;
  21 import org.opendaylight.transportpce.tapi.utils.TapiLink;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Link1;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPools;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmTpType;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.Node1;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  39 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
  40 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Direction;
  41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LifecycleState;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.PortRole;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.capacity.pac.AvailableCapacityBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.capacity.pac.TotalPotentialCapacityBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePoint;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointKey;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU0;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2E;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU4;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE100GigE;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE10GigELAN;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPEGigE;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROMS;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSiMC;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupKey;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointKey;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePoint;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointKey;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstances;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleKey;
  80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristic;
  81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristicBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
  83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
  84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
  86 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristic;
  87 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristicBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristic;
  89 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristicBuilder;
  90 import org.opendaylight.yangtools.yang.common.Uint16;
  91 import org.opendaylight.yangtools.yang.common.Uint64;
  92 import org.slf4j.Logger;
  93 import org.slf4j.LoggerFactory;
  94
  95
  96 public class ConvertORTopoToTapiFullTopo {
  97
  98     private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiFullTopo.class);
  99     private String ietfNodeId;
 100     private OpenroadmNodeType ietfNodeType;
 101     private AdminStates ietfNodeAdminState;
 102     private State ietfNodeOperState;
 103     private List<TerminationPoint> oorClientPortList;
 104     private List<TerminationPoint> oorNetworkPortList;
 105     private OduSwitchingPools oorOduSwitchingPool;
 106     private Uuid tapiTopoUuid;
 107     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 108         tapiNodes;
 109     private Map<LinkKey, Link> tapiLinks;
 110     private Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSips;
 111     private Map<String, Uuid> uuidMap;
 112     private final TapiLink tapiLink;
 113
 114
 115     public ConvertORTopoToTapiFullTopo(Uuid tapiTopoUuid, TapiLink tapiLink) {
 116         this.tapiTopoUuid = tapiTopoUuid;
 117         this.tapiNodes = new HashMap<>();
 118         this.tapiLinks = new HashMap<>();
 119         this.uuidMap = new HashMap<>();
 120         this.tapiSips = new HashMap<>();
 121         this.tapiLink = tapiLink;
 122     }
 123
 124     public void convertNode(Node ietfNode, List<String> networkPorts) {
 125         this.ietfNodeId = ietfNode.getNodeId().getValue();
 126         if (ietfNode.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 127                 == null) {
 128             return;
 129         }
 130         this.ietfNodeType = ietfNode.augmentation(
 131             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class).getNodeType();
 132         this.ietfNodeAdminState = ietfNode.augmentation(
 133             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 134                 .getAdministrativeState();
 135         this.ietfNodeOperState = ietfNode.augmentation(
 136             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 137                 .getOperationalState();
 138         this.oorNetworkPortList = ietfNode.augmentation(
 139             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 140                 .getTerminationPoint().values().stream()
 141                 .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 142                     == OpenroadmTpType.XPONDERNETWORK.getIntValue()
 143                     && networkPorts.contains(tp.getTpId().getValue()))
 144                 .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 145                 .collect(Collectors.toList());
 146         if (!OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 147             this.oorOduSwitchingPool = ietfNode.augmentation(Node1.class).getSwitchingPools().getOduSwitchingPools()
 148                 .values().stream().findFirst().orElseThrow();
 149             this.oorClientPortList = ietfNode.augmentation(
 150                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 151                     .getTerminationPoint().values().stream()
 152                     .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 153                         == OpenroadmTpType.XPONDERCLIENT.getIntValue())
 154                     .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 155                     .collect(Collectors.toList());
 156         } else {
 157             this.oorOduSwitchingPool = createOduSwitchingPoolForTp100G();
 158             List<TpId> tpList = this.oorOduSwitchingPool.getNonBlockingList().values().stream()
 159                 .flatMap(nbl -> nbl.getTpList().stream())
 160                 .collect(Collectors.toList());
 161             this.oorClientPortList = ietfNode.augmentation(
 162                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 163                     .getTerminationPoint().values().stream()
 164                     .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 165                         == OpenroadmTpType.XPONDERCLIENT.getIntValue() && tpList.contains(tp.getTpId()))
 166                     .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 167                     .collect(Collectors.toList());
 168             this.oorClientPortList.forEach(tp -> LOG.info("tp = {}", tp.getTpId()));
 169         }
 170
 171         // node creation XPDR ([DSR/ODU] and OTSI merged in R 2.4.X
 172         LOG.info("creation of a DSR/ODU node for {}", this.ietfNodeId);
 173         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId,
 174             TapiStringConstants.XPDR)).getBytes(Charset.forName("UTF-8"))).toString());
 175         this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.XPDR), nodeUuid);
 176         Name nameDsrNode = new NameBuilder().setValueName("dsr/odu node name").setValue(
 177             String.join("+", this.ietfNodeId, TapiStringConstants.DSR)).build();
 178 //        Name nameOtsiNode =  new NameBuilder().setValueName("otsi node name").setValue(
 179 //            String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)).build();
 180         Name nameNodeType = new NameBuilder().setValueName("Node Type")
 181             .setValue(this.ietfNodeType.getName()).build();
 182         Set<LayerProtocolName> dsrLayerProtocols = Set.of(LayerProtocolName.DSR, LayerProtocolName.ODU,
 183             LayerProtocolName.PHOTONICMEDIA);
 184         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology
 185             .Node dsrNode = createTapiNode(Map.of(nameDsrNode.key(), nameDsrNode, nameNodeType.key(), nameNodeType),
 186             dsrLayerProtocols);
 187         LOG.info("XPDR Node {} should have {} NEPs and {} SIPs", this.ietfNodeId,
 188             this.oorClientPortList.size() + this.oorNetworkPortList.size(),
 189             this.oorClientPortList.size() + this.oorNetworkPortList.size());
 190         LOG.info("XPDR Node {} has {} NEPs and {} SIPs", this.ietfNodeId,
 191             dsrNode.getOwnedNodeEdgePoint().values().size(), dsrNode.getOwnedNodeEdgePoint().values().stream()
 192                 .filter(nep -> nep.getMappedServiceInterfacePoint() != null).count());
 193         tapiNodes.put(dsrNode.key(), dsrNode);
 194     }
 195
 196     public void convertRdmToRdmLinks(List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 197             .ietf.network.topology.rev180226.networks.network.Link> rdmTordmLinkList) {
 198         List<String> linksToNotConvert = new ArrayList<>();
 199         LOG.info("creation of {} roadm to roadm links", rdmTordmLinkList.size() / 2);
 200         for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 201             .Link link : rdmTordmLinkList) {
 202             if (!linksToNotConvert.contains(link.getLinkId().getValue())) {
 203                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 204                         .ietf.network.topology.rev180226.networks.network.Link oppositeLink = rdmTordmLinkList.stream()
 205                     .filter(l -> l.getLinkId().equals(link.augmentation(Link1.class).getOppositeLink()))
 206                     .findAny().orElse(null);
 207
 208                 AdminStates oppLnkAdmState = null;
 209                 State oppLnkOpState = null;
 210                 if (oppositeLink != null) {
 211                     oppLnkAdmState = oppositeLink.augmentation(Link1.class).getAdministrativeState();
 212                     oppLnkOpState = oppositeLink.augmentation(Link1.class).getOperationalState();
 213                 }
 214                 String adminState =
 215                     link.augmentation(Link1.class).getAdministrativeState() == null
 216                         || oppLnkAdmState == null
 217                     ? null
 218                     : this.tapiLink.setTapiAdminState(
 219                         link.augmentation(Link1.class).getAdministrativeState(), oppLnkAdmState).getName();
 220                 String operState =
 221                     link.augmentation(Link1.class).getOperationalState() == null
 222                         || oppLnkOpState == null
 223                     ? null
 224                     : this.tapiLink.setTapiOperationalState(
 225                         link.augmentation(Link1.class).getOperationalState(), oppLnkOpState).getName();
 226
 227                 Link tapLink = this.tapiLink.createTapiLink(String.join("-",
 228                         link.getSource().getSourceNode().getValue().split("-")[0],
 229                         link.getSource().getSourceNode().getValue().split("-")[1]),
 230                     link.getSource().getSourceTp().getValue(), String.join("-",
 231                         link.getDestination().getDestNode().getValue().split("-")[0],
 232                         link.getDestination().getDestNode().getValue().split("-")[1]),
 233                     link.getDestination().getDestTp().getValue(), TapiStringConstants.OMS_RDM_RDM_LINK,
 234                     TapiStringConstants.PHTNC_MEDIA, TapiStringConstants.PHTNC_MEDIA, TapiStringConstants.PHTNC_MEDIA,
 235                     TapiStringConstants.PHTNC_MEDIA, adminState, operState, Set.of(LayerProtocolName.PHOTONICMEDIA),
 236                     Set.of(LayerProtocolName.PHOTONICMEDIA.getName()), this.tapiTopoUuid);
 237                 linksToNotConvert.add(link
 238                     .augmentation(Link1.class)
 239                     .getOppositeLink().getValue());
 240                 tapiLinks.put(tapLink.key(), tapLink);
 241             }
 242         }
 243     }
 244
 245     public void convertRoadmNode(Node roadm, Network openroadmTopo) {
 246         this.ietfNodeId = roadm.getNodeId().getValue();
 247         this.ietfNodeType = roadm.augmentation(
 248             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class).getNodeType();
 249         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> oneplist = new HashMap<>();
 250         // 1. Get degree and srg nodes to map TPs into NEPs
 251         if (openroadmTopo.getNode() == null) {
 252             LOG.warn("Openroadm-topology is null.");
 253             return;
 254         }
 255         int numNeps = 0;
 256         int numSips = 0;
 257         List<Node> nodeList = new ArrayList<Node>(openroadmTopo.getNode().values());
 258         for (Node node:nodeList) {
 259             if (node.getSupportingNode().values().stream().noneMatch(sp -> sp.getNodeRef().getValue()
 260                 .equals(this.ietfNodeId))) {
 261                 LOG.warn("Abstracted node {} is not part of {}",
 262                     node.getNodeId().getValue(), this.ietfNodeId);
 263                 continue;
 264             }
 265             if (node.augmentation(Node1.class) == null
 266                 && node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 267                 .ietf.network.topology.rev180226.Node1.class) == null) {
 268                 LOG.warn("Abstracted node {} doesnt have type of node or is not disaggregated",
 269                     node.getNodeId().getValue());
 270                 continue;
 271             }
 272             OpenroadmNodeType nodeType = node.augmentation(org.opendaylight.yang.gen.v1.http
 273                 .org.openroadm.common.network.rev230526.Node1.class).getNodeType();
 274             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 node1 =
 275                 node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 276                     .ietf.network.topology.rev180226.Node1.class);
 277             LOG.info("TPs of node: {}", node1.getTerminationPoint().values());
 278             switch (nodeType.getIntValue()) {
 279                 case 11:
 280                     LOG.info("Degree node");
 281                     // Get only external TPs of the degree
 282                     List<TerminationPoint> degPortList = node1.getTerminationPoint().values().stream()
 283                         .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 284                             == OpenroadmTpType.DEGREETXRXTTP.getIntValue()
 285                             || tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 286                             == OpenroadmTpType.DEGREERXTTP.getIntValue()
 287                             || tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 288                             == OpenroadmTpType.DEGREETXTTP.getIntValue())
 289                         .collect(Collectors.toList());
 290                     // Convert TP List in NEPs and put it in onepl
 291                     LOG.info("Degree port List: {}", degPortList);
 292                     // TODO: deg port could be sip. e.g. MDONS
 293                     oneplist.putAll(populateNepsForRdmNode(degPortList, false, TapiStringConstants.PHTNC_MEDIA_OTS));
 294                     oneplist.putAll(populateNepsForRdmNode(degPortList, false, TapiStringConstants.PHTNC_MEDIA_OMS));
 295                     // oneplist.putAll(populateNepsForRdmNode(node.getNodeId().getValue(), degPortList, false
 296                     //, TapiStringConstants.PHTNC_MEDIA_OTS));
 297                     numNeps += degPortList.size() * 2;
 298                     break;
 299                 case 12:
 300                     LOG.info("SRG node");
 301                     // Get only external TPs of the srg
 302                     List<TerminationPoint> srgPortList = node1.getTerminationPoint().values().stream()
 303                         .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 304                             == OpenroadmTpType.SRGTXRXPP.getIntValue()
 305                             || tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 306                             == OpenroadmTpType.SRGRXPP.getIntValue()
 307                             || tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 308                             == OpenroadmTpType.SRGTXPP.getIntValue())
 309                         .collect(Collectors.toList());
 310                     // Convert TP List in NEPs and put it in onepl
 311                     LOG.info("Srg port List: {}", srgPortList);
 312                     oneplist.putAll(populateNepsForRdmNode(srgPortList, true, TapiStringConstants.PHTNC_MEDIA_OTS));
 313                     // oneplist.putAll(populateNepsForRdmNode(node.getNodeId().getValue(), srgPortList, true
 314                     // TapiStringConstants.PHTNC_MEDIA_OTS));
 315                     numNeps += srgPortList.size();
 316                     numSips += srgPortList.size();
 317                     break;
 318                 default:
 319                     LOG.error("Node {} type not supported", nodeType.getName());
 320             }
 321         }
 322         // create tapi Node
 323         // UUID
 324         LOG.info("Creation of PHOTONIC node for {}", roadm.getNodeId().getValue());
 325         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", roadm.getNodeId().getValue(),
 326             TapiStringConstants.PHTNC_MEDIA)).getBytes(Charset.forName("UTF-8"))).toString());
 327         // Names
 328         Name nodeNames =  new NameBuilder().setValueName("roadm node name")
 329             .setValue(String.join("+", roadm.getNodeId().getValue(), TapiStringConstants.PHTNC_MEDIA)).build();
 330         Name nameNodeType = new NameBuilder().setValueName("Node Type")
 331             .setValue(this.ietfNodeType.getName()).build();
 332         // Protocol Layer
 333         Set<LayerProtocolName> layerProtocols = Set.of(LayerProtocolName.PHOTONICMEDIA);
 334         // Build tapi node
 335         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology
 336             .Node roadmNode = createRoadmTapiNode(nodeUuid,
 337             Map.of(nodeNames.key(), nodeNames, nameNodeType.key(), nameNodeType), layerProtocols, oneplist);
 338         // TODO add states corresponding to device config
 339         LOG.info("ROADM node {} should have {} NEPs and {} SIPs", roadm.getNodeId().getValue(), numNeps, numSips);
 340         LOG.info("ROADM node {} has {} NEPs and {} SIPs", roadm.getNodeId().getValue(),
 341             roadmNode.nonnullOwnedNodeEdgePoint().values().size(),
 342             roadmNode.nonnullOwnedNodeEdgePoint().values().stream()
 343                 .filter(nep -> nep.getMappedServiceInterfacePoint() != null).count());
 344
 345         tapiNodes.put(roadmNode.key(), roadmNode);
 346     }
 347
 348     private OduSwitchingPools createOduSwitchingPoolForTp100G() {
 349         Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
 350         int count = 1;
 351         for (TerminationPoint tp : this.oorNetworkPortList) {
 352             TpId tpid1 = tp.getTpId();
 353             TpId tpid2 = tp.augmentation(
 354                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1.class)
 355                     .getAssociatedConnectionMapTp().iterator().next();
 356             Set<TpId> tpList = new HashSet<>();
 357             tpList.add(tpid1);
 358             tpList.add(tpid2);
 359             NonBlockingList nbl = new NonBlockingListBuilder()
 360                 .setNblNumber(Uint16.valueOf(count))
 361                 .setTpList(tpList)
 362                 .build();
 363             nblMap.put(nbl.key(), nbl);
 364             count++;
 365         }
 366         return new OduSwitchingPoolsBuilder()
 367             .setNonBlockingList(nblMap)
 368             .setSwitchingPoolNumber(Uint16.valueOf(1))
 369             .build();
 370     }
 371
 372     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node
 373             createTapiNode(Map<NameKey, Name> nodeNames, Set<LayerProtocolName> layerProtocols) {
 374         Uuid nodeUuid = null;
 375         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 376         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList = new HashMap<>();
 377         Map<RuleKey, Rule> ruleList = new HashMap<>();
 378         Set<RuleType> ruleTypes = new HashSet<>();
 379         ruleTypes.add(RuleType.FORWARDING);
 380         Rule rule = new RuleBuilder()
 381             .setLocalId("forward")
 382             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 383             .setRuleType(ruleTypes)
 384             .build();
 385         ruleList.put(rule.key(), rule);
 386         if (layerProtocols.contains(LayerProtocolName.DSR)) {
 387             nodeUuid = getNodeUuid4Dsr(onepl, nodeRuleGroupList, ruleList);
 388         } else if (layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
 389             nodeUuid = getNodeUuid4Photonic(onepl, nodeRuleGroupList, ruleList);
 390         } else {
 391             LOG.error("Undefined LayerProtocolName for {} node {}", nodeNames.get(nodeNames.keySet().iterator().next())
 392                 .getValueName(), nodeNames.get(nodeNames.keySet().iterator().next()).getValue());
 393         }
 394         // Empty random creation of mandatory fields for avoiding errors....
 395         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 396             .setCostAlgorithm("Restricted Shortest Path - RSP")
 397             .setCostName("HOP_COUNT")
 398             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 399             .build();
 400         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 401             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 402             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 403             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 404             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 405             .setTrafficPropertyName("FIXED_LATENCY")
 406             .build();
 407         return new NodeBuilder()
 408             .setUuid(nodeUuid)
 409             .setName(nodeNames)
 410             .setLayerProtocolName(layerProtocols)
 411             .setAdministrativeState(this.tapiLink.setTapiAdminState(this.ietfNodeAdminState.getName()))
 412             .setOperationalState(this.tapiLink.setTapiOperationalState(this.ietfNodeOperState.getName()))
 413             .setLifecycleState(LifecycleState.INSTALLED)
 414             .setOwnedNodeEdgePoint(onepl)
 415             .setNodeRuleGroup(nodeRuleGroupList)
 416             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 417             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 418             .setErrorCharacteristic("error")
 419             .setLossCharacteristic("loss")
 420             .setRepeatDeliveryCharacteristic("repeat delivery")
 421             .setDeliveryOrderCharacteristic("delivery order")
 422             .setUnavailableTimeCharacteristic("unavailable time")
 423             .setServerIntegrityProcessCharacteristic("server integrity process")
 424             .build();
 425     }
 426
 427     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node
 428                 createRoadmTapiNode(Uuid nodeUuid, Map<NameKey, Name> nameMap, Set<LayerProtocolName> layerProtocols,
 429                         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> oneplist) {
 430         // Empty random creation of mandatory fields for avoiding errors....
 431         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 432             .setCostAlgorithm("Restricted Shortest Path - RSP")
 433             .setCostName("HOP_COUNT")
 434             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 435             .build();
 436         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 437             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 438             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 439             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 440             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 441             .setTrafficPropertyName("FIXED_LATENCY")
 442             .build();
 443         return new NodeBuilder()
 444             .setUuid(nodeUuid)
 445             .setName(nameMap)
 446             .setLayerProtocolName(layerProtocols)
 447             .setAdministrativeState(AdministrativeState.UNLOCKED)
 448             .setOperationalState(OperationalState.ENABLED)
 449             .setLifecycleState(LifecycleState.INSTALLED)
 450             .setOwnedNodeEdgePoint(oneplist)
 451             .setNodeRuleGroup(createNodeRuleGroupForRdmNode(nodeUuid, oneplist.values()))
 452             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 453             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 454             .setErrorCharacteristic("error")
 455             .setLossCharacteristic("loss")
 456             .setRepeatDeliveryCharacteristic("repeat delivery")
 457             .setDeliveryOrderCharacteristic("delivery order")
 458             .setUnavailableTimeCharacteristic("unavailable time")
 459             .setServerIntegrityProcessCharacteristic("server integrity process")
 460             .build();
 461     }
 462
 463     private Uuid getNodeUuid4Photonic(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 464                                       Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList,
 465                                       Map<RuleKey, Rule> ruleList) {
 466         Uuid nodeUuid;
 467         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI));
 468         // iNep creation on otsi node
 469         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 470             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 471                 oorNetworkPortList.get(i).getTpId().getValue()));
 472             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(
 473                 (String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 474                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 475                 .toString());
 476             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 477                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid1);
 478             Name onedName = new NameBuilder()
 479                 .setValueName("iNodeEdgePoint")
 480                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 481                     oorNetworkPortList.get(i).getTpId().getValue()))
 482                 .build();
 483
 484             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 485                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 486                 String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI));
 487             onepl.put(onep.key(), onep);
 488         }
 489         // eNep creation on otsi node
 490         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 491             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 492                 oorNetworkPortList.get(i).getTpId().getValue()));
 493             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(
 494                 (String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 495                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 496                 .toString());
 497             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 498                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid2);
 499             Name onedName = new NameBuilder()
 500                 .setValueName("eNodeEdgePoint")
 501                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 502                     oorNetworkPortList.get(i).getTpId().getValue()))
 503                 .build();
 504
 505             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 506                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, false,
 507                 String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI));
 508             onepl.put(onep.key(), onep);
 509         }
 510         // Photonic Media Nep creation on otsi node
 511         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 512             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA,
 513                 oorNetworkPortList.get(i).getTpId().getValue()));
 514             Uuid nepUuid3 = new Uuid(UUID.nameUUIDFromBytes(
 515                 (String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA,
 516                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 517                 .toString());
 518             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA,
 519                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid3);
 520             Name onedName = new NameBuilder()
 521                 .setValueName("PhotMedNodeEdgePoint")
 522                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA,
 523                     oorNetworkPortList.get(i).getTpId().getValue()))
 524                 .build();
 525
 526             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 527                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, false,
 528                 String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA));
 529             onepl.put(onep.key(), onep);
 530         }
 531         // create NodeRuleGroup
 532         int count = 1;
 533         LOG.info("OTSi switching pool = {}", this.oorOduSwitchingPool.nonnullNonBlockingList().values());
 534         for (TerminationPoint tp : this.oorNetworkPortList) {
 535             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 536                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 537                 nepList = new HashMap<>();
 538             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 539                 .NodeEdgePoint inep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
 540                 .node.rule.group.NodeEdgePointBuilder()
 541                 .setTopologyUuid(tapiTopoUuid)
 542                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)))
 543                 .setNodeEdgePointUuid(
 544                     this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 545                         tp.getTpId().getValue())))
 546                 .build();
 547             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 548                 .NodeEdgePoint enep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
 549                 .node.rule.group.NodeEdgePointBuilder()
 550                 .setTopologyUuid(tapiTopoUuid)
 551                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)))
 552                 .setNodeEdgePointUuid(
 553                     this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 554                         tp.getTpId().getValue())))
 555                 .build();
 556             nepList.put(inep.key(), inep);
 557             nepList.put(enep.key(), enep);
 558             // Empty random creation of mandatory fields for avoiding errors....
 559             CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 560                 .setCostAlgorithm("Restricted Shortest Path - RSP")
 561                 .setCostName("HOP_COUNT")
 562                 .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 563                 .build();
 564             LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 565                 .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 566                 .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 567                 .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 568                 .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 569                 .setTrafficPropertyName("FIXED_LATENCY")
 570                 .build();
 571             RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 572                 .setRiskCharacteristicName("risk characteristic")
 573                 .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 574                 .build();
 575             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 576                 .setUuid(new Uuid(
 577                     UUID.nameUUIDFromBytes(("otsi node rule group " + count).getBytes(Charset.forName("UTF-8")))
 578                         .toString()))
 579                 .setRule(ruleList)
 580                 .setNodeEdgePoint(nepList)
 581                 .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 582                 .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 583                 .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 584                 .build();
 585             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 586             count++;
 587         }
 588         return nodeUuid;
 589     }
 590
 591     private Uuid getNodeUuid4Dsr(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 592                                  Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
 593         Uuid nodeUuid;
 594         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.DSR));
 595         // client nep creation on DSR node
 596         for (int i = 0; i < oorClientPortList.size(); i++) {
 597             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 598                 oorClientPortList.get(i).getTpId().getValue()));
 599             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 600                 (String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 601                     oorClientPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 602             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 603                     oorClientPortList.get(i).getTpId().getValue()), nepUuid);
 604             NameBuilder nameBldr = new NameBuilder().setValue(
 605                 String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 606                     oorClientPortList.get(i).getTpId().getValue()));
 607             Name name;
 608             if (OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 609                 name = nameBldr.setValueName("100G-tpdr").build();
 610             } else {
 611                 name = nameBldr.setValueName("NodeEdgePoint_C").build();
 612             }
 613
 614             OwnedNodeEdgePoint onep = createNep(oorClientPortList.get(i), Map.of(name.key(), name),
 615                 LayerProtocolName.DSR, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 616                     TapiStringConstants.DSR));
 617             onepl.put(onep.key(), onep);
 618         }
 619         // network nep creation on I_ODU node
 620         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 621             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 622                 oorNetworkPortList.get(i).getTpId().getValue()));
 623             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 624                 (String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 625                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 626             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 627                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid);
 628             Name onedName = new NameBuilder()
 629                 .setValueName("iNodeEdgePoint_N")
 630                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 631                     oorNetworkPortList.get(i).getTpId().getValue()))
 632                 .build();
 633
 634             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 635                 LayerProtocolName.ODU, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 636                     TapiStringConstants.I_ODU));
 637             onepl.put(onep.key(), onep);
 638         }
 639         // network nep creation on E_ODU node
 640         for (int i = 0; i < oorClientPortList.size(); i++) {
 641             LOG.info("NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU,
 642                 oorClientPortList.get(i).getTpId().getValue()));
 643             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 644                 (String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU,
 645                     oorClientPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 646             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU,
 647                 oorClientPortList.get(i).getTpId().getValue()), nepUuid);
 648             Name onedName = new NameBuilder()
 649                 .setValueName("eNodeEdgePoint_N")
 650                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.E_ODU,
 651                     oorClientPortList.get(i).getTpId().getValue()))
 652                 .build();
 653
 654             OwnedNodeEdgePoint onep = createNep(oorClientPortList.get(i), Map.of(onedName.key(), onedName),
 655                 LayerProtocolName.ODU, LayerProtocolName.DSR, false, String.join("+", this.ietfNodeId,
 656                     TapiStringConstants.E_ODU));
 657             onepl.put(onep.key(), onep);
 658         }
 659         // create NodeRuleGroup
 660         int count = 1;
 661         LOG.info("ODU switching pool = {}", this.oorOduSwitchingPool.nonnullNonBlockingList().values());
 662         for (NonBlockingList nbl : this.oorOduSwitchingPool.nonnullNonBlockingList().values()) {
 663             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 664                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 665                 nepList = new HashMap<>();
 666             LOG.info("UUidMap={}", this.uuidMap.keySet());
 667             LOG.info("TP list = {}", nbl.getTpList());
 668             for (TpId tp : nbl.getTpList()) {
 669                 LOG.info("TP={}", tp.getValue());
 670                 LOG.info("UuidKey={}", String.join("+", this.ietfNodeId,
 671                     TapiStringConstants.E_ODU, tp.getValue()));
 672                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId,
 673                             TapiStringConstants.E_ODU, tp.getValue()))
 674                         && this.uuidMap.containsKey(String.join("+", this.ietfNodeId,
 675                             TapiStringConstants.DSR, tp.getValue()))) {
 676                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 677                         nep1 = new org.opendaylight.yang.gen.v1.urn
 678                         .onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointBuilder()
 679                         .setTopologyUuid(tapiTopoUuid)
 680                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 681                             TapiStringConstants.DSR)))
 682                         .setNodeEdgePointUuid(this.uuidMap.get(String.join(
 683                             "+", this.ietfNodeId, TapiStringConstants.DSR, tp.getValue())))
 684                         .build();
 685                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 686                         nep2 = new org.opendaylight.yang.gen.v1.urn
 687                         .onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointBuilder()
 688                         .setTopologyUuid(tapiTopoUuid)
 689                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 690                             TapiStringConstants.DSR)))
 691                         .setNodeEdgePointUuid(this.uuidMap.get(String.join(
 692                             "+", this.ietfNodeId, TapiStringConstants.E_ODU, tp.getValue())))
 693                         .build();
 694                     nepList.put(nep1.key(), nep1);
 695                     nepList.put(nep2.key(), nep2);
 696                 }
 697             }
 698             // Empty random creation of mandatory fields for avoiding errors....
 699             CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 700                 .setCostAlgorithm("Restricted Shortest Path - RSP")
 701                 .setCostName("HOP_COUNT")
 702                 .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 703                 .build();
 704             LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 705                 .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 706                 .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 707                 .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 708                 .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 709                 .setTrafficPropertyName("FIXED_LATENCY")
 710                 .build();
 711             RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 712                 .setRiskCharacteristicName("risk characteristic")
 713                 .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 714                 .build();
 715             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 716                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(("dsr node rule group " + count)
 717                     .getBytes(Charset.forName("UTF-8"))).toString()))
 718                 .setRule(ruleList)
 719                 .setNodeEdgePoint(nepList)
 720                 .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 721                 .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 722                 .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 723                 .build();
 724             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 725             count++;
 726         }
 727         return nodeUuid;
 728     }
 729
 730     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
 731                                          LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol, boolean withSip,
 732                                          String keyword) {
 733         String key = String.join("+", keyword, oorTp.getTpId().getValue());
 734         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
 735             .setUuid(this.uuidMap.get(key))
 736             .setLayerProtocolName(nepProtocol)
 737             .setName(nepNames);
 738         if (withSip) {
 739             onepBldr.setMappedServiceInterfacePoint(createMSIP(1, nepProtocol, oorTp, keyword));
 740         }
 741         AdministrativeState adminState = null;
 742         OperationalState operState = null;
 743         if (oorTp.augmentation(TerminationPoint1.class).getAdministrativeState() != null) {
 744             adminState = this.tapiLink.setTapiAdminState(oorTp.augmentation(TerminationPoint1.class)
 745                 .getAdministrativeState().getName());
 746         }
 747         if (oorTp.augmentation(TerminationPoint1.class).getOperationalState() != null) {
 748             operState = this.tapiLink.setTapiOperationalState(oorTp.augmentation(TerminationPoint1.class)
 749                 .getOperationalState().getName());
 750         }
 751         onepBldr.setSupportedCepLayerProtocolQualifierInstances(createSupportedLayerProtocolQualifier(oorTp,
 752                 nepProtocol))
 753             .setDirection(Direction.BIDIRECTIONAL)
 754             .setLinkPortRole(PortRole.SYMMETRIC)
 755             .setAdministrativeState(adminState)
 756             .setOperationalState(operState)
 757             .setLifecycleState(LifecycleState.INSTALLED);
 758 //            .setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 759 //            .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL);
 760         return onepBldr.build();
 761     }
 762
 763     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> populateNepsForRdmNode(List<TerminationPoint> tpList,
 764             boolean withSip, String nepPhotonicSublayer) {
 765         // create neps for MC and OTSiMC and Photonic Media
 766         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 767         for (TerminationPoint tp:tpList) {
 768             // Admin and oper state common for all tps
 769             AdminStates admin = tp.augmentation(TerminationPoint1.class).getAdministrativeState();
 770             State oper = tp.augmentation(TerminationPoint1.class).getOperationalState();
 771             // PHOTONIC MEDIA nep
 772             LOG.info("PHOTO NEP = {}", String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA,
 773                 tp.getTpId().getValue()));
 774             Name nepName = new NameBuilder()
 775                 .setValueName(nepPhotonicSublayer + "NodeEdgePoint")
 776                 .setValue(String.join("+", this.ietfNodeId, nepPhotonicSublayer,
 777                     tp.getTpId().getValue()))
 778                 .build();
 779
 780             List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 781             sclpqiList.add(
 782                 new SupportedCepLayerProtocolQualifierInstancesBuilder()
 783                     .setLayerProtocolQualifier(
 784                         TapiStringConstants.PHTNC_MEDIA_OMS.equals(nepPhotonicSublayer)
 785                             ? PHOTONICLAYERQUALIFIEROMS.VALUE
 786                             : PHOTONICLAYERQUALIFIEROTS.VALUE)
 787                     .setNumberOfCepInstances(Uint64.valueOf(1))
 788                     .build());
 789             OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder()
 790                 .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId,
 791                     nepPhotonicSublayer, tp.getTpId().getValue()))
 792                     .getBytes(Charset.forName("UTF-8"))).toString()))
 793                 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA)
 794                 .setName(Map.of(nepName.key(), nepName))
 795                 .setSupportedCepLayerProtocolQualifierInstances(sclpqiList)
 796                 .setDirection(Direction.BIDIRECTIONAL)
 797                 .setLinkPortRole(PortRole.SYMMETRIC)
 798                 .setAdministrativeState(this.tapiLink.setTapiAdminState(admin.getName()))
 799                 .setOperationalState(this.tapiLink.setTapiOperationalState(oper.getName()))
 800                 .setLifecycleState(LifecycleState.INSTALLED)
 801 //                .setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 802 //                .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL)
 803                 .build();
 804             onepMap.put(onep.key(), onep);
 805         }
 806         return onepMap;
 807     }
 808
 809     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(Uuid nodeUuid,
 810                                                                                Collection<OwnedNodeEdgePoint> onepl) {
 811         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 812             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 813             nepMap = new HashMap<>();
 814         for (OwnedNodeEdgePoint onep : onepl) {
 815             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 816                 nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 817                 .NodeEdgePointBuilder()
 818                 .setTopologyUuid(tapiTopoUuid)
 819                 .setNodeUuid(nodeUuid)
 820                 .setNodeEdgePointUuid(onep.key().getUuid())
 821                 .build();
 822             nepMap.put(nep.key(), nep);
 823         }
 824         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
 825         Map<RuleKey, Rule> ruleList = new HashMap<>();
 826         Set<RuleType> ruleTypes = new HashSet<>();
 827         ruleTypes.add(RuleType.FORWARDING);
 828         Rule rule = new RuleBuilder()
 829             .setLocalId("forward")
 830             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 831             .setRuleType(ruleTypes)
 832             .build();
 833         ruleList.put(rule.key(), rule);
 834         NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 835             .setUuid(new Uuid(UUID.nameUUIDFromBytes((this.ietfNodeId + " node rule group")
 836                 .getBytes(Charset.forName("UTF-8"))).toString()))
 837             .setRule(ruleList)
 838             .setNodeEdgePoint(nepMap)
 839             .build();
 840         nodeRuleGroupMap.put(nodeRuleGroup.key(), nodeRuleGroup);
 841         return nodeRuleGroupMap;
 842     }
 843
 844     private Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createMSIP(int nb,
 845                                                                                         LayerProtocolName layerProtocol,
 846                                                                                         TerminationPoint tp,
 847                                                                                         String nodeid) {
 848         // add them to SIP context
 849         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
 850         for (int i = 0; i < nb; i++) {
 851             LOG.info("SIP = {}", String.join("+", "SIP", nodeid, tp.getTpId().getValue()));
 852             Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeid,
 853                 tp.getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 854             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
 855                 .setServiceInterfacePointUuid(sipUuid).build();
 856             ServiceInterfacePoint sip = createSIP(sipUuid, layerProtocol, tp, nodeid);
 857             this.tapiSips.put(sip.key(), sip);
 858             msipl.put(msip.key(), msip);
 859         }
 860         return msipl;
 861     }
 862
 863     private ServiceInterfacePoint createSIP(Uuid sipUuid, LayerProtocolName layerProtocol, TerminationPoint tp,
 864                                             String nodeid) {
 865         // TODO: what value should be set in total capacity and available capacity??
 866         // LOG.info("SIP name = {}", String.join("+", nodeid, tp.getTpId().getValue()));
 867         Name sipName = new NameBuilder()
 868             .setValueName("SIP name")
 869             .setValue(String.join("+", nodeid, tp.getTpId().getValue()))
 870             .build();
 871         AdministrativeState adminState = null;
 872         OperationalState operState = null;
 873         if (tp.augmentation(TerminationPoint1.class).getAdministrativeState() != null) {
 874             adminState = this.tapiLink.setTapiAdminState(tp.augmentation(TerminationPoint1.class)
 875                 .getAdministrativeState().getName());
 876         }
 877         if (tp.augmentation(TerminationPoint1.class).getOperationalState() != null) {
 878             operState = this.tapiLink.setTapiOperationalState(tp.augmentation(TerminationPoint1.class)
 879                 .getOperationalState().getName());
 880         }
 881         return new ServiceInterfacePointBuilder()
 882             .setUuid(sipUuid)
 883             .setName(Map.of(sipName.key(), sipName))
 884             .setLayerProtocolName(layerProtocol)
 885             .setAdministrativeState(adminState)
 886             .setOperationalState(operState)
 887             .setLifecycleState(LifecycleState.INSTALLED)
 888             .setAvailableCapacity(new AvailableCapacityBuilder().build())
 889             .setTotalPotentialCapacity(new TotalPotentialCapacityBuilder().build())
 890             .setSupportedCepLayerProtocolQualifierInstances(createSipSupportedLayerProtocolQualifier(
 891                 tp, layerProtocol))
 892             .build();
 893     }
 894
 895     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 896             .service._interface.point.SupportedCepLayerProtocolQualifierInstances>
 897             createSipSupportedLayerProtocolQualifier(TerminationPoint tp,
 898             LayerProtocolName lpn) {
 899         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 900             .service._interface.point.SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 901         sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 902                 .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 903             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
 904             .setNumberOfCepInstances(Uint64.valueOf(1))
 905             .build());
 906         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1 tp1 =
 907             tp.augmentation(org.opendaylight.yang.gen.v1.http
 908                 .org.openroadm.otn.network.topology.rev230526.TerminationPoint1.class);
 909         if (tp1 == null) {
 910             return new ArrayList<>(sclpqiList);
 911         }
 912         if (tp1.getTpSupportedInterfaces() == null) {
 913             LOG.warn("Tp supported interface doesnt exist on TP {}", tp.getTpId().getValue());
 914             return new ArrayList<>(sclpqiList);
 915         }
 916         Collection<SupportedInterfaceCapability> sicList = tp1.getTpSupportedInterfaces()
 917             .getSupportedInterfaceCapability().values();
 918         for (SupportedInterfaceCapability sic : sicList) {
 919             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
 920             switch (lpn.getName()) {
 921                 case "DSR":
 922                     switch (ifCapType) {
 923                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
 924                         //  port are extended in the config file
 925                         case "If1GEODU0":
 926                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 927                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 928                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 929                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 930                                 .build());
 931                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 932                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 933                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
 934                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 935                                 .build());
 936                             break;
 937                         case "If10GEODU2e":
 938                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 939                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 940                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 941                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 942                                 .build());
 943                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 944                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 945                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 946                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 947                                 .build());
 948                             break;
 949                         case "If10GEODU2":
 950                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 951                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 952                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 953                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 954                                 .build());
 955                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 956                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 957                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 958                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 959                                 .build());
 960                             break;
 961                         case "If10GE":
 962                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 963                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 964                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 965                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 966                                 .build());
 967                             break;
 968                         case "If100GEODU4":
 969                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 970                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 971                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 972                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 973                                 .build());
 974                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 975                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 976                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 977                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 978                                 .build());
 979                             break;
 980                         case "If100GE":
 981                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 982                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 983                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 984                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 985                                 .build());
 986                             break;
 987                         case "IfOCHOTU4ODU4":
 988                         case "IfOCH":
 989                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
 990                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
 991                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 992                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 993                                 .build());
 994                             break;
 995                         default:
 996                             LOG.error("IfCapability type not managed");
 997                             break;
 998                     }
 999                     break;
1000                 case "ODU":
1001                     switch (ifCapType) {
1002                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
1003                         //  port are extended in the config file
1004                         case "If1GEODU0":
1005                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1006                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1007                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
1008                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1009                                 .build());
1010                             break;
1011                         case "If10GEODU2e":
1012                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1013                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1014                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
1015                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1016                                 .build());
1017                             break;
1018                         case "If10GEODU2":
1019                         case "If10GE":
1020                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1021                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1022                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
1023                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1024                                 .build());
1025                             break;
1026                         case "If100GEODU4":
1027                         case "If100GE":
1028                         case "IfOCHOTU4ODU4":
1029                         case "IfOCH":
1030                             sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1031                                     .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1032                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1033                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1034                                 .build());
1035                             break;
1036                         default:
1037                             LOG.error("IfCapability type not managed");
1038                             break;
1039                     }
1040                     break;
1041                 case "PHOTONIC_MEDIA":
1042                     if (ifCapType.equals("IfOCHOTU4ODU4") || ifCapType.equals("IfOCH")) {
1043                         sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1044                                 .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1045                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
1046                             .setNumberOfCepInstances(Uint64.valueOf(0))
1047                             .build());
1048                         sclpqiList.add(new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121
1049                             .service._interface.point.SupportedCepLayerProtocolQualifierInstancesBuilder()
1050                                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
1051                             .setNumberOfCepInstances(Uint64.valueOf(0))
1052                             .build());
1053                     }
1054                     break;
1055                 default:
1056                     LOG.error("Layer Protocol Name is unknown");
1057                     break;
1058             }
1059         }
1060         return sclpqiList;
1061     }
1062
1063     private List<SupportedCepLayerProtocolQualifierInstances> createSupportedLayerProtocolQualifier(TerminationPoint tp,
1064             LayerProtocolName lpn) {
1065         List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
1066         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1067             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
1068             .setNumberOfCepInstances(Uint64.valueOf(1))
1069             .build());
1070         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1 tp1 =
1071             tp.augmentation(org.opendaylight.yang.gen.v1.http
1072                 .org.openroadm.otn.network.topology.rev230526.TerminationPoint1.class);
1073         if (tp1 == null) {
1074             return new ArrayList<>(sclpqiList);
1075         }
1076         if (tp1.getTpSupportedInterfaces() == null) {
1077             LOG.warn("Tp supported interface doesnt exist on TP {}", tp.getTpId().getValue());
1078             return new ArrayList<>(sclpqiList);
1079         }
1080         Collection<SupportedInterfaceCapability> sicList = tp1.getTpSupportedInterfaces()
1081             .getSupportedInterfaceCapability().values();
1082         for (SupportedInterfaceCapability sic : sicList) {
1083             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
1084             switch (lpn.getName()) {
1085                 case "DSR":
1086                     switch (ifCapType) {
1087                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
1088                         //  port are extended in the config file
1089                         case "If1GEODU0":
1090                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1091                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
1092                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1093                                 .build());
1094                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1095                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
1096                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1097                                 .build());
1098                             break;
1099                         case "If10GEODU2e":
1100                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1101                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
1102                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1103                                 .build());
1104                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1105                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1106                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1107                                 .build());
1108                             break;
1109                         case "If10GEODU2":
1110                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1111                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
1112                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1113                                 .build());
1114                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1115                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1116                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1117                                 .build());
1118                             break;
1119                         case "If10GE":
1120                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1121                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
1122                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1123                                 .build());
1124                             break;
1125                         case "If100GEODU4":
1126                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1127                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
1128                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1129                                 .build());
1130                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1131                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1132                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1133                                 .build());
1134                             break;
1135                         case "If100GE":
1136                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1137                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
1138                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1139                                 .build());
1140                             break;
1141                         case "IfOCHOTU4ODU4":
1142                         case "IfOCH":
1143                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1144                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1145                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1146                                 .build());
1147                             break;
1148                         default:
1149                             LOG.error("IfCapability type not managed");
1150                             break;
1151                     }
1152                     break;
1153                 case "ODU":
1154                     switch (ifCapType) {
1155                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
1156                         //  port are extended in the config file
1157                         case "If1GEODU0":
1158                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1159                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
1160                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1161                                 .build());
1162                             break;
1163                         case "If10GEODU2e":
1164                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1165                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
1166                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1167                                 .build());
1168                             break;
1169                         case "If10GEODU2":
1170                         case "If10GE":
1171                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1172                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
1173                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1174                                 .build());
1175                             break;
1176                         case "If100GEODU4":
1177                         case "If100GE":
1178                         case "IfOCHOTU4ODU4":
1179                         case "IfOCH":
1180                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1181                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
1182                                 .setNumberOfCepInstances(Uint64.valueOf(0))
1183                                 .build());
1184                             break;
1185                         default:
1186                             LOG.error("IfCapability type not managed");
1187                             break;
1188                     }
1189                     break;
1190                 case "PHOTONIC_MEDIA":
1191                     if (ifCapType.equals("IfOCHOTU4ODU4") || ifCapType.equals("IfOCH")) {
1192                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1193                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
1194                             .setNumberOfCepInstances(Uint64.valueOf(0))
1195                             .build());
1196                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
1197                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
1198                             .setNumberOfCepInstances(Uint64.valueOf(0))
1199                             .build());
1200                     }
1201                     break;
1202                 default:
1203                     LOG.error("Layer Protocol Name is unknown");
1204                     break;
1205             }
1206         }
1207         return sclpqiList;
1208     }
1209
1210     public void convertXpdrToRdmLinks(List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1211             .ietf.network.topology.rev180226.networks.network.Link> xpdrRdmLinkList) {
1212         List<String> linksToNotConvert = new ArrayList<>();
1213         LOG.info("creation of {} xpdr to roadm links", xpdrRdmLinkList.size() / 2);
1214         // LOG.info("Link list = {}", xpdrRdmLinkList.toString());
1215         for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1216             .ietf.network.topology.rev180226.networks.network.Link link:xpdrRdmLinkList) {
1217             if (!linksToNotConvert.contains(link.getLinkId().getValue())) {
1218                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1219                     .ietf.network.topology.rev180226.networks.network.Link oppositeLink = xpdrRdmLinkList.stream()
1220                     .filter(l -> l.getLinkId().equals(link.augmentation(Link1.class).getOppositeLink())).findAny()
1221                     .orElse(null);
1222
1223                 AdminStates oppLnkAdmState = null;
1224                 State oppLnkOpState = null;
1225                 if (oppositeLink != null) {
1226                     oppLnkAdmState = oppositeLink.augmentation(Link1.class).getAdministrativeState();
1227                     oppLnkOpState = oppositeLink.augmentation(Link1.class).getOperationalState();
1228                 }
1229                 String adminState =
1230                     link.augmentation(Link1.class).getAdministrativeState() == null
1231                         || oppLnkAdmState == null
1232                     ? null
1233                     : this.tapiLink.setTapiAdminState(
1234                         link.augmentation(Link1.class).getAdministrativeState(), oppLnkAdmState).getName();
1235                 String operState =
1236                     link.augmentation(Link1.class).getOperationalState() == null
1237                         || oppLnkOpState == null
1238                     ? null
1239                     : this.tapiLink.setTapiOperationalState(
1240                         link.augmentation(Link1.class).getOperationalState(), oppLnkOpState).getName();
1241
1242                 String sourceNode = (link.getSource().getSourceNode().getValue().contains("ROADM"))
1243                     ? getIdBasedOnModelVersion(link.getSource().getSourceNode().getValue())
1244                     : link.getSource().getSourceNode().getValue();
1245                 String sourceTp = link.getSource().getSourceTp().getValue();
1246                 String sourceNodeQual = sourceNode.contains("ROADM") ? TapiStringConstants.PHTNC_MEDIA
1247                     : TapiStringConstants.OTSI;
1248                 String destNode = (link.getDestination().getDestNode().getValue().contains("ROADM"))
1249                     ? getIdBasedOnModelVersion(link.getDestination().getDestNode().getValue())
1250                     : link.getDestination().getDestNode().getValue();
1251                 String destTp = link.getDestination().getDestTp().getValue();
1252                 String destNodeQual = destNode.contains("ROADM") ? TapiStringConstants.PHTNC_MEDIA
1253                     : TapiStringConstants.OTSI;
1254                 Link tapLink = this.tapiLink.createTapiLink(sourceNode, sourceTp, destNode, destTp,
1255                     TapiStringConstants.OMS_XPDR_RDM_LINK, sourceNodeQual, destNodeQual,
1256                     TapiStringConstants.PHTNC_MEDIA, TapiStringConstants.PHTNC_MEDIA, adminState,
1257                     operState, Set.of(LayerProtocolName.PHOTONICMEDIA),
1258                     Set.of(LayerProtocolName.PHOTONICMEDIA.getName()), this.tapiTopoUuid);
1259                 linksToNotConvert.add(link.augmentation(Link1.class).getOppositeLink().getValue());
1260                 this.tapiLinks.put(tapLink.key(), tapLink);
1261             }
1262         }
1263     }
1264
1265     private String getIdBasedOnModelVersion(String linknodeid) {
1266         if (linknodeid.matches("[A-Z]{5}-[A-Z0-9]{2}-.*")) {
1267             LOG.info("OpenROADM version > 1.2.1 {}", linknodeid);
1268             return String.join("-", linknodeid.split("-")[0], linknodeid.split("-")[1]);
1269         } else {
1270             LOG.info("OpenROADM version <= 1.2.1 {}", linknodeid);
1271             return linknodeid.split("-")[0];
1272         }
1273     }
1274
1275     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
1276             getTapiNodes() {
1277         return tapiNodes;
1278     }
1279
1280     public Map<LinkKey, Link> getTapiLinks() {
1281         return tapiLinks;
1282     }
1283
1284     public Map<ServiceInterfacePointKey, ServiceInterfacePoint> getTapiSips() {
1285         return tapiSips;
1286     }
1287 }