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.Arrays;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Map.Entry;
  19 import java.util.UUID;
  20 import java.util.stream.Collectors;
  21 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.OduSwitchingPools;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmTpType;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.Link1;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.Node1;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  31 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState;
  32 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit;
  33 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection;
  34 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LAYERPROTOCOLQUALIFIER;
  35 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName;
  36 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState;
  37 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState;
  38 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection;
  39 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole;
  40 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationDirection;
  41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationState;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.TotalSizeBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.pac.AvailableCapacityBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.pac.TotalPotentialCapacityBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameKey;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE100GigE;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE10GigELAN;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2E;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU4;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROMS;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROTSi;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ForwardingRule;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RuleType;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePoint;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePointBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePointKey;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroupBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroupKey;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.edge.point.MappedServiceInterfacePoint;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.edge.point.MappedServiceInterfacePointBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.edge.point.MappedServiceInterfacePointKey;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.Rule;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.RuleBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.RuleKey;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkKey;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey;
  77 import org.opendaylight.yangtools.yang.common.Uint64;
  78 import org.slf4j.Logger;
  79 import org.slf4j.LoggerFactory;
  80
  81
  82 public class ConvertORTopoToTapiTopo {
  83
  84     private static final String DSR = "DSR";
  85     private static final String OTSI = "OTSi";
  86     private static final String E_OTSI = "eOTSi";
  87     private static final String I_OTSI = "iOTSi";
  88     private static final String RDM_INFRA = "ROADM-infra";
  89     private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiTopo.class);
  90     private String ietfNodeId;
  91     private List<TerminationPoint> oorClientPortList;
  92     private List<TerminationPoint> oorNetworkPortList;
  93     private OduSwitchingPools oorOduSwitchingPool;
  94     private Uuid tapiTopoUuid;
  95     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
  96         tapiNodes;
  97     private Map<LinkKey, Link> tapiLinks;
  98     private Map<String, Uuid> uuidMap;
  99
 100
 101     public ConvertORTopoToTapiTopo(Uuid tapiTopoUuid) {
 102         this.tapiTopoUuid = tapiTopoUuid;
 103         this.tapiNodes = new HashMap<>();
 104         this.tapiLinks = new HashMap<>();
 105         this.uuidMap = new HashMap<>();
 106     }
 107
 108     public void convertNode(Node ietfNode, List<String> networkPorts) {
 109         this.ietfNodeId = ietfNode.getNodeId().getValue();
 110         this.oorClientPortList = ietfNode.augmentation(
 111                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 112             .getTerminationPoint().values().stream()
 113             .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 114             == OpenroadmTpType.XPONDERCLIENT.getIntValue())
 115             .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 116             .collect(Collectors.toList());
 117         this.oorNetworkPortList = ietfNode.augmentation(
 118                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
 119             .getTerminationPoint().values().stream()
 120             .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
 121             == OpenroadmTpType.XPONDERNETWORK.getIntValue()
 122             && networkPorts.contains(tp.getTpId().getValue()))
 123             .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue()))
 124             .collect(Collectors.toList());
 125         this.oorOduSwitchingPool = ietfNode.augmentation(Node1.class).getSwitchingPools().getOduSwitchingPools()
 126             .values().stream().findFirst().get();
 127
 128         // node creation [DSR/ODU]
 129         LOG.info("creation of a DSR/ODU node");
 130         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId, DSR))
 131             .getBytes(Charset.forName("UTF-8"))).toString());
 132         this.uuidMap.put(String.join("+", this.ietfNodeId, DSR), nodeUuid);
 133         Name nameDsr = new NameBuilder().setValueName("dsr/odu node name").setValue(this.ietfNodeId).build();
 134         List<LayerProtocolName> dsrLayerProtocols = Arrays.asList(LayerProtocolName.DSR, LayerProtocolName.ODU);
 135         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology
 136             .Node dsrNode = createTapiNode(Map.of(nameDsr.key(), nameDsr), dsrLayerProtocols);
 137         tapiNodes.put(dsrNode.key(), dsrNode);
 138
 139         // node creation [otsi]
 140         LOG.info("creation of an OTSi node");
 141         nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId, OTSI))
 142             .getBytes(Charset.forName("UTF-8"))).toString());
 143         this.uuidMap.put(String.join("+", this.ietfNodeId, OTSI), nodeUuid);
 144         Name nameOtsi =  new NameBuilder().setValueName("otsi node name").setValue(this.ietfNodeId).build();
 145         List<LayerProtocolName> otsiLayerProtocols = Arrays.asList(LayerProtocolName.PHOTONICMEDIA);
 146         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology
 147             .Node otsiNode = createTapiNode(Map.of(nameOtsi.key(), nameOtsi), otsiLayerProtocols);
 148         tapiNodes.put(otsiNode.key(), otsiNode);
 149
 150         // transitional link cration between network nep of DSR/ODU node and iNep of otsi node
 151         LOG.info("creation of transitional links between DSR/ODU and OTSi nodes");
 152         createTapiTransitionalLinks();
 153     }
 154
 155     public void convertLinks(List
 156         <org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link>
 157         otnLinkList) {
 158         List<String> linksToNotConvert = new ArrayList<>();
 159         LOG.info("creation of {} otn links", otnLinkList.size() / 2);
 160         for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
 161             .Link link : otnLinkList) {
 162             if (!linksToNotConvert.contains(link.getLinkId().getValue())) {
 163                 Link tapiLink = createTapiLink(link);
 164                 linksToNotConvert.add(link
 165                     .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Link1.class)
 166                     .getOppositeLink().getValue());
 167                 tapiLinks.put(tapiLink.key(), tapiLink);
 168             }
 169         }
 170     }
 171
 172     public void convertRoadmInfrastructure() {
 173         LOG.info("abstraction of the ROADM infrastructure towards a photonic node");
 174         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(RDM_INFRA.getBytes(Charset.forName("UTF-8"))).toString());
 175         Name nodeName =  new NameBuilder().setValueName("otsi node name").setValue(RDM_INFRA).build();
 176         List<LayerProtocolName> nodeLayerProtocols = Arrays.asList(LayerProtocolName.PHOTONICMEDIA);
 177
 178         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiPhotonicNodes
 179             = pruneTapiPhotonicNodes();
 180         Map<String, String> photonicNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(tapiPhotonicNodes);
 181         // nep creation for rdm infra abstraction node
 182         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = createNepForRdmNode(photonicNepUuisMap.size());
 183         // node rule group creation
 184         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList
 185             = createNodeRuleGroupForRdmNode(nodeUuid, onepMap.values());
 186         // build RDM infra node abstraction
 187         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node rdmNode = new NodeBuilder()
 188             .setUuid(nodeUuid)
 189             .setName(Map.of(nodeName.key(), nodeName))
 190             .setLayerProtocolName(nodeLayerProtocols)
 191             .setAdministrativeState(AdministrativeState.UNLOCKED)
 192             .setOperationalState(OperationalState.ENABLED)
 193             .setLifecycleState(LifecycleState.INSTALLED)
 194             .setOwnedNodeEdgePoint(onepMap)
 195             .setNodeRuleGroup(nodeRuleGroupList)
 196             .build();
 197         tapiNodes.put(rdmNode.key(), rdmNode);
 198
 199         // OMS link creation between photonoci nodes and RDM infra abstraction node
 200         Map<String, String> rdmInfraNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(List.of(rdmNode));
 201         if (photonicNepUuisMap.size() != rdmInfraNepUuisMap.size()) {
 202             LOG.warn("Unable to build OMS links between photonics nodes and RDM infrasctructure abstraction");
 203         } else {
 204             createTapiOmsLinks(photonicNepUuisMap, rdmInfraNepUuisMap);
 205         }
 206     }
 207
 208     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
 209         pruneTapiPhotonicNodes() {
 210         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
 211             prunedTapiPhotonicNodes = new ArrayList<>();
 212         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiPhotonicNodes
 213             = this.tapiNodes.values().stream()
 214                 .filter(n -> LayerProtocolName.PHOTONICMEDIA.equals(n.getLayerProtocolName().get(0)))
 215                 .collect(Collectors.toList());
 216         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node
 217             : tapiPhotonicNodes) {
 218             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepM = new HashMap<>();
 219             for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry : node.getOwnedNodeEdgePoint().entrySet()) {
 220                 if (entry.getValue().getName().values().stream()
 221                     .filter(name -> name.getValueName().startsWith("eNodeEdgePoint"))
 222                     .count() > 0) {
 223                     onepM.put(entry.getKey(), entry.getValue());
 224                 }
 225             }
 226             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node prunedNode
 227                 = new NodeBuilder(node).setOwnedNodeEdgePoint(onepM).build();
 228             prunedTapiPhotonicNodes.add(prunedNode);
 229         }
 230         return prunedTapiPhotonicNodes;
 231     }
 232
 233     private Map<String, String> convertListNodeWithListNepToMapForUuidAndName(
 234         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> nodes) {
 235         Map<String, String> uuidNameMap = new HashMap<>();
 236         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node : nodes) {
 237             for (OwnedNodeEdgePoint nep : node.nonnullOwnedNodeEdgePoint().values()) {
 238                 String nodeUuid = node.getUuid().getValue();
 239                 String nepUuid = nep.getUuid().getValue();
 240                 String nodeName = node.getName().get(new NameKey("otsi node name")).getValue();
 241                 String nepName = nep.getName().get(new NameKey(nep.getName().keySet().stream().findFirst().get()))
 242                     .getValue();
 243                 uuidNameMap.put(String.join("--", nodeUuid, nepUuid), String.join("--", nodeName, nepName));
 244             }
 245         }
 246         return uuidNameMap;
 247     }
 248
 249     private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology
 250         .Node createTapiNode(Map<NameKey, Name> nodeNames, List<LayerProtocolName> layerProtocols) {
 251         Uuid nodeUuid = null;
 252         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 253         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList = new HashMap<>();
 254         Map<RuleKey, Rule> ruleList = new HashMap<>();
 255         Rule rule = new RuleBuilder()
 256             .setLocalId("forward")
 257             .setForwardingRule(ForwardingRule.MAYFORWARDACROSSGROUP)
 258             .setRuleType(RuleType.FORWARDING)
 259             .build();
 260         ruleList.put(rule.key(), rule);
 261         if (layerProtocols.contains(LayerProtocolName.DSR)) {
 262             nodeUuid = getNodeUuid4Dsr(onepl, nodeRuleGroupList, ruleList);
 263         } else if (layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
 264             nodeUuid = getNodeUuid4Photonic(onepl, nodeRuleGroupList, ruleList);
 265         } else {
 266             LOG.error("Undefined LayerProtocolName for {} node {}", nodeNames.get(nodeNames.keySet().iterator().next())
 267                 .getValueName(), nodeNames.get(nodeNames.keySet().iterator().next()).getValue());
 268         }
 269         return new NodeBuilder()
 270                 .setUuid(nodeUuid)
 271                 .setName(nodeNames)
 272                 .setLayerProtocolName(layerProtocols)
 273                 .setAdministrativeState(AdministrativeState.UNLOCKED)
 274                 .setOperationalState(OperationalState.ENABLED)
 275                 .setLifecycleState(LifecycleState.INSTALLED)
 276                 .setOwnedNodeEdgePoint(onepl)
 277                 .setNodeRuleGroup(nodeRuleGroupList)
 278                 .build();
 279     }
 280
 281     private Uuid getNodeUuid4Photonic(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 282         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
 283         Uuid nodeUuid;
 284         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, OTSI));
 285         // iNep creation on otsi node
 286         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 287             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(
 288                     (String.join("+", this.ietfNodeId, I_OTSI, oorNetworkPortList.get(i).getTpId().getValue()))
 289                     .getBytes(Charset.forName("UTF-8")))
 290                 .toString());
 291             this.uuidMap.put(String.join("+", this.ietfNodeId, I_OTSI, oorNetworkPortList.get(i).getTpId().getValue()),
 292                 nepUuid1);
 293             Name onedName = new NameBuilder()
 294                 .setValueName(new StringBuilder("iNodeEdgePoint_").append(i + 1).toString())
 295                 .setValue(oorNetworkPortList.get(i).getTpId().getValue())
 296                 .build();
 297
 298             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 299                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 300                 String.join("+", this.ietfNodeId, I_OTSI));
 301             onepl.put(onep.key(), onep);
 302         }
 303         // eNep creation on otsi node
 304         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 305             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(
 306                     (String.join("+", this.ietfNodeId, E_OTSI, oorNetworkPortList.get(i).getTpId().getValue()))
 307                     .getBytes(Charset.forName("UTF-8")))
 308                 .toString());
 309             this.uuidMap.put(String.join("+", this.ietfNodeId, E_OTSI, oorNetworkPortList.get(i).getTpId().getValue()),
 310                 nepUuid2);
 311             Name onedName = new NameBuilder()
 312                 .setValueName(new StringBuilder("eNodeEdgePoint_").append(i + 1).toString())
 313                 .setValue(oorNetworkPortList.get(i).getTpId().getValue())
 314                 .build();
 315
 316             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 317                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 318                 String.join("+", this.ietfNodeId, E_OTSI));
 319             onepl.put(onep.key(), onep);
 320         }
 321         // create NodeRuleGroup
 322         int count = 1;
 323         for (TerminationPoint tp : this.oorNetworkPortList) {
 324             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePointKey,
 325                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint>
 326                 nepList = new HashMap<>();
 327             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group
 328                 .NodeEdgePoint inep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 329                 .node.rule.group.NodeEdgePointBuilder()
 330                 .setTopologyUuid(tapiTopoUuid)
 331                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, OTSI)))
 332                 .setNodeEdgePointUuid(
 333                     this.uuidMap.get(String.join("+", this.ietfNodeId, I_OTSI, tp.getTpId().getValue())))
 334                 .build();
 335             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group
 336                 .NodeEdgePoint enep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 337                 .node.rule.group.NodeEdgePointBuilder()
 338                 .setTopologyUuid(tapiTopoUuid)
 339                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, OTSI)))
 340                 .setNodeEdgePointUuid(
 341                     this.uuidMap.get(String.join("+", this.ietfNodeId, E_OTSI, tp.getTpId().getValue())))
 342                 .build();
 343             nepList.put(inep.key(), inep);
 344             nepList.put(enep.key(), enep);
 345             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 346                 .setUuid(new Uuid(
 347                         UUID.nameUUIDFromBytes(("otsi node rule group " + count).getBytes(Charset.forName("UTF-8")))
 348                     .toString()))
 349                 .setRule(ruleList)
 350                 .setNodeEdgePoint(nepList)
 351                 .build();
 352             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 353             count++;
 354         }
 355         return nodeUuid;
 356     }
 357
 358     private Uuid getNodeUuid4Dsr(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
 359         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
 360         Uuid nodeUuid;
 361         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, DSR));
 362         // client nep creation on DSR/ODU node
 363         for (int i = 0; i < oorClientPortList.size(); i++) {
 364             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 365                 (String.join("+", this.ietfNodeId, DSR, oorClientPortList.get(i).getTpId().getValue()))
 366                 .getBytes(Charset.forName("UTF-8"))).toString());
 367             this.uuidMap.put(String.join("+", this.ietfNodeId, DSR, oorClientPortList.get(i).getTpId().getValue()),
 368                 nepUuid);
 369             Name name = new NameBuilder()
 370                 .setValueName(new StringBuilder("NodeEdgePoint_C").append(i + 1).toString())
 371                 .setValue(oorClientPortList.get(i).getTpId().getValue())
 372                 .build();
 373
 374             OwnedNodeEdgePoint onep = createNep(oorClientPortList.get(i), Map.of(name.key(), name),
 375                 LayerProtocolName.ETH, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId, DSR));
 376             onepl.put(onep.key(), onep);
 377         }
 378         // network nep creation on DSR/ODU node
 379         for (int i = 0; i < oorNetworkPortList.size(); i++) {
 380             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
 381                 (String.join("+", this.ietfNodeId, DSR, oorNetworkPortList.get(i).getTpId().getValue()))
 382                 .getBytes(Charset.forName("UTF-8"))).toString());
 383             this.uuidMap.put(String.join("+", this.ietfNodeId, DSR, oorNetworkPortList.get(i).getTpId().getValue()),
 384                 nepUuid);
 385             Name onedName = new NameBuilder()
 386                 .setValueName(new StringBuilder("NodeEdgePoint_N").append(i + 1).toString())
 387                 .setValue(oorNetworkPortList.get(i).getTpId().getValue())
 388                 .build();
 389
 390             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
 391                 LayerProtocolName.ODU, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId, DSR));
 392             onepl.put(onep.key(), onep);
 393         }
 394         // create NodeRuleGroup
 395         int count = 1;
 396         for (NonBlockingList nbl : this.oorOduSwitchingPool.getNonBlockingList().values()) {
 397             Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePointKey,
 398                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint>
 399                 nepList = new HashMap<>();
 400             for (TpId tp : nbl.getTpList()) {
 401                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId, DSR, tp.getValue()))) {
 402                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint
 403                         nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group
 404                         .NodeEdgePointBuilder()
 405                         .setTopologyUuid(tapiTopoUuid)
 406                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, DSR)))
 407                         .setNodeEdgePointUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, DSR, tp.getValue())))
 408                         .build();
 409                     nepList.put(nep.key(), nep);
 410                 }
 411             }
 412             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 413                 .setUuid(new Uuid(
 414                         UUID.nameUUIDFromBytes(("dsr node rule group " + count).getBytes(Charset.forName("UTF-8")))
 415                     .toString()))
 416                 .setRule(ruleList)
 417                 .setNodeEdgePoint(nepList)
 418                 .build();
 419             nodeRuleGroupList.put(nodeRuleGroup.key(), nodeRuleGroup);
 420             count++;
 421         }
 422         return nodeUuid;
 423     }
 424
 425     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
 426         LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol, boolean withSip, String keyword) {
 427         String key = String.join("+", keyword, oorTp.getTpId().getValue());
 428         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
 429             .setUuid(this.uuidMap.get(key))
 430             .setLayerProtocolName(nepProtocol)
 431             .setName(nepNames);
 432         if (withSip) {
 433             onepBldr.setMappedServiceInterfacePoint(createSIP(1));
 434         }
 435         onepBldr.setSupportedCepLayerProtocolQualifier(createSupportedCepLayerProtocolQualifier(oorTp, nodeProtocol));
 436         onepBldr.setLinkPortDirection(PortDirection.BIDIRECTIONAL).setLinkPortRole(PortRole.SYMMETRIC)
 437                 .setAdministrativeState(AdministrativeState.UNLOCKED).setOperationalState(OperationalState.ENABLED)
 438                 .setLifecycleState(LifecycleState.INSTALLED).setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 439                 .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL);
 440         return onepBldr.build();
 441     }
 442
 443     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> createNepForRdmNode(int nbNep) {
 444         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 445         for (int i = 1; i <= nbNep; i++) {
 446             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "roadm node", "nep", String.valueOf(i)))
 447                 .getBytes(Charset.forName("UTF-8"))).toString());
 448             Name nepName = new NameBuilder()
 449                 .setValueName("NodeEdgePoint name")
 450                 .setValue(new StringBuilder("NodeEdgePoint_").append(i).toString())
 451                 .build();
 452             OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder()
 453                 .setUuid(nepUuid)
 454                 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA)
 455                 .setName(Map.of(nepName.key(), nepName))
 456                 .setSupportedCepLayerProtocolQualifier(List.of(PHOTONICLAYERQUALIFIEROMS.class))
 457                 .setLinkPortDirection(PortDirection.BIDIRECTIONAL).setLinkPortRole(PortRole.SYMMETRIC)
 458                 .setAdministrativeState(AdministrativeState.UNLOCKED).setOperationalState(OperationalState.ENABLED)
 459                 .setLifecycleState(LifecycleState.INSTALLED).setTerminationDirection(TerminationDirection.BIDIRECTIONAL)
 460                 .setTerminationState(TerminationState.TERMINATEDBIDIRECTIONAL)
 461                 .build();
 462             onepMap.put(onep.key(), onep);
 463         }
 464         return onepMap;
 465     }
 466
 467     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(Uuid nodeUuid,
 468         Collection<OwnedNodeEdgePoint> onepl) {
 469         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePointKey,
 470             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint>
 471             nepMap = new HashMap<>();
 472         for (OwnedNodeEdgePoint onep : onepl) {
 473             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint
 474                 nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group
 475                     .NodeEdgePointBuilder()
 476                 .setTopologyUuid(tapiTopoUuid)
 477                 .setNodeUuid(nodeUuid)
 478                 .setNodeEdgePointUuid(onep.key().getUuid())
 479                 .build();
 480             nepMap.put(nep.key(), nep);
 481         }
 482         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
 483         Map<RuleKey, Rule> ruleList = new HashMap<>();
 484         Rule rule = new RuleBuilder()
 485             .setLocalId("forward")
 486             .setForwardingRule(ForwardingRule.MAYFORWARDACROSSGROUP)
 487             .setRuleType(RuleType.FORWARDING)
 488             .build();
 489         ruleList.put(rule.key(), rule);
 490         NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
 491             .setUuid(new Uuid(UUID.nameUUIDFromBytes(("rdm infra node rule group").getBytes(Charset.forName("UTF-8")))
 492                 .toString()))
 493             .setRule(ruleList)
 494             .setNodeEdgePoint(nepMap)
 495             .build();
 496         nodeRuleGroupMap.put(nodeRuleGroup.key(), nodeRuleGroup);
 497         return nodeRuleGroupMap;
 498     }
 499
 500     private Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createSIP(int nb) {
 501         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
 502         for (int i = 0; i < nb; i++) {
 503             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
 504                 .setServiceInterfacePointUuid(new Uuid(UUID.randomUUID().toString())).build();
 505             msipl.put(msip.key(), msip);
 506         }
 507         return msipl;
 508     }
 509
 510     private List<Class<? extends LAYERPROTOCOLQUALIFIER>> createSupportedCepLayerProtocolQualifier(TerminationPoint tp,
 511         LayerProtocolName lpn) {
 512         List<Class<? extends LAYERPROTOCOLQUALIFIER>> sclpqList = new ArrayList<>();
 513         List<SupportedInterfaceCapability> sicList = new ArrayList<>(
 514             tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm
 515             .otn.network.topology.rev181130.TerminationPoint1.class).getTpSupportedInterfaces()
 516             .getSupportedInterfaceCapability().values());
 517         for (SupportedInterfaceCapability sic : sicList) {
 518             switch (lpn.getName()) {
 519                 case "DSR":
 520                     if (sic.getIfCapType().getSimpleName().equals("If10GEODU2e")) {
 521                         sclpqList.add(DIGITALSIGNALTYPE10GigELAN.class);
 522                         sclpqList.add(ODUTYPEODU2E.class);
 523                     } else if (sic.getIfCapType().getSimpleName().equals("IfOCHOTU4ODU4")) {
 524                         sclpqList.add(ODUTYPEODU4.class);
 525                     } else if (sic.getIfCapType().getSimpleName().equals("If100GEODU4")) {
 526                         sclpqList.add(DIGITALSIGNALTYPE100GigE.class);
 527                         sclpqList.add(ODUTYPEODU4.class);
 528                     }
 529                     break;
 530                 case "PHOTONIC_MEDIA":
 531                     if (sic.getIfCapType().getSimpleName().equals("IfOCHOTU4ODU4")) {
 532                         sclpqList.add(PHOTONICLAYERQUALIFIEROTSi.class);
 533                         sclpqList.add(PHOTONICLAYERQUALIFIEROMS.class);
 534                     }
 535                     break;
 536                 default:
 537                     LOG.error("Layer Protocol Name is unknown");
 538                     break;
 539             }
 540         }
 541         return sclpqList;
 542     }
 543
 544     private void createTapiTransitionalLinks() {
 545         for (TerminationPoint tp : this.oorNetworkPortList) {
 546             Map<NodeEdgePointKey, NodeEdgePoint> nepList = new HashMap<>();
 547             String sourceKey = String.join("+", this.ietfNodeId, DSR, tp.getTpId().getValue());
 548             Uuid sourceUuidTp = this.uuidMap.get(sourceKey);
 549             String destKey = String.join("+", this.ietfNodeId, I_OTSI, tp.getTpId().getValue());
 550             Uuid destUuidTp = this.uuidMap.get(destKey);
 551             NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 552                 .setTopologyUuid(this.tapiTopoUuid)
 553                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, DSR)))
 554                 .setNodeEdgePointUuid(sourceUuidTp)
 555                 .build();
 556             nepList.put(sourceNep.key(), sourceNep);
 557             NodeEdgePoint destNep = new NodeEdgePointBuilder()
 558                 .setTopologyUuid(this.tapiTopoUuid)
 559                 .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId, OTSI)))
 560                 .setNodeEdgePointUuid(destUuidTp)
 561                 .build();
 562             nepList.put(destNep.key(), destNep);
 563             Name linkName = new NameBuilder().setValueName("transitional link name")
 564                 .setValue(String.join("--", this.ietfNodeId, sourceKey, destKey))
 565                 .build();
 566             Link transiLink = new LinkBuilder()
 567                 .setUuid(new Uuid(
 568                         UUID.nameUUIDFromBytes((String.join("--", this.ietfNodeId, sourceKey, destKey))
 569                             .getBytes(Charset.forName("UTF-8")))
 570                     .toString()))
 571                 .setName(Map.of(linkName.key(), linkName))
 572                 .setTransitionedLayerProtocolName(Arrays.asList(LayerProtocolName.ODU.getName(),
 573                     LayerProtocolName.PHOTONICMEDIA.getName()))
 574                 .setNodeEdgePoint(nepList)
 575                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 576                 .setAvailableCapacity(new AvailableCapacityBuilder().setTotalSize(
 577                     new TotalSizeBuilder().setUnit(CapacityUnit.GBPS).setValue(Uint64.valueOf(100)).build()).build())
 578                 .build();
 579             this.tapiLinks.put(transiLink.key(), transiLink);
 580         }
 581     }
 582
 583     private Link createTapiLink(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 584         .networks.network.Link link) {
 585         String prefix = link.getLinkId().getValue().split("-")[0];
 586         String sourceNode = link.getSource().getSourceNode().getValue();
 587         String sourceTp = link.getSource().getSourceTp().toString();
 588         String destNode = link.getDestination().getDestNode().getValue();
 589         String destTp = link.getDestination().getDestTp().toString();
 590         Map<NodeEdgePointKey, NodeEdgePoint> nepList = new HashMap<>();
 591         Uuid sourceUuidTp;
 592         Uuid sourceUuidNode;
 593         Uuid destUuidTp;
 594         Uuid destUuidNode;
 595         Name linkName;
 596         switch (prefix) {
 597             case "OTU4":
 598                 sourceUuidTp = this.uuidMap.get(String.join("+", sourceNode, I_OTSI, sourceTp));
 599                 sourceUuidNode = this.uuidMap.get(String.join("+", sourceNode, OTSI));
 600                 NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 601                     .setTopologyUuid(this.tapiTopoUuid)
 602                     .setNodeUuid(sourceUuidNode)
 603                     .setNodeEdgePointUuid(sourceUuidTp)
 604                     .build();
 605                 nepList.put(sourceNep.key(), sourceNep);
 606                 destUuidTp = this.uuidMap.get(String.join("+", destNode, I_OTSI, destTp));
 607                 destUuidNode = this.uuidMap.get(String.join("+", destNode, OTSI));
 608                 NodeEdgePoint destNep = new NodeEdgePointBuilder()
 609                     .setTopologyUuid(this.tapiTopoUuid)
 610                     .setNodeUuid(destUuidNode)
 611                     .setNodeEdgePointUuid(destUuidTp)
 612                     .build();
 613                 nepList.put(destNep.key(), destNep);
 614                 linkName = new NameBuilder().setValueName("otn link name")
 615                     .setValue(link.getLinkId().getValue())
 616                     .build();
 617                 return new LinkBuilder()
 618                     .setUuid(new Uuid(
 619                         UUID.nameUUIDFromBytes((link.getLinkId().getValue())
 620                             .getBytes(Charset.forName("UTF-8")))
 621                     .toString()))
 622                 .setName(Map.of(linkName.key(), linkName))
 623                 .setLayerProtocolName(Arrays.asList(LayerProtocolName.PHOTONICMEDIA))
 624                 .setAdministrativeState(AdministrativeState.UNLOCKED)
 625                 .setOperationalState(OperationalState.ENABLED)
 626                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 627                 .setNodeEdgePoint(nepList)
 628                 .setTotalPotentialCapacity(new TotalPotentialCapacityBuilder().setTotalSize(
 629                     new TotalSizeBuilder().setUnit(CapacityUnit.GBPS)
 630                         .setValue(Uint64.valueOf(100)).build()).build())
 631                 .setAvailableCapacity(new AvailableCapacityBuilder().setTotalSize(
 632                     new TotalSizeBuilder().setUnit(CapacityUnit.MBPS)
 633                         .setValue(Uint64.valueOf(link.augmentation(Link1.class).getAvailableBandwidth())).build())
 634                     .build())
 635                 .build();
 636             case "ODU4":
 637                 sourceUuidTp = this.uuidMap.get(String.join("+", sourceNode, DSR, sourceTp));
 638                 sourceUuidNode = this.uuidMap.get(String.join("+", sourceNode, DSR));
 639                 NodeEdgePoint sourceNep2 = new NodeEdgePointBuilder()
 640                     .setTopologyUuid(this.tapiTopoUuid)
 641                     .setNodeUuid(sourceUuidNode)
 642                     .setNodeEdgePointUuid(sourceUuidTp)
 643                     .build();
 644                 nepList.put(sourceNep2.key(), sourceNep2);
 645                 destUuidTp = this.uuidMap.get(String.join("+", destNode, DSR, destTp));
 646                 destUuidNode = this.uuidMap.get(String.join("+", destNode, DSR));
 647                 NodeEdgePoint destNep2 = new NodeEdgePointBuilder()
 648                     .setTopologyUuid(this.tapiTopoUuid)
 649                     .setNodeUuid(destUuidNode)
 650                     .setNodeEdgePointUuid(destUuidTp)
 651                     .build();
 652                 nepList.put(destNep2.key(), destNep2);
 653                 linkName = new NameBuilder().setValueName("otn link name")
 654                     .setValue(link.getLinkId().getValue())
 655                     .build();
 656                 return new LinkBuilder()
 657                     .setUuid(new Uuid(
 658                         UUID.nameUUIDFromBytes((link.getLinkId().getValue())
 659                             .getBytes(Charset.forName("UTF-8")))
 660                     .toString()))
 661                 .setName(Map.of(linkName.key(), linkName))
 662                 .setLayerProtocolName(Arrays.asList(LayerProtocolName.ODU))
 663                 .setAdministrativeState(AdministrativeState.UNLOCKED)
 664                 .setOperationalState(OperationalState.ENABLED)
 665                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 666                 .setNodeEdgePoint(nepList)
 667                 .setTotalPotentialCapacity(new TotalPotentialCapacityBuilder().setTotalSize(
 668                     new TotalSizeBuilder().setUnit(CapacityUnit.GBPS)
 669                         .setValue(Uint64.valueOf(100)).build()).build())
 670                 .setAvailableCapacity(new AvailableCapacityBuilder().setTotalSize(
 671                     new TotalSizeBuilder().setUnit(CapacityUnit.MBPS)
 672                         .setValue(Uint64.valueOf(link.augmentation(Link1.class).getAvailableBandwidth())).build())
 673                     .build())
 674                 .build();
 675             default:
 676                 LOG.error("OTN link of type {} not managed yet", prefix);
 677                 return null;
 678         }
 679     }
 680
 681     private void createTapiOmsLinks(Map<String, String> photonicNepUuisMap, Map<String, String> rdmInfraNepUuisMap) {
 682         Iterator<Entry<String, String>> it1 = photonicNepUuisMap.entrySet().iterator();
 683         Iterator<Entry<String, String>> it2 = rdmInfraNepUuisMap.entrySet().iterator();
 684         while (it1.hasNext()) {
 685             Map<NodeEdgePointKey, NodeEdgePoint> nepMap = new HashMap<>();
 686             Map.Entry<String, String> photonicEntry = it1.next();
 687             Map.Entry<String, String> rdmEntry = it2.next();
 688             Uuid sourceUuidTp = new Uuid(photonicEntry.getKey().split("--")[1]);
 689             Uuid sourceUuidNode = new Uuid(photonicEntry.getKey().split("--")[0]);
 690             Uuid destUuidTp = new Uuid(rdmEntry.getKey().split("--")[1]);
 691             Uuid destUuidNode = new Uuid(rdmEntry.getKey().split("--")[0]);
 692             NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 693                 .setTopologyUuid(this.tapiTopoUuid)
 694                 .setNodeUuid(sourceUuidNode)
 695                 .setNodeEdgePointUuid(sourceUuidTp)
 696                 .build();
 697             nepMap.put(sourceNep.key(), sourceNep);
 698             NodeEdgePoint destNep = new NodeEdgePointBuilder()
 699                 .setTopologyUuid(this.tapiTopoUuid)
 700                 .setNodeUuid(destUuidNode)
 701                 .setNodeEdgePointUuid(destUuidTp)
 702                 .build();
 703             nepMap.put(destNep.key(), destNep);
 704             Name linkName = new NameBuilder().setValueName("OMS link name")
 705                 .setValue(String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 706                 .build();
 707             Link omsLink = new LinkBuilder()
 708                 .setUuid(new Uuid(
 709                       UUID.nameUUIDFromBytes((String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
 710                           .getBytes(Charset.forName("UTF-8")))
 711                   .toString()))
 712                 .setName(Map.of(linkName.key(), linkName))
 713                 .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA))
 714                 .setNodeEdgePoint(nepMap)
 715                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 716                 .build();
 717             this.tapiLinks.put(omsLink.key(), omsLink);
 718         }
 719     }
 720
 721     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
 722         getTapiNodes() {
 723         return tapiNodes;
 724     }
 725
 726     public Map<LinkKey, Link> getTapiLinks() {
 727         return tapiLinks;
 728     }
 729 }