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

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