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