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