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