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