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

   1 /*
   2  * Copyright © 2019 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 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.Collections;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Map.Entry;
  20 import java.util.Set;
  21 import java.util.UUID;
  22 import java.util.stream.Collectors;
  23 import org.opendaylight.transportpce.tapi.TapiStringConstants;
  24 import org.opendaylight.transportpce.tapi.utils.TapiLink;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Link1;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPools;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmTpType;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.Node1;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Direction;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.ForwardingDirection;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LifecycleState;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.PortRole;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU0;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU2E;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.digital.otn.rev221121.ODUTYPEODU4;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE100GigE;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPE10GigELAN;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITALSIGNALTYPEGigE;
  59 //import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROMS;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSiMC;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePoint;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePointBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePointKey;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupKey;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointKey;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPac;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPacBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePoint;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointKey;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstances;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
  81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleKey;
  83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristic;
  84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristicBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
  86 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
  88 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
  90 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristic;
  91 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristicBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristic;
  93 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristicBuilder;
  94 import org.opendaylight.yangtools.yang.common.Uint16;
  95 import org.opendaylight.yangtools.yang.common.Uint64;
  96 import org.slf4j.Logger;
  97 import org.slf4j.LoggerFactory;
  98
  99
 100 public class ConvertORTopoToTapiTopo {
 101
 102     private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiTopo.class);
 103     private String ietfNodeId;
 104     private OpenroadmNodeType ietfNodeType;
 105     private AdminStates ietfNodeAdminState = null;
 106     private State ietfNodeOperState = null;
 107     private List<TerminationPoint> oorClientPortList = null;
 108     private List<TerminationPoint> oorNetworkPortList = null;
 109     private OduSwitchingPools oorOduSwitchingPool = null;
 110     private Uuid tapiTopoUuid;
 111     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 112         tapiNodes;
 113     private Map<LinkKey, Link> tapiLinks;
 114     private Map<String, Uuid> uuidMap;
 115     private final TapiLink tapiLink;
 116
 117
 118     public ConvertORTopoToTapiTopo(Uuid tapiTopoUuid, TapiLink tapiLink) {
 119         this.tapiTopoUuid = tapiTopoUuid;
 120         this.tapiNodes = new HashMap<>();
 121         this.tapiLinks = new HashMap<>();
 122         this.uuidMap = 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 [DSR/ODU]
 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 nameDsr = new NameBuilder().setValueName("dsr/odu node name")
 179             .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.XPDR)).build();
 180         Name namePhot = new NameBuilder().setValueName("otsi node name")
 181             .setValue(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(nameDsr.key(), nameDsr, namePhot.key(), namePhot,nameNodeType.key(),
 188                 nameNodeType),
 189             dsrLayerProtocols);
 190         tapiNodes.put(dsrNode.key(), dsrNode);
 191     }
 192
 193     public void convertLinks(Map<
 194             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 195                 .LinkKey,
 196             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 197                 .Link> otnLinkMap) {
 198         List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 199             .Link> otnLinkList = new ArrayList<>(otnLinkMap.values());
 200         Collections.sort(otnLinkList, (l1, l2) -> l1.getLinkId().getValue()
 201             .compareTo(l2.getLinkId().getValue()));
 202         List<String> linksToNotConvert = new ArrayList<>();
 203         LOG.info("creation of {} otn links", otnLinkMap.size() / 2);
 204         for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 205                 .Link otnlink : otnLinkList) {
 206             if (!linksToNotConvert.contains(otnlink.getLinkId().getValue())) {
 207                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks
 208                     .network.Link oppositeLink = otnLinkMap.get(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 209                         .yang.ietf.network.topology.rev180226.networks.network.LinkKey(otnlink.augmentation(Link1.class)
 210                     .getOppositeLink()));
 211
 212                 AdminStates oppLnkAdmState = null;
 213                 State oppLnkOpState = null;
 214                 String oppositeLinkId = null;
 215                 if (oppositeLink != null) {
 216                     oppLnkAdmState = oppositeLink.augmentation(Link1.class).getAdministrativeState();
 217                     oppLnkOpState = oppositeLink.augmentation(Link1.class).getOperationalState();
 218                     oppositeLinkId = oppositeLink.getLinkId().getValue();
 219                 }
 220                 String adminState =
 221                     otnlink.augmentation(Link1.class).getAdministrativeState() == null
 222                         || oppLnkAdmState == null
 223                     ? null
 224                     : this.tapiLink.setTapiAdminState(
 225                         otnlink.augmentation(Link1.class).getAdministrativeState(), oppLnkAdmState).getName();
 226                 String operState = otnlink.augmentation(Link1.class).getOperationalState() == null
 227                         || oppLnkOpState == null
 228                     ? null
 229                     : this.tapiLink.setTapiOperationalState(
 230                         otnlink.augmentation(Link1.class).getOperationalState(), oppLnkOpState).getName();
 231                 // TODO: Handle not only OTU4 but also other cases
 232                 String prefix = otnlink.getLinkId().getValue().split("-")[0];
 233                 String nodesQual = TapiStringConstants.XPDR;
 234                 String tpsQual = prefix.equals("OTU4") ? TapiStringConstants.I_OTSI : TapiStringConstants.E_ODU;
 235                 LayerProtocolName layerProtocolName = prefix.equals("OTU4") ? LayerProtocolName.PHOTONICMEDIA
 236                     : LayerProtocolName.ODU;
 237
 238                 Link tapLink = this.tapiLink.createTapiLink(otnlink.getSource().getSourceNode().getValue(),
 239                     otnlink.getSource().getSourceTp().getValue(), otnlink.getDestination().getDestNode().getValue(),
 240                     otnlink.getDestination().getDestTp().getValue(), TapiStringConstants.OTN_XPDR_XPDR_LINK, nodesQual,
 241                     nodesQual, tpsQual, tpsQual, adminState, operState, Set.of(layerProtocolName),
 242                     Set.of(layerProtocolName.getName()), this.tapiTopoUuid);
 243                 linksToNotConvert.add(oppositeLinkId);
 244                 tapiLinks.put(tapLink.key(), tapLink);
 245                 LOG.debug("Links converted are as follow  {}", tapiLinks.toString());
 246             }
 247         }
 248     }
 249
 250     public void convertRoadmInfrastructure() {
 251         LOG.info("abstraction of the ROADM infrastructure towards a photonic node");
 252         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.RDM_INFRA
 253             .getBytes(Charset.forName("UTF-8"))).toString());
 254         Name nodeName =  new NameBuilder().setValueName("otsi node name").setValue(TapiStringConstants.RDM_INFRA)
 255             .build();
 256         Name nameNodeType = new NameBuilder().setValueName("Node Type")
 257             .setValue(OpenroadmNodeType.ROADM.getName()).build();
 258         Set<LayerProtocolName> nodeLayerProtocols = Set.of(LayerProtocolName.PHOTONICMEDIA);
 259         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> tapiPhotonicNodes
 260             = pruneTapiPhotonicNodes();
 261         //At that stage, there is no Roadm in the tapiPhotonicNodes Map / only the transponders
 262         Map<String, String> photonicNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(tapiPhotonicNodes);
 263         // nep creation for rdm infra abstraction node
 264         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = createNepForRdmNode(photonicNepUuisMap.size());
 265         // node rule group creation
 266         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList
 267             = createNodeRuleGroupForRdmNode(nodeUuid, onepMap.values());
 268      // Empty random creation of mandatory fields for avoiding errors....
 269         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 270             .setCostAlgorithm("Restricted Shortest Path - RSP")
 271             .setCostName("HOP_COUNT")
 272             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 273             .build();
 274         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 275             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 276             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 277             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 278             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 279             .setTrafficPropertyName("FIXED_LATENCY")
 280             .build();
 281         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 282             .setRiskCharacteristicName("risk characteristic")
 283             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 284             .build();
 285         RiskParameterPac riskParamPac = new RiskParameterPacBuilder()
 286             .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 287             .build();
 288         // build RDM infra node abstraction
 289         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node rdmNode = new NodeBuilder()
 290             .setUuid(nodeUuid)
 291             .setName(Map.of(nodeName.key(), nodeName, nameNodeType.key(), nameNodeType))
 292             .setLayerProtocolName(nodeLayerProtocols)
 293             .setAdministrativeState(AdministrativeState.UNLOCKED)
 294             .setOperationalState(OperationalState.ENABLED)
 295             .setLifecycleState(LifecycleState.INSTALLED)
 296             .setOwnedNodeEdgePoint(onepMap)
 297             .setNodeRuleGroup(nodeRuleGroupList)
 298             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 299             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 300             .setRiskParameterPac(riskParamPac)
 301             .build();
 302         tapiNodes.put(rdmNode.key(), rdmNode);
 303     // OTS link creation between photonic nodes and RDM infra abstraction node :
 304       //onepMap is a list of nep which Uuid is formed from THE ROADM node name, "nep" and an integer (order of the nep)
 305       // It has absolutely no relationship with the real ROADM infrastructure (SRG ports)
 306       //rdmInfraNepUuisMap is a Map <ROADMnodeUuuid--NepUuid; ROADMnodeName--nepName> built from onepMap
 307       //photonicNepUuisMap is a Map <TSPnodeUuuid--eNepUuid; TSPnodeName--nepName> built from TapiPhotonicNode
 308         Map<String, String> rdmInfraNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(List.of(rdmNode));
 309         if (photonicNepUuisMap.size() != rdmInfraNepUuisMap.size()) {
 310             LOG.warn("Unable to build OTS links between photonics nodes and RDM infrasctructure abstraction");
 311         } else {
 312             //Tapi OtsLinks are created between Neps corresponding to the eNEPs of transponders (existing network ports)
 313             //and Generic NEPS with abstracted names created in the ROADM infrastructure corresponding to tps mirroring
 314             //transponders NETWORK PORTs. There is a simplification here considering that any network port of
 315             //transponders will have a mirroring SRG client port in the ROADM infrastructure.
 316             // TODO: Do not understand that we build OTS link without checking that existing transponder ports
 317             //are effectively connected. Need some consolidation
 318             createTapiOtsLinks(photonicNepUuisMap, rdmInfraNepUuisMap);
 319         }
 320     }
 321
 322     private OduSwitchingPools createOduSwitchingPoolForTp100G() {
 323         Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
 324         int count = 1;
 325         for (TerminationPoint tp : this.oorNetworkPortList) {
 326             TpId tpid1 = tp.getTpId();
 327             TpId tpid2 = tp.augmentation(
 328                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1.class)
 329                 .getAssociatedConnectionMapTp().iterator().next();
 330             Set<TpId> tpList = new HashSet<>();
 331             tpList.add(tpid1);
 332             tpList.add(tpid2);
 333             NonBlockingList nbl = new NonBlockingListBuilder()
 334                 .setNblNumber(Uint16.valueOf(count))
 335                 .setTpList(tpList)
 336                 .build();
 337             nblMap.put(nbl.key(), nbl);
 338             count++;
 339         }
 340         return new OduSwitchingPoolsBuilder()
 341             .setNonBlockingList(nblMap)
 342             .setSwitchingPoolNumber(Uint16.valueOf(1))
 343             .build();
 344     }
 345
 346     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 347             pruneTapiPhotonicNodes() {
 348         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 349             prunedTapiPhotonicNodes = new ArrayList<>();
 350         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> tapiPhotonicNodes
 351             = this.tapiNodes.values().stream()
 352                 .filter(n -> n.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
 353                 .collect(Collectors.toList());
 354         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node
 355             : tapiPhotonicNodes) {
 356             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepM = new HashMap<>();
 357             for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry : node.getOwnedNodeEdgePoint().entrySet()) {
 358                 if (entry.getValue().getName().values().stream()
 359                     .filter(name -> name.getValueName().startsWith("eNodeEdgePoint")).count() > 0) {
 360                     onepM.put(entry.getKey(), entry.getValue());
 361                 }
 362             }
 363             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node prunedNode
 364                 = new NodeBuilder(node).setOwnedNodeEdgePoint(onepM).build();
 365             prunedTapiPhotonicNodes.add(prunedNode);
 366         }
 367         return prunedTapiPhotonicNodes;
 368     }
 369
 370     private Map<String, String> convertListNodeWithListNepToMapForUuidAndName(
 371         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> nodes) {
 372         Map<String, String> uuidNameMap = new HashMap<>();
 373         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node : nodes) {
 374             for (OwnedNodeEdgePoint nep : node.nonnullOwnedNodeEdgePoint().values()) {
 375                 String nodeUuid = node.getUuid().getValue();
 376                 String nepUuid = nep.getUuid().getValue();
 377                 String nodeName = node.getName().get(new NameKey("otsi node name")).getValue();
 378                 String nepName = nep.getName().get(new NameKey(nep.getName().keySet().stream().findFirst()
 379                         .orElseThrow()))
 380                     .getValue();
 381                 uuidNameMap.put(String.join("--", nodeUuid, nepUuid), String.join("--", nodeName, nepName));
 382             }
 383         }
 384         return uuidNameMap;
 385     }
 386
 387     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node
 388             createTapiNode(Map<NameKey, Name> nodeNames, Set<LayerProtocolName> layerProtocols) {
 389         Uuid nodeUuid = null;
 390         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 391         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList = new HashMap<>();
 392         Map<RuleKey, Rule> ruleList = new HashMap<>();
 393         Set<RuleType> ruleTypes = new HashSet<>();
 394         ruleTypes.add(RuleType.FORWARDING);
 395         Rule rule = new RuleBuilder()
 396             .setLocalId("forward")
 397             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 398             .setRuleType(ruleTypes)
 399             .build();
 400         ruleList.put(rule.key(), rule);
 401         if (layerProtocols.contains(LayerProtocolName.DSR)
 402                 || layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
 403             nodeUuid = getNodeUuid4Dsr(onepl, nodeRuleGroupList, ruleList);
 404         } else {
 405             LOG.error("Undefined LayerProtocolName for {} node {}", nodeNames.get(nodeNames.keySet().iterator().next())
 406                 .getValueName(), nodeNames.get(nodeNames.keySet().iterator().next()).getValue());
 407         }
 408      // Empty random creation of mandatory fields for avoiding errors....
 409         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 410             .setCostAlgorithm("Restricted Shortest Path - RSP")
 411             .setCostName("HOP_COUNT")
 412             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 413             .build();
 414         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 415             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 416             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 417             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 418             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 419             .setTrafficPropertyName("FIXED_LATENCY")
 420             .build();
 421         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 422             .setRiskCharacteristicName("risk characteristic")
 423             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 424             .build();
 425         RiskParameterPac riskParamPac = new RiskParameterPacBuilder()
 426             .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 427             .build();
 428         return new NodeBuilder()
 429             .setUuid(nodeUuid)
 430             .setName(nodeNames)
 431             .setLayerProtocolName(layerProtocols)
 432             .setAdministrativeState(this.tapiLink.setTapiAdminState(this.ietfNodeAdminState.getName()))
 433             .setOperationalState(this.tapiLink.setTapiOperationalState(this.ietfNodeOperState.getName()))
 434             .setLifecycleState(LifecycleState.INSTALLED)
 435             .setOwnedNodeEdgePoint(onepl)
 436             .setNodeRuleGroup(nodeRuleGroupList)
 437             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 438             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 439             .setRiskParameterPac(riskParamPac)
 440             .build();
 441     }
 442
 443     private Uuid getNodeUuid4Dsr(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 444                                  Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
 445         Uuid nodeUuid;
 446         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.XPDR));
 447         // client nep creation on DSR/ODU node
 448         for (int i = 0; i < oorClientPortList.size(); i++) {
 449             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 450                 (String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 451                     oorClientPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 452             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 453                 oorClientPortList.get(i).getTpId().getValue()), nepUuid);
 454             NameBuilder nameBldr = new NameBuilder().setValue(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 455                 oorClientPortList.get(i).getTpId().getValue()));
 456             Name name;
 457             if (OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 458                 name = nameBldr.setValueName("100G-tpdr").build();
 459             } else {
 460                 name = nameBldr.setValueName("NodeEdgePoint_C").build();
 461             }
 462
 463             OwnedNodeEdgePoint onep = createNep(oorClientPortList.get(i), Map.of(name.key(), name),
 464                 LayerProtocolName.ETH, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 465                     TapiStringConstants.DSR));
 466             onepl.put(onep.key(), onep);
 467         }
 468         // network nep creation on DSR/ODU node
 469         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 470             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 471                 (String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 472                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 473             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 474                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid);
 475             Name onedName = new NameBuilder()
 476                 .setValueName("iNodeEdgePoint_N")
 477                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 478                     oorNetworkPortList.get(i).getTpId().getValue()))
 479                 .build();
 480
 481             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 482                 LayerProtocolName.ODU, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 483                     TapiStringConstants.I_ODU));
 484             onepl.put(onep.key(), onep);
 485         }
 486      // eNep creation on otsi node
 487         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 488             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(
 489                     (String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS,
 490                         oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 491                 .toString());
 492             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS,
 493                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid2);
 494             Name onedName = new NameBuilder()
 495                 .setValueName("eNodeEdgePoint")
 496                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS,
 497                     oorNetworkPortList.get(i).getTpId().getValue()))
 498                 .build();
 499
 500             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 501                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 502                 String.join("+", this.ietfNodeId, TapiStringConstants.PHTNC_MEDIA_OTS));
 503             onepl.put(onep.key(), onep);
 504         }
 505         // create NodeRuleGroup
 506         int count = 1;
 507         for (NonBlockingList nbl : this.oorOduSwitchingPool.nonnullNonBlockingList().values()) {
 508             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 509                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 510                 nepList = new HashMap<>();
 511             for (TpId tp : nbl.getTpList()) {
 512                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 513                         tp.getValue())) || this.uuidMap.containsKey(String.join(
 514                     "+", this.ietfNodeId, TapiStringConstants.I_ODU, tp.getValue()))) {
 515                     String qual = tp.getValue().contains("CLIENT") ? TapiStringConstants.DSR
 516                         : TapiStringConstants.I_ODU;
 517                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 518                         nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 519                         .NodeEdgePointBuilder()
 520                         .setTopologyUuid(tapiTopoUuid)
 521                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 522                             TapiStringConstants.XPDR)))
 523                         .setNodeEdgePointUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 524                             qual, tp.getValue())))
 525                         .build();
 526                     nepList.put(nep.key(), nep);
 527                 }
 528             }
 529             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 530                 .setUuid(new Uuid(
 531                     UUID.nameUUIDFromBytes(("dsr node rule group " + count).getBytes(Charset.forName("UTF-8")))
 532                         .toString()))
 533                 .setRule(ruleList)
 534                 .setNodeEdgePoint(nepList)
 535                 .build();
 536             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 537             count++;
 538         }
 539         return nodeUuid;
 540     }
 541
 542     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
 543                                          LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol,
 544                                          boolean withSip, String keyword) {
 545         String key = String.join("+", keyword, oorTp.getTpId().getValue());
 546         AdministrativeState adminState = (oorTp.augmentation(TerminationPoint1.class).getAdministrativeState() != null)
 547             ? this.tapiLink.setTapiAdminState(oorTp.augmentation(TerminationPoint1.class).getAdministrativeState()
 548                 .getName())
 549             : null;
 550         OperationalState operState = (oorTp.augmentation(TerminationPoint1.class).getOperationalState() != null)
 551             ? this.tapiLink.setTapiOperationalState(oorTp.augmentation(TerminationPoint1.class).getOperationalState()
 552                 .getName())
 553             : null;
 554         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
 555             .setUuid(this.uuidMap.get(key))
 556             .setLayerProtocolName(nepProtocol)
 557             .setName(nepNames)
 558             .setSupportedCepLayerProtocolQualifierInstances(createSupportedCepLayerProtocolQualifier(oorTp,
 559                 nodeProtocol))
 560             .setDirection(Direction.BIDIRECTIONAL)
 561             .setLinkPortRole(PortRole.SYMMETRIC)
 562             .setAdministrativeState(adminState)
 563             .setOperationalState(operState)
 564             .setLifecycleState(LifecycleState.INSTALLED);
 565         if (withSip) {
 566             onepBldr.setMappedServiceInterfacePoint(createSIP(1, oorTp, keyword));
 567         }
 568         return onepBldr.build();
 569     }
 570
 571     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> createNepForRdmNode(int nbNep) {
 572         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 573         for (int i = 1; i <= nbNep; i++) {
 574             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "roadm node", "nep", String.valueOf(i)))
 575                 .getBytes(Charset.forName("UTF-8"))).toString());
 576             Name nepName = new NameBuilder()
 577                 .setValueName("NodeEdgePoint name")
 578                 .setValue(new StringBuilder("NodeEdgePoint_").append(i).toString())
 579                 .build();
 580             List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 581             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 582                 .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 583                 .setNumberOfCepInstances(Uint64.valueOf(1))
 584                 .build());
 585             OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder()
 586                 .setUuid(nepUuid)
 587                 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA)
 588                 .setName(Map.of(nepName.key(), nepName))
 589                 .setSupportedCepLayerProtocolQualifierInstances(sclpqiList)
 590                 .setDirection(Direction.BIDIRECTIONAL).setLinkPortRole(PortRole.SYMMETRIC)
 591                 .setAdministrativeState(AdministrativeState.UNLOCKED).setOperationalState(OperationalState.ENABLED)
 592                 .setLifecycleState(LifecycleState.INSTALLED)
 593                 .build();
 594             onepMap.put(onep.key(), onep);
 595         }
 596         return onepMap;
 597     }
 598
 599     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(Uuid nodeUuid,
 600                                                                                Collection<OwnedNodeEdgePoint> onepl) {
 601         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 602             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 603             nepMap = new HashMap<>();
 604         for (OwnedNodeEdgePoint onep : onepl) {
 605             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 606                 nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 607                     .NodeEdgePointBuilder()
 608                 .setTopologyUuid(tapiTopoUuid)
 609                 .setNodeUuid(nodeUuid)
 610                 .setNodeEdgePointUuid(onep.key().getUuid())
 611                 .build();
 612             nepMap.put(nep.key(), nep);
 613         }
 614         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
 615         Set<RuleType> ruleTypes = new HashSet<>();
 616         ruleTypes.add(RuleType.FORWARDING);
 617         Map<RuleKey, Rule> ruleList = new HashMap<>();
 618         Rule rule = new RuleBuilder()
 619             .setLocalId("forward")
 620             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 621             .setRuleType(ruleTypes)
 622             .build();
 623         ruleList.put(rule.key(), rule);
 624         NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 625             .setUuid(new Uuid(UUID.nameUUIDFromBytes(("rdm infra node rule group").getBytes(Charset.forName("UTF-8")))
 626                 .toString()))
 627             .setRule(ruleList)
 628             .setNodeEdgePoint(nepMap)
 629             .build();
 630         nodeRuleGroupMap.put(nodeRuleGroup.key(), nodeRuleGroup);
 631         return nodeRuleGroupMap;
 632     }
 633
 634     private Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createSIP(int nb, TerminationPoint tp,
 635                                                                                        String nodeId) {
 636         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
 637         for (int i = 0; i < nb; i++) {
 638             //TODO : verify why i is not included to proceed Uuid
 639             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
 640                 .setServiceInterfacePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId,
 641                     tp.getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString()))
 642                 .build();
 643             msipl.put(msip.key(), msip);
 644         }
 645         return msipl;
 646     }
 647
 648     private List<SupportedCepLayerProtocolQualifierInstances> createSupportedCepLayerProtocolQualifier(
 649             TerminationPoint tp, LayerProtocolName lpn) {
 650         List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 651         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1 tp1 =
 652             tp.augmentation(org.opendaylight.yang.gen.v1.http
 653                 .org.openroadm.otn.network.topology.rev230526.TerminationPoint1.class);
 654         if (tp1 == null) {
 655             return new ArrayList<>(sclpqiList);
 656         }
 657         if (tp1.getTpSupportedInterfaces() == null) {
 658             LOG.warn("Tp supported interface doesnt exist on TP {}", tp.getTpId().getValue());
 659             return new ArrayList<>(sclpqiList);
 660         }
 661         Collection<SupportedInterfaceCapability> sicList = tp1.getTpSupportedInterfaces()
 662             .getSupportedInterfaceCapability().values();
 663         for (SupportedInterfaceCapability sic : sicList) {
 664             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
 665             switch (lpn.getName()) {
 666                 case "DSR":
 667                     switch (ifCapType) {
 668                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
 669                         //  port are extended in the config file
 670                         case "If1GEODU0":
 671                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 672                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 673                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 674                                 .build());
 675                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 676                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
 677                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 678                                 .build());
 679                             break;
 680                         case "If10GEODU2e":
 681                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 682                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 683                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 684                                 .build());
 685                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 686                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 687                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 688                                 .build());
 689                             break;
 690                         case "If10GEODU2":
 691                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 692                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 693                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 694                                 .build());
 695                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 696                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 697                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 698                                 .build());
 699                             break;
 700                         case "If10GE":
 701                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 702                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 703                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 704                                 .build());
 705                             break;
 706                         case "If100GEODU4":
 707                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 708                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 709                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 710                                 .build());
 711                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 712                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 713                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 714                                 .build());
 715                             break;
 716                         case "If100GE":
 717                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 718                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 719                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 720                                 .build());
 721                             break;
 722                         case "IfOCHOTU4ODU4":
 723                         case "IfOCH":
 724                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 725                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 726                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 727                                 .build());
 728                             break;
 729                         default:
 730                             LOG.error("IfCapability type not managed");
 731                             break;
 732                     }
 733                     break;
 734                 //TODO: verify that in the new scope it makes sense to include ODU in the abstracted topology
 735                 case "ODU":
 736                     switch (ifCapType) {
 737                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
 738                         //  port are extended in the config file
 739                         case "If1GEODU0":
 740                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 741                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 742                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 743                                 .build());
 744                             break;
 745                         case "If10GEODU2e":
 746                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 747                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 748                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 749                                 .build());
 750                             break;
 751                         case "If10GEODU2":
 752                         case "If10GE":
 753                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 754                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 755                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 756                                 .build());
 757                             break;
 758                         case "If100GEODU4":
 759                         case "If100GE":
 760                         case "IfOCHOTU4ODU4":
 761                         case "IfOCH":
 762                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 763                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 764                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 765                                 .build());
 766                             break;
 767                         default:
 768                             LOG.error("IfCapability type not managed");
 769                             break;
 770                     }
 771                     break;
 772                 case "PHOTONIC_MEDIA":
 773                     if (ifCapType.equals("IfOCHOTU4ODU4") || ifCapType.equals("IfOCH")) {
 774                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 775                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
 776                             .setNumberOfCepInstances(Uint64.valueOf(0))
 777                             .build());
 778                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 779                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 780                             .setNumberOfCepInstances(Uint64.valueOf(0))
 781                             .build());
 782                     }
 783                     break;
 784                 default:
 785                     LOG.error("Layer Protocol Name is unknown");
 786                     break;
 787             }
 788         }
 789         return sclpqiList.stream().distinct().toList();
 790     }
 791
 792     private void createTapiOtsLinks(Map<String, String> photonicNepUuisMap, Map<String, String> rdmInfraNepUuisMap) {
 793         Iterator<Entry<String, String>> it1 = photonicNepUuisMap.entrySet().iterator();
 794         Iterator<Entry<String, String>> it2 = rdmInfraNepUuisMap.entrySet().iterator();
 795         while (it1.hasNext()) {
 796             Map<NodeEdgePointKey, NodeEdgePoint> nepMap = new HashMap<>();
 797             Map.Entry<String, String> photonicEntry = it1.next();
 798             Map.Entry<String, String> rdmEntry = it2.next();
 799             Uuid sourceUuidTp = new Uuid(photonicEntry.getKey().split("--")[1]);
 800             Uuid sourceUuidNode = new Uuid(photonicEntry.getKey().split("--")[0]);
 801             Uuid destUuidTp = new Uuid(rdmEntry.getKey().split("--")[1]);
 802             Uuid destUuidNode = new Uuid(rdmEntry.getKey().split("--")[0]);
 803             NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 804                 .setTopologyUuid(this.tapiTopoUuid)
 805                 .setNodeUuid(sourceUuidNode)
 806                 .setNodeEdgePointUuid(sourceUuidTp)
 807                 .build();
 808             nepMap.put(sourceNep.key(), sourceNep);
 809             NodeEdgePoint destNep = new NodeEdgePointBuilder()
 810                 .setTopologyUuid(this.tapiTopoUuid)
 811                 .setNodeUuid(destUuidNode)
 812                 .setNodeEdgePointUuid(destUuidTp)
 813                 .build();
 814             nepMap.put(destNep.key(), destNep);
 815             Name linkName = new NameBuilder().setValueName("OTS link name")
 816                 .setValue(String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 817                 .build();
 818             Link otsLink = new LinkBuilder()
 819                 .setUuid(new Uuid(
 820                     UUID.nameUUIDFromBytes((String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 821                             .getBytes(Charset.forName("UTF-8")))
 822                         .toString()))
 823                 .setName(Map.of(linkName.key(), linkName))
 824                 .setLayerProtocolName(Set.of(LayerProtocolName.PHOTONICMEDIA))
 825                 .setNodeEdgePoint(nepMap)
 826                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 827                 .build();
 828             this.tapiLinks.put(otsLink.key(), otsLink);
 829         }
 830     }
 831
 832     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 833             getTapiNodes() {
 834         return tapiNodes;
 835     }
 836
 837     public Map<LinkKey, Link> getTapiLinks() {
 838         return tapiLinks;
 839     }
 840 }