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.edge.point.MappedServiceInterfacePoint;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePointKey;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstances;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleKey;
  81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
  82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
  84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
  86 import org.opendaylight.yangtools.yang.common.Uint16;
  87 import org.opendaylight.yangtools.yang.common.Uint64;
  88 import org.slf4j.Logger;
  89 import org.slf4j.LoggerFactory;
  90
  91
  92 public class ConvertORTopoToTapiTopo {
  93
  94     private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiTopo.class);
  95     private String ietfNodeId;
  96     private OpenroadmNodeType ietfNodeType;
  97     private AdminStates ietfNodeAdminState;
  98     private State ietfNodeOperState;
  99     private List<TerminationPoint> oorClientPortList;
 100     private List<TerminationPoint> oorNetworkPortList;
 101     private OduSwitchingPools oorOduSwitchingPool;
 102     private Uuid tapiTopoUuid;
 103     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 104         tapiNodes;
 105     private Map<LinkKey, Link> tapiLinks;
 106     private Map<String, Uuid> uuidMap;
 107     private final TapiLink tapiLink;
 108
 109
 110     public ConvertORTopoToTapiTopo(Uuid tapiTopoUuid, TapiLink tapiLink) {
 111         this.tapiTopoUuid = tapiTopoUuid;
 112         this.tapiNodes = new HashMap<>();
 113         this.tapiLinks = new HashMap<>();
 114         this.uuidMap = new HashMap<>();
 115         this.tapiLink = tapiLink;
 116     }
 117
 118     public void convertNode(Node ietfNode, List<String> networkPorts) {
 119         this.ietfNodeId = ietfNode.getNodeId().getValue();
 120         if (ietfNode.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 121                 == null) {
 122             return;
 123         }
 124         this.ietfNodeType = ietfNode.augmentation(
 125             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class).getNodeType();
 126         this.ietfNodeAdminState = ietfNode.augmentation(
 127                 org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 128             .getAdministrativeState();
 129         this.ietfNodeOperState = ietfNode.augmentation(
 130                 org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Node1.class)
 131             .getOperationalState();
 132         this.oorNetworkPortList = ietfNode.augmentation(
 133                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 134             .getTerminationPoint().values().stream()
 135             .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 136                 == OpenroadmTpType.XPONDERNETWORK.getIntValue()
 137                 && networkPorts.contains(tp.getTpId().getValue()))
 138             .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 139             .collect(Collectors.toList());
 140         if (!OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 141             this.oorOduSwitchingPool = ietfNode.augmentation(Node1.class).getSwitchingPools().getOduSwitchingPools()
 142                 .values().stream().findFirst().orElseThrow();
 143             this.oorClientPortList = ietfNode.augmentation(
 144                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 145                 .getTerminationPoint().values().stream()
 146                 .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 147                     == OpenroadmTpType.XPONDERCLIENT.getIntValue())
 148                 .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 149                 .collect(Collectors.toList());
 150         } else {
 151             this.oorOduSwitchingPool = createOduSwitchingPoolForTp100G();
 152             List<TpId> tpList = this.oorOduSwitchingPool.getNonBlockingList().values().stream()
 153                 .flatMap(nbl -> nbl.getTpList().stream())
 154                 .collect(Collectors.toList());
 155             this.oorClientPortList = ietfNode.augmentation(
 156                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 157                 .getTerminationPoint().values().stream()
 158                 .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 159                     == OpenroadmTpType.XPONDERCLIENT.getIntValue() && tpList.contains(tp.getTpId()))
 160                 .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 161                 .collect(Collectors.toList());
 162             this.oorClientPortList.forEach(tp -> LOG.info("tp = {}", tp.getTpId()));
 163         }
 164
 165         // node creation [DSR/ODU]
 166         LOG.info("creation of a DSR/ODU node for {}", this.ietfNodeId);
 167         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId,
 168             TapiStringConstants.XPDR)).getBytes(Charset.forName("UTF-8"))).toString());
 169         this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.XPDR), nodeUuid);
 170         Name nameDsr = new NameBuilder().setValueName("dsr/odu node name")
 171             .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.XPDR)).build();
 172         Name nameNodeType = new NameBuilder().setValueName("Node Type")
 173             .setValue(this.ietfNodeType.getName()).build();
 174         Set<LayerProtocolName> dsrLayerProtocols = Set.of(LayerProtocolName.DSR, LayerProtocolName.ODU,
 175                 LayerProtocolName.PHOTONICMEDIA);
 176         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology
 177             .Node dsrNode = createTapiNode(Map.of(nameDsr.key(), nameDsr, nameNodeType.key(), nameNodeType),
 178             dsrLayerProtocols);
 179         tapiNodes.put(dsrNode.key(), dsrNode);
 180
 181     }
 182
 183     public void convertLinks(Map<
 184             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 185                 .LinkKey,
 186             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 187                 .Link> otnLinkMap) {
 188         List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 189             .Link> otnLinkList = new ArrayList<>(otnLinkMap.values());
 190         Collections.sort(otnLinkList, (l1, l2) -> l1.getLinkId().getValue()
 191             .compareTo(l2.getLinkId().getValue()));
 192         List<String> linksToNotConvert = new ArrayList<>();
 193         LOG.info("creation of {} otn links", otnLinkMap.size() / 2);
 194         for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 195                 .Link otnlink : otnLinkList) {
 196             if (!linksToNotConvert.contains(otnlink.getLinkId().getValue())) {
 197                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks
 198                     .network.Link oppositeLink = otnLinkMap.get(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 199                         .yang.ietf.network.topology.rev180226.networks.network.LinkKey(otnlink.augmentation(Link1.class)
 200                     .getOppositeLink()));
 201
 202                 AdminStates oppLnkAdmState = null;
 203                 State oppLnkOpState = null;
 204                 String oppositeLinkId = null;
 205                 if (oppositeLink != null) {
 206                     oppLnkAdmState = oppositeLink.augmentation(Link1.class).getAdministrativeState();
 207                     oppLnkOpState = oppositeLink.augmentation(Link1.class).getOperationalState();
 208                     oppositeLinkId = oppositeLink.getLinkId().getValue();
 209                 }
 210                 String adminState =
 211                     otnlink.augmentation(Link1.class).getAdministrativeState() == null
 212                         || oppLnkAdmState == null
 213                     ? null
 214                     : this.tapiLink.setTapiAdminState(
 215                         otnlink.augmentation(Link1.class).getAdministrativeState(), oppLnkAdmState).getName();
 216                 String operState = otnlink.augmentation(Link1.class).getOperationalState() == null
 217                         || oppLnkOpState == null
 218                     ? null
 219                     : this.tapiLink.setTapiOperationalState(
 220                         otnlink.augmentation(Link1.class).getOperationalState(), oppLnkOpState).getName();
 221
 222                 String prefix = otnlink.getLinkId().getValue().split("-")[0];
 223                 String nodesQual = prefix.equals("OTU4") ? TapiStringConstants.OTSI : TapiStringConstants.DSR;
 224                 String tpsQual = prefix.equals("OTU4") ? TapiStringConstants.I_OTSI : TapiStringConstants.E_ODU;
 225                 LayerProtocolName layerProtocolName = prefix.equals("OTU4") ? LayerProtocolName.PHOTONICMEDIA
 226                     : LayerProtocolName.ODU;
 227
 228                 Link tapLink = this.tapiLink.createTapiLink(otnlink.getSource().getSourceNode().getValue(),
 229                     otnlink.getSource().getSourceTp().getValue(), otnlink.getDestination().getDestNode().getValue(),
 230                     otnlink.getDestination().getDestTp().getValue(), TapiStringConstants.OTN_XPDR_XPDR_LINK, nodesQual,
 231                     nodesQual, tpsQual, tpsQual, adminState, operState, Set.of(layerProtocolName),
 232                     Set.of(layerProtocolName.getName()), this.tapiTopoUuid);
 233                 linksToNotConvert.add(oppositeLinkId);
 234                 tapiLinks.put(tapLink.key(), tapLink);
 235             }
 236         }
 237     }
 238
 239     public void convertRoadmInfrastructure() {
 240         LOG.info("abstraction of the ROADM infrastructure towards a photonic node");
 241         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.RDM_INFRA
 242             .getBytes(Charset.forName("UTF-8"))).toString());
 243         Name nodeName =  new NameBuilder().setValueName("otsi node name").setValue(TapiStringConstants.RDM_INFRA)
 244             .build();
 245         Name nameNodeType = new NameBuilder().setValueName("Node Type")
 246             .setValue(OpenroadmNodeType.ROADM.getName()).build();
 247         Set<LayerProtocolName> nodeLayerProtocols = Set.of(LayerProtocolName.PHOTONICMEDIA);
 248
 249         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> tapiPhotonicNodes
 250             = pruneTapiPhotonicNodes();
 251         Map<String, String> photonicNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(tapiPhotonicNodes);
 252         // nep creation for rdm infra abstraction node
 253         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = createNepForRdmNode(photonicNepUuisMap.size());
 254         // node rule group creation
 255         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList
 256             = createNodeRuleGroupForRdmNode(nodeUuid, onepMap.values());
 257         // build RDM infra node abstraction
 258         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node rdmNode = new NodeBuilder()
 259             .setUuid(nodeUuid)
 260             .setName(Map.of(nodeName.key(), nodeName, nameNodeType.key(), nameNodeType))
 261             .setLayerProtocolName(nodeLayerProtocols)
 262             .setAdministrativeState(AdministrativeState.UNLOCKED)
 263             .setOperationalState(OperationalState.ENABLED)
 264             .setLifecycleState(LifecycleState.INSTALLED)
 265             .setOwnedNodeEdgePoint(onepMap)
 266             .setNodeRuleGroup(nodeRuleGroupList)
 267             .build();
 268         tapiNodes.put(rdmNode.key(), rdmNode);
 269
 270         // OMS link creation between photonoci nodes and RDM infra abstraction node
 271         Map<String, String> rdmInfraNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(List.of(rdmNode));
 272         if (photonicNepUuisMap.size() != rdmInfraNepUuisMap.size()) {
 273             LOG.warn("Unable to build OMS links between photonics nodes and RDM infrasctructure abstraction");
 274         } else {
 275             createTapiOmsLinks(photonicNepUuisMap, rdmInfraNepUuisMap);
 276         }
 277     }
 278
 279     private OduSwitchingPools createOduSwitchingPoolForTp100G() {
 280         Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
 281         int count = 1;
 282         for (TerminationPoint tp : this.oorNetworkPortList) {
 283             TpId tpid1 = tp.getTpId();
 284             TpId tpid2 = tp.augmentation(
 285                     org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1.class)
 286                 .getAssociatedConnectionMapTp().iterator().next();
 287             Set<TpId> tpList = new HashSet<>();
 288             tpList.add(tpid1);
 289             tpList.add(tpid2);
 290             NonBlockingList nbl = new NonBlockingListBuilder()
 291                 .setNblNumber(Uint16.valueOf(count))
 292                 .setTpList(tpList)
 293                 .build();
 294             nblMap.put(nbl.key(), nbl);
 295             count++;
 296         }
 297         return new OduSwitchingPoolsBuilder()
 298             .setNonBlockingList(nblMap)
 299             .setSwitchingPoolNumber(Uint16.valueOf(1))
 300             .build();
 301     }
 302
 303     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 304             pruneTapiPhotonicNodes() {
 305         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 306             prunedTapiPhotonicNodes = new ArrayList<>();
 307         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> tapiPhotonicNodes
 308             = this.tapiNodes.values().stream()
 309             .filter(n -> LayerProtocolName.PHOTONICMEDIA.equals(n.getLayerProtocolName().stream().findFirst()
 310                     .orElseThrow()))
 311             .collect(Collectors.toList());
 312         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node
 313             : tapiPhotonicNodes) {
 314             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepM = new HashMap<>();
 315             for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry : node.getOwnedNodeEdgePoint().entrySet()) {
 316                 if (entry.getValue().getName().values().stream()
 317                     .filter(name -> name.getValueName().startsWith("eNodeEdgePoint")).count() > 0) {
 318                     onepM.put(entry.getKey(), entry.getValue());
 319                 }
 320             }
 321             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node prunedNode
 322                 = new NodeBuilder(node).setOwnedNodeEdgePoint(onepM).build();
 323             prunedTapiPhotonicNodes.add(prunedNode);
 324         }
 325         return prunedTapiPhotonicNodes;
 326     }
 327
 328     private Map<String, String> convertListNodeWithListNepToMapForUuidAndName(
 329         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> nodes) {
 330         Map<String, String> uuidNameMap = new HashMap<>();
 331         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node : nodes) {
 332             for (OwnedNodeEdgePoint nep : node.nonnullOwnedNodeEdgePoint().values()) {
 333                 String nodeUuid = node.getUuid().getValue();
 334                 String nepUuid = nep.getUuid().getValue();
 335                 String nodeName = node.getName().get(new NameKey("otsi node name")).getValue();
 336                 String nepName = nep.getName().get(new NameKey(nep.getName().keySet().stream().findFirst()
 337                         .orElseThrow()))
 338                     .getValue();
 339                 uuidNameMap.put(String.join("--", nodeUuid, nepUuid), String.join("--", nodeName, nepName));
 340             }
 341         }
 342         return uuidNameMap;
 343     }
 344
 345     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node
 346             createTapiNode(Map<NameKey, Name> nodeNames, Set<LayerProtocolName> layerProtocols) {
 347         Uuid nodeUuid = null;
 348         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 349         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList = new HashMap<>();
 350         Map<RuleKey, Rule> ruleList = new HashMap<>();
 351         Set<RuleType> ruleTypes = new HashSet<>();
 352         ruleTypes.add(RuleType.FORWARDING);
 353         Rule rule = new RuleBuilder()
 354             .setLocalId("forward")
 355             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 356             .setRuleType(ruleTypes)
 357             .build();
 358         ruleList.put(rule.key(), rule);
 359         if (layerProtocols.contains(LayerProtocolName.DSR)) {
 360             nodeUuid = getNodeUuid4Dsr(onepl, nodeRuleGroupList, ruleList);
 361         } else if (layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
 362             nodeUuid = getNodeUuid4Photonic(onepl, nodeRuleGroupList, ruleList);
 363         } else {
 364             LOG.error("Undefined LayerProtocolName for {} node {}", nodeNames.get(nodeNames.keySet().iterator().next())
 365                 .getValueName(), nodeNames.get(nodeNames.keySet().iterator().next()).getValue());
 366         }
 367         return new NodeBuilder()
 368             .setUuid(nodeUuid)
 369             .setName(nodeNames)
 370             .setLayerProtocolName(layerProtocols)
 371             .setAdministrativeState(this.tapiLink.setTapiAdminState(this.ietfNodeAdminState.getName()))
 372             .setOperationalState(this.tapiLink.setTapiOperationalState(this.ietfNodeOperState.getName()))
 373             .setLifecycleState(LifecycleState.INSTALLED)
 374             .setOwnedNodeEdgePoint(onepl)
 375             .setNodeRuleGroup(nodeRuleGroupList)
 376             .build();
 377     }
 378
 379     private Uuid getNodeUuid4Photonic(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 380                                       Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList,
 381                                       Map<RuleKey, Rule> ruleList) {
 382         Uuid nodeUuid;
 383         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI));
 384         // iNep creation on otsi node
 385         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 386             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(
 387                     (String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 388                         oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 389                 .toString());
 390             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 391                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid1);
 392             Name onedName = new NameBuilder()
 393                 .setValueName("iNodeEdgePoint")
 394                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 395                     oorNetworkPortList.get(i).getTpId().getValue()))
 396                 .build();
 397
 398             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 399                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 400                 String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI));
 401             onepl.put(onep.key(), onep);
 402         }
 403         // eNep creation on otsi node
 404         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 405             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(
 406                     (String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 407                         oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
 408                 .toString());
 409             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 410                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid2);
 411             Name onedName = new NameBuilder()
 412                 .setValueName("eNodeEdgePoint")
 413                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 414                     oorNetworkPortList.get(i).getTpId().getValue()))
 415                 .build();
 416
 417             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 418                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 419                 String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI));
 420             onepl.put(onep.key(), onep);
 421         }
 422         // create NodeRuleGroup
 423         int count = 1;
 424         for (TerminationPoint tp : this.oorNetworkPortList) {
 425             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 426                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 427                 nepList = new HashMap<>();
 428             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 429                 .NodeEdgePoint inep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
 430                 .node.rule.group.NodeEdgePointBuilder()
 431                 .setTopologyUuid(tapiTopoUuid)
 432                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)))
 433                 .setNodeEdgePointUuid(
 434                     this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
 435                         tp.getTpId().getValue()))).build();
 436             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 437                 .NodeEdgePoint enep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
 438                 .node.rule.group.NodeEdgePointBuilder()
 439                 .setTopologyUuid(tapiTopoUuid)
 440                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)))
 441                 .setNodeEdgePointUuid(
 442                     this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
 443                         tp.getTpId().getValue())))
 444                 .build();
 445             nepList.put(inep.key(), inep);
 446             nepList.put(enep.key(), enep);
 447             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 448                 .setUuid(new Uuid(
 449                     UUID.nameUUIDFromBytes(("otsi node rule group " + count).getBytes(Charset.forName("UTF-8")))
 450                         .toString()))
 451                 .setRule(ruleList)
 452                 .setNodeEdgePoint(nepList)
 453                 .build();
 454             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 455             count++;
 456         }
 457         return nodeUuid;
 458     }
 459
 460     private Uuid getNodeUuid4Dsr(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 461                                  Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
 462         Uuid nodeUuid;
 463         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.DSR));
 464         // client nep creation on DSR/ODU node
 465         for (int i = 0; i < oorClientPortList.size(); i++) {
 466             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 467                 (String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 468                     oorClientPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 469             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 470                 oorClientPortList.get(i).getTpId().getValue()), nepUuid);
 471             NameBuilder nameBldr = new NameBuilder().setValue(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 472                 oorClientPortList.get(i).getTpId().getValue()));
 473             Name name;
 474             if (OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
 475                 name = nameBldr.setValueName("100G-tpdr").build();
 476             } else {
 477                 name = nameBldr.setValueName("NodeEdgePoint_C").build();
 478             }
 479
 480             OwnedNodeEdgePoint onep = createNep(oorClientPortList.get(i), Map.of(name.key(), name),
 481                 LayerProtocolName.ETH, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 482                     TapiStringConstants.DSR));
 483             onepl.put(onep.key(), onep);
 484         }
 485         // network nep creation on DSR/ODU node
 486         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 487             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 488                 (String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 489                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
 490             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 491                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid);
 492             Name onedName = new NameBuilder()
 493                 .setValueName("iNodeEdgePoint_N")
 494                 .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
 495                     oorNetworkPortList.get(i).getTpId().getValue()))
 496                 .build();
 497
 498             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 499                 LayerProtocolName.ODU, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
 500                     TapiStringConstants.I_ODU));
 501             onepl.put(onep.key(), onep);
 502         }
 503         // create NodeRuleGroup
 504         int count = 1;
 505         for (NonBlockingList nbl : this.oorOduSwitchingPool.nonnullNonBlockingList().values()) {
 506             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 507                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 508                 nepList = new HashMap<>();
 509             for (TpId tp : nbl.getTpList()) {
 510                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
 511                         tp.getValue())) || this.uuidMap.containsKey(String.join(
 512                     "+", this.ietfNodeId, TapiStringConstants.I_ODU, tp.getValue()))) {
 513                     String qual = tp.getValue().contains("CLIENT") ? TapiStringConstants.DSR
 514                         : TapiStringConstants.I_ODU;
 515                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 516                         nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 517                         .NodeEdgePointBuilder()
 518                         .setTopologyUuid(tapiTopoUuid)
 519                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 520                             TapiStringConstants.DSR)))
 521                         .setNodeEdgePointUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
 522                             qual, tp.getValue())))
 523                         .build();
 524                     nepList.put(nep.key(), nep);
 525                 }
 526             }
 527             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 528                 .setUuid(new Uuid(
 529                     UUID.nameUUIDFromBytes(("dsr node rule group " + count).getBytes(Charset.forName("UTF-8")))
 530                         .toString()))
 531                 .setRule(ruleList)
 532                 .setNodeEdgePoint(nepList)
 533                 .build();
 534             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 535             count++;
 536         }
 537         return nodeUuid;
 538     }
 539
 540     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
 541                                          LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol,
 542                                          boolean withSip, String keyword) {
 543         String key = String.join("+", keyword, oorTp.getTpId().getValue());
 544         AdministrativeState adminState = (oorTp.augmentation(TerminationPoint1.class).getAdministrativeState() != null)
 545             ? this.tapiLink.setTapiAdminState(oorTp.augmentation(TerminationPoint1.class).getAdministrativeState()
 546                 .getName())
 547             : null;
 548         OperationalState operState = (oorTp.augmentation(TerminationPoint1.class).getOperationalState() != null)
 549             ? this.tapiLink.setTapiOperationalState(oorTp.augmentation(TerminationPoint1.class).getOperationalState()
 550                 .getName())
 551             : null;
 552         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
 553             .setUuid(this.uuidMap.get(key))
 554             .setLayerProtocolName(nepProtocol)
 555             .setName(nepNames)
 556             .setSupportedCepLayerProtocolQualifierInstances(createSupportedCepLayerProtocolQualifier(oorTp,
 557                 nodeProtocol))
 558             .setDirection(Direction.BIDIRECTIONAL)
 559             .setLinkPortRole(PortRole.SYMMETRIC)
 560             .setAdministrativeState(adminState)
 561             .setOperationalState(operState)
 562             .setLifecycleState(LifecycleState.INSTALLED);
 563 //            .setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 564 //            .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL);
 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 //                .setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 594 //                .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL)
 595                 .build();
 596             onepMap.put(onep.key(), onep);
 597         }
 598         return onepMap;
 599     }
 600
 601     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(Uuid nodeUuid,
 602                                                                                Collection<OwnedNodeEdgePoint> onepl) {
 603         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey,
 604             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint>
 605             nepMap = new HashMap<>();
 606         for (OwnedNodeEdgePoint onep : onepl) {
 607             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint
 608                 nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group
 609                     .NodeEdgePointBuilder()
 610                 .setTopologyUuid(tapiTopoUuid)
 611                 .setNodeUuid(nodeUuid)
 612                 .setNodeEdgePointUuid(onep.key().getUuid())
 613                 .build();
 614             nepMap.put(nep.key(), nep);
 615         }
 616         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
 617         Set<RuleType> ruleTypes = new HashSet<>();
 618         ruleTypes.add(RuleType.FORWARDING);
 619         Map<RuleKey, Rule> ruleList = new HashMap<>();
 620         Rule rule = new RuleBuilder()
 621             .setLocalId("forward")
 622             .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 623             .setRuleType(ruleTypes)
 624             .build();
 625         ruleList.put(rule.key(), rule);
 626         NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 627             .setUuid(new Uuid(UUID.nameUUIDFromBytes(("rdm infra node rule group").getBytes(Charset.forName("UTF-8")))
 628                 .toString()))
 629             .setRule(ruleList)
 630             .setNodeEdgePoint(nepMap)
 631             .build();
 632         nodeRuleGroupMap.put(nodeRuleGroup.key(), nodeRuleGroup);
 633         return nodeRuleGroupMap;
 634     }
 635
 636     private Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createSIP(int nb, TerminationPoint tp,
 637                                                                                        String nodeId) {
 638         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
 639         for (int i = 0; i < nb; i++) {
 640             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
 641                 .setServiceInterfacePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId,
 642                     tp.getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString()))
 643                 .build();
 644             msipl.put(msip.key(), msip);
 645         }
 646         return msipl;
 647     }
 648
 649     private List<SupportedCepLayerProtocolQualifierInstances> createSupportedCepLayerProtocolQualifier(
 650             TerminationPoint tp, LayerProtocolName lpn) {
 651         List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>();
 652         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 653             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
 654             .setNumberOfCepInstances(Uint64.valueOf(1))
 655             .build());
 656         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev230526.TerminationPoint1 tp1 =
 657             tp.augmentation(org.opendaylight.yang.gen.v1.http
 658                 .org.openroadm.otn.network.topology.rev230526.TerminationPoint1.class);
 659         if (tp1 == null) {
 660             return new ArrayList<>(sclpqiList);
 661         }
 662         if (tp1.getTpSupportedInterfaces() == null) {
 663             LOG.warn("Tp supported interface doesnt exist on TP {}", tp.getTpId().getValue());
 664             return new ArrayList<>(sclpqiList);
 665         }
 666         Collection<SupportedInterfaceCapability> sicList = tp1.getTpSupportedInterfaces()
 667             .getSupportedInterfaceCapability().values();
 668         for (SupportedInterfaceCapability sic : sicList) {
 669             String ifCapType = sic.getIfCapType().toString().split("\\{")[0];
 670             switch (lpn.getName()) {
 671                 case "DSR":
 672                     switch (ifCapType) {
 673                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
 674                         //  port are extended in the config file
 675                         case "If1GEODU0":
 676                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 677                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 678                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 679                                 .build());
 680                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 681                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPEGigE.VALUE)
 682                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 683                                 .build());
 684                             break;
 685                         case "If10GEODU2e":
 686                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 687                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 688                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 689                                 .build());
 690                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 691                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 692                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 693                                 .build());
 694                             break;
 695                         case "If10GEODU2":
 696                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 697                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 698                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 699                                 .build());
 700                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 701                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 702                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 703                                 .build());
 704                             break;
 705                         case "If10GE":
 706                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 707                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE10GigELAN.VALUE)
 708                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 709                                 .build());
 710                             break;
 711                         case "If100GEODU4":
 712                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 713                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 714                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 715                                 .build());
 716                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 717                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 718                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 719                                 .build());
 720                             break;
 721                         case "If100GE":
 722                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 723                                 .setLayerProtocolQualifier(DIGITALSIGNALTYPE100GigE.VALUE)
 724                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 725                                 .build());
 726                             break;
 727                         case "IfOCHOTU4ODU4":
 728                         case "IfOCH":
 729                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 730                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 731                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 732                                 .build());
 733                             break;
 734                         default:
 735                             LOG.error("IfCapability type not managed");
 736                             break;
 737                     }
 738                     break;
 739                 //TODO: verify that in the new scope it makes sense to include ODU in the abstracted topology
 740                 case "ODU":
 741                     switch (ifCapType) {
 742                         // TODO: it may be needed to add more cases clauses if the interface capabilities of a
 743                         //  port are extended in the config file
 744                         case "If1GEODU0":
 745                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 746                                 .setLayerProtocolQualifier(ODUTYPEODU0.VALUE)
 747                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 748                                 .build());
 749                             break;
 750                         case "If10GEODU2e":
 751                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 752                                 .setLayerProtocolQualifier(ODUTYPEODU2E.VALUE)
 753                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 754                                 .build());
 755                             break;
 756                         case "If10GEODU2":
 757                         case "If10GE":
 758                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 759                                 .setLayerProtocolQualifier(ODUTYPEODU2.VALUE)
 760                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 761                                 .build());
 762                             break;
 763                         case "If100GEODU4":
 764                         case "If100GE":
 765                         case "IfOCHOTU4ODU4":
 766                         case "IfOCH":
 767                             sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 768                                 .setLayerProtocolQualifier(ODUTYPEODU4.VALUE)
 769                                 .setNumberOfCepInstances(Uint64.valueOf(0))
 770                                 .build());
 771                             break;
 772                         default:
 773                             LOG.error("IfCapability type not managed");
 774                             break;
 775                     }
 776                     break;
 777                 case "PHOTONIC_MEDIA":
 778                     if (ifCapType.equals("IfOCHOTU4ODU4") || ifCapType.equals("IfOCH")) {
 779                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 780                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE)
 781                             .setNumberOfCepInstances(Uint64.valueOf(0))
 782                             .build());
 783                         sclpqiList.add(new SupportedCepLayerProtocolQualifierInstancesBuilder()
 784                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE)
 785                             .setNumberOfCepInstances(Uint64.valueOf(0))
 786                             .build());
 787                     }
 788                     break;
 789                 default:
 790                     LOG.error("Layer Protocol Name is unknown");
 791                     break;
 792             }
 793         }
 794         return sclpqiList;
 795     }
 796
 797     private void createTapiOmsLinks(Map<String, String> photonicNepUuisMap, Map<String, String> rdmInfraNepUuisMap) {
 798         Iterator<Entry<String, String>> it1 = photonicNepUuisMap.entrySet().iterator();
 799         Iterator<Entry<String, String>> it2 = rdmInfraNepUuisMap.entrySet().iterator();
 800         while (it1.hasNext()) {
 801             Map<NodeEdgePointKey, NodeEdgePoint> nepMap = new HashMap<>();
 802             Map.Entry<String, String> photonicEntry = it1.next();
 803             Map.Entry<String, String> rdmEntry = it2.next();
 804             Uuid sourceUuidTp = new Uuid(photonicEntry.getKey().split("--")[1]);
 805             Uuid sourceUuidNode = new Uuid(photonicEntry.getKey().split("--")[0]);
 806             Uuid destUuidTp = new Uuid(rdmEntry.getKey().split("--")[1]);
 807             Uuid destUuidNode = new Uuid(rdmEntry.getKey().split("--")[0]);
 808             NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 809                 .setTopologyUuid(this.tapiTopoUuid)
 810                 .setNodeUuid(sourceUuidNode)
 811                 .setNodeEdgePointUuid(sourceUuidTp)
 812                 .build();
 813             nepMap.put(sourceNep.key(), sourceNep);
 814             NodeEdgePoint destNep = new NodeEdgePointBuilder()
 815                 .setTopologyUuid(this.tapiTopoUuid)
 816                 .setNodeUuid(destUuidNode)
 817                 .setNodeEdgePointUuid(destUuidTp)
 818                 .build();
 819             nepMap.put(destNep.key(), destNep);
 820             Name linkName = new NameBuilder().setValueName("OMS link name")
 821                 .setValue(String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 822                 .build();
 823             Link omsLink = new LinkBuilder()
 824                 .setUuid(new Uuid(
 825                     UUID.nameUUIDFromBytes((String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 826                             .getBytes(Charset.forName("UTF-8")))
 827                         .toString()))
 828                 .setName(Map.of(linkName.key(), linkName))
 829                 .setLayerProtocolName(Set.of(LayerProtocolName.PHOTONICMEDIA))
 830                 .setNodeEdgePoint(nepMap)
 831                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 832                 .build();
 833             this.tapiLinks.put(omsLink.key(), omsLink);
 834         }
 835     }
 836
 837     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 838             getTapiNodes() {
 839         return tapiNodes;
 840     }
 841
 842     public Map<LinkKey, Link> getTapiLinks() {
 843         return tapiLinks;
 844     }
 845 }