networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmOtnTopology.java

   1 /*
   2  * Copyright © 2020 Orange. 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
   9 package org.opendaylight.transportpce.networkmodel.util;
  10
  11 import com.google.common.collect.ImmutableMap;
  12 import java.util.ArrayList;
  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.stream.Collectors;
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.opendaylight.transportpce.common.NetworkUtils;
  21 import org.opendaylight.transportpce.networkmodel.dto.OtnTopoNode;
  22 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630.OtnLinkType;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.mapping.Mapping;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.network.Nodes;
  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.device.types.rev191129.XpdrNodeTypes;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.OduSwitchingPools;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.OduSwitchingPoolsKey;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev201211.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmTpType;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityBuilder;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityKey;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODTU4TsAllocated;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODTUCnTs;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODU0;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODU2;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODU2e;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.ODU4;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OdtuTypeIdentity;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OduRateIdentity;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.Link1;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.Link1Builder;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.Node1Builder;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.TerminationPoint1;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.TerminationPoint1Builder;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.networks.network.node.SwitchingPoolsBuilder;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.networks.network.node.TpBandwidthSharingBuilder;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.networks.network.node.XpdrAttributesBuilder;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.networks.network.node.termination.point.TpSupportedInterfacesBuilder;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev211210.networks.network.node.termination.point.XpdrTpPortConnectionAttributesBuilder;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If100GE;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If100GEODU4;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If10GE;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If10GEODU2;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If10GEODU2e;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If1GEODU0;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.If400GE;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOCH;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOCHOTU4ODU4;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOTU4ODU4;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOtsiOtsigroup;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.SupportedIfCapability;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.SwitchingPoolTypes;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev211210.xpdr.otn.tp.attributes.OdtuTpnPool;
  73 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev211210.xpdr.otn.tp.attributes.OdtuTpnPoolBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  75 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
  79 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey;
  82 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
  88 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPoint;
  89 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPointBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPointKey;
  91 import org.opendaylight.yangtools.yang.common.Uint16;
  92 import org.opendaylight.yangtools.yang.common.Uint32;
  93 import org.slf4j.Logger;
  94 import org.slf4j.LoggerFactory;
  95
  96 public final class OpenRoadmOtnTopology {
  97
  98     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmOtnTopology.class);
  99     private static final String CLIENT = "-CLIENT";
 100     private static final String NETWORK = "-NETWORK";
 101     private static final String XPDR = "-XPDR";
 102     private static final String OTN_PARAMS_ERROR = "Error with otn parameters of supported link {}";
 103     private static final int NB_TRIB_PORTS = 80;
 104     private static final int NB_TRIB_SLOTS = 80;
 105
 106     private static final Map<String, OduRateIdentity> RATE_MAP = Map.of(
 107         "If100GEODU4", ODU4.VALUE,
 108         "IfOCHOTU4ODU4", ODU4.VALUE,
 109         "If1GEODU0", ODU0.VALUE,
 110         "If10GEODU2", ODU2.VALUE,
 111         "If10GEODU2e", ODU2e.VALUE);
 112     private static final Map<OtnLinkType, Long> OTNLINKTYPE_BW_MAP = Map.of(
 113         OtnLinkType.ODTU4, 100000L,
 114         OtnLinkType.ODUC4, 400000L,
 115         OtnLinkType.ODUC3, 300000L,
 116         OtnLinkType.ODUC2, 200000L);
 117     private static final Map<OtnLinkType, Long> OTNLINKTYPE_OTU_BW_MAP = Map.of(
 118         OtnLinkType.OTU4, 100000L,
 119         OtnLinkType.OTUC4, 400000L);
 120     private static final Map<Uint32, Long> SERVICERATE_BWINCR_MAP = Map.of(
 121         Uint32.valueOf(1), 1000L,
 122         Uint32.valueOf(10), 10000L,
 123         Uint32.valueOf(100), 100000L);
 124     private static final Map<Uint32, OdtuTypeIdentity> SERVICERATE_ODTUTYPECLASS_MAP = Map.of(
 125         Uint32.valueOf(1), ODTU4TsAllocated.VALUE,
 126         Uint32.valueOf(10), ODTU4TsAllocated.VALUE,
 127         Uint32.valueOf(100), ODTUCnTs.VALUE);
 128
 129     private OpenRoadmOtnTopology() {
 130     }
 131
 132     public static TopologyShard createTopologyShard(Nodes mappingNode) {
 133         List<Node> nodes = new ArrayList<>();
 134         List<Link> links = new ArrayList<>();
 135         Map<Integer, OtnTopoNode> xpdrMap = convertPortMappingToOtnNodeList(mappingNode);
 136         for (OtnTopoNode node : xpdrMap.values()) {
 137             switch (node.getNodeType()) {
 138                 case Tpdr:
 139                     nodes.add(createTpdr(node));
 140                     break;
 141                 case Mpdr:
 142                     nodes.add(createMuxpdr(node));
 143                     break;
 144                 case Switch:
 145                     nodes.add(createSwitch(node));
 146                     break;
 147                 case Regen:
 148                 case RegenUni:
 149                     // TODO: Need to revisit this method
 150                     nodes.add(createRegen(node));
 151                     break;
 152                 default:
 153                     LOG.error("unknown otn node type {}", node.getNodeType().getName());
 154                     return null;
 155             }
 156         }
 157         return new TopologyShard(nodes, links);
 158     }
 159
 160     public static TopologyShard createOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ,
 161             OtnLinkType linkType) {
 162
 163         return new TopologyShard(
 164             null,
 165             OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)
 166                 ? initialiseOtnLinks(nodeA, tpA, nodeZ, tpZ, linkType)
 167                 : null);
 168     }
 169
 170     public static TopologyShard createOtnLinks(
 171             org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.renderer.rpc.result.sp
 172                 .Link notifLink,
 173             OtnLinkType linkType) {
 174
 175         return new TopologyShard(
 176             null,
 177             initialiseOtnLinks(notifLink.getATermination().getNodeId(),
 178             notifLink.getATermination().getTpId(),
 179             notifLink.getZTermination().getNodeId(),
 180             notifLink.getZTermination().getTpId(),
 181             linkType));
 182     }
 183
 184     public static TopologyShard createOtnLinks(
 185             org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.renderer.rpc.result.sp
 186                 .Link notifLink,
 187             List<Link> supportedOtu4links, List<TerminationPoint> supportedTPs, OtnLinkType linkType) {
 188
 189         if (OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)) {
 190             return new TopologyShard(
 191                 null,
 192                 initialiseOtnLinks(
 193                     notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(),
 194                     notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType));
 195         } else if (OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
 196             List<Link> links = initialiseOtnLinks(
 197                 notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(),
 198                 notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType);
 199             links.addAll(updateOtnLinkBwParameters(supportedOtu4links, linkType));
 200             List<TerminationPoint> updatedTPs = new ArrayList<>();
 201             for (TerminationPoint tp : supportedTPs) {
 202                 updatedTPs.add(updateTp(tp, true, linkType));
 203             }
 204             return new TopologyShard(null, links, updatedTPs);
 205         } else {
 206             return null;
 207         }
 208     }
 209
 210     public static TopologyShard createOtnLinks(List<Link> suppOtuLinks, List<TerminationPoint> oldTps,
 211             OtnLinkType linkType) {
 212
 213         List<Link> links = new ArrayList<>();
 214         for (Link link : suppOtuLinks) {
 215             if (link.augmentation(Link1.class) == null) {
 216                 LOG.error("Error with OTN parameters of supported link {}", link.getLinkId().getValue());
 217                 continue;
 218             }
 219             if (!OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
 220                 LOG.error("Error with link {} : unsupported OTN link type", link.getLinkId().getValue());
 221                 continue;
 222             }
 223             if (link.augmentation(Link1.class).getAvailableBandwidth().longValue() < OTNLINKTYPE_BW_MAP.get(linkType)) {
 224                 LOG.error("Error with link {} : unsufficient available bandwith", link.getLinkId().getValue());
 225                 continue;
 226             }
 227             links.add(updateOtnLinkBwParameters(link, 0L, OTNLINKTYPE_BW_MAP.get(linkType)));
 228         }
 229         if (links.size() == 2) {
 230             links.addAll(initialiseOtnLinks(suppOtuLinks.get(0).getSource().getSourceNode().getValue(),
 231                 suppOtuLinks.get(0).getSource().getSourceTp().getValue(),
 232                 suppOtuLinks.get(0).getDestination().getDestNode().getValue(),
 233                 suppOtuLinks.get(0).getDestination().getDestTp().getValue(),
 234                 linkType));
 235         }
 236         List<TerminationPoint> tps = new ArrayList<>();
 237         for (TerminationPoint tp : oldTps) {
 238             tps.add(updateTp(tp, true, linkType));
 239         }
 240         return links.size() == 4 && tps.size() == 2
 241             ?  new TopologyShard(null, links, tps)
 242             :  new TopologyShard(null, null, null);
 243     }
 244
 245     public static TopologyShard updateOtnLinks(List<Link> suppOduLinks, List<TerminationPoint> oldTps,
 246             Uint32 serviceRate, Short tribPortNb, Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
 247
 248         List<Link> links = new ArrayList<>();
 249         if (!SERVICERATE_BWINCR_MAP.containsKey(serviceRate)) {
 250             LOG.warn("Error with not managed service rate {}", serviceRate.toString());
 251             return new TopologyShard(null, null, null);
 252         }
 253         Long bwIncr = SERVICERATE_BWINCR_MAP.get(serviceRate);
 254         for (Link link : suppOduLinks) {
 255             if (link.augmentation(Link1.class) == null
 256                     || link.augmentation(Link1.class).getAvailableBandwidth() == null
 257                     || link.augmentation(Link1.class).getUsedBandwidth() == null) {
 258                 LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
 259             } else {
 260                 Uint32 avlBw = link.augmentation(Link1.class).getAvailableBandwidth();
 261                 Uint32 usedBw = link.augmentation(Link1.class).getUsedBandwidth();
 262                 if (avlBw.toJava() < bwIncr) {
 263                     bwIncr = 0L;
 264                 }
 265                 links.add(
 266                     isDeletion
 267                         ? updateOtnLinkBwParameters(link, avlBw.toJava() + bwIncr, usedBw.toJava() - bwIncr)
 268                         : updateOtnLinkBwParameters(link, avlBw.toJava() - bwIncr, usedBw.toJava() + bwIncr)
 269                 );
 270             }
 271         }
 272         List<TerminationPoint> tps = new ArrayList<>();
 273         for (TerminationPoint tp : oldTps) {
 274             if (bwIncr > 0L) {
 275                 tps.add(updateNodeTpTsPool(tp, serviceRate, tribPortNb, minTribSlotNb, maxTribSlotNb, isDeletion));
 276             }
 277         }
 278         if (links.isEmpty() || tps.isEmpty()) {
 279             LOG.error("unable to update otn links");
 280             return new TopologyShard(null, null, null);
 281         } else {
 282             return new TopologyShard(null, links, tps);
 283         }
 284     }
 285
 286     public static TopologyShard updateOtnLinks(List<Link> suppOtuLinks, boolean isDeletion) {
 287
 288         List<Link> links = new ArrayList<>();
 289         for (Link link : suppOtuLinks) {
 290             if (link.augmentation(Link1.class) == null
 291                 || link.augmentation(Link1.class).getAvailableBandwidth() == null
 292                 || link.augmentation(Link1.class).getUsedBandwidth() == null) {
 293                 LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
 294             } else {
 295                 links.add(
 296                     isDeletion
 297                         ? updateOtnLinkBwParameters(link, Long.valueOf(100000), Long.valueOf(0))
 298                         : updateOtnLinkBwParameters(link, Long.valueOf(0), Long.valueOf(100000))
 299                 );
 300             }
 301         }
 302         if (links.isEmpty()) {
 303             LOG.error("unable to update otn links");
 304             return new TopologyShard(null, null, null);
 305         } else {
 306             return new TopologyShard(null, links, null);
 307         }
 308     }
 309
 310     public static TopologyShard deleteOtnLinks(List<Link> suppOtuLinks, List<TerminationPoint> oldTps,
 311             OtnLinkType linkType) {
 312
 313         List<Link> links = new ArrayList<>();
 314         for (Link link : suppOtuLinks) {
 315             if (link.augmentation(Link1.class) == null
 316                     || link.augmentation(
 317                             org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630
 318                                     .Link1.class) == null) {
 319                 LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
 320                 return new TopologyShard(null, null, null);
 321             }
 322             OtnLinkType otnLinkType = link.augmentation(
 323                     org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630.Link1.class)
 324                     .getOtnLinkType();
 325             if (!OTNLINKTYPE_OTU_BW_MAP.containsKey(otnLinkType)) {
 326             //TODO shouldn't other link type listed in OTNLINKTYPE_BW_MAP be handled too ?
 327                 LOG.warn("Unexpected otn-link-type {} for link {}", otnLinkType, link.getLinkId());
 328                 continue;
 329             }
 330             links.add(updateOtnLinkBwParameters(link, OTNLINKTYPE_OTU_BW_MAP.get(otnLinkType) , 0L));
 331         }
 332         List<TerminationPoint> tps = new ArrayList<>();
 333         for (TerminationPoint tp : oldTps) {
 334             tps.add(updateTp(tp, false, linkType));
 335         }
 336         return
 337             links.isEmpty() || tps.isEmpty()
 338                 ? new TopologyShard(null, null, null)
 339                 : new TopologyShard(null, links, tps);
 340     }
 341
 342     private static List<Link> initialiseOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ,
 343             OtnLinkType linkType) {
 344
 345         List<Link> links = new ArrayList<>();
 346         String nodeATopo = formatNodeName(nodeA, tpA);
 347         String nodeZTopo = formatNodeName(nodeZ, tpZ);
 348         org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630.Link1 tpceLink1
 349             = new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630.Link1Builder()
 350                 .setOtnLinkType(linkType).build();
 351         Link1Builder otnLink1Bldr = new Link1Builder()
 352             .setUsedBandwidth(Uint32.valueOf(0));
 353         if (OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)) {
 354             otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(OTNLINKTYPE_OTU_BW_MAP.get(linkType)));
 355         } else if (OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
 356             otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(OTNLINKTYPE_BW_MAP.get(linkType)));
 357         } else {
 358             LOG.error("unable to set available bandwidth to unknown link type");
 359         }
 360         // create link A-Z
 361         LinkBuilder ietfLinkAZBldr = TopologyUtils.createLink(nodeATopo, nodeZTopo, tpA, tpZ, linkType.getName());
 362         links.add(ietfLinkAZBldr
 363             .addAugmentation(tpceLink1)
 364             .addAugmentation(otnLink1Bldr.build())
 365             .addAugmentation(
 366                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1Builder(
 367                         ietfLinkAZBldr.augmentation(
 368                             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1.class))
 369                     .setLinkType(OpenroadmLinkType.OTNLINK)
 370                     .setOperationalState(State.InService)
 371                     .setAdministrativeState(AdminStates.InService)
 372                     .build())
 373             .build());
 374         // create link Z-A
 375         LinkBuilder ietfLinkZABldr = TopologyUtils.createLink(nodeZTopo, nodeATopo, tpZ, tpA, linkType.getName());
 376         links.add(ietfLinkZABldr
 377             .addAugmentation(tpceLink1)
 378             .addAugmentation(otnLink1Bldr.build())
 379             .addAugmentation(
 380                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1Builder(
 381                         ietfLinkZABldr.augmentation(
 382                             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1.class))
 383                     .setLinkType(OpenroadmLinkType.OTNLINK)
 384                     .setOperationalState(State.InService)
 385                     .setAdministrativeState(AdminStates.InService)
 386                     .build())
 387             .build());
 388         return links;
 389     }
 390
 391     private static Link updateOtnLinkBwParameters(Link link, Long availBw, Long usedBw) {
 392
 393         LOG.debug("in updateOtnLinkBwParameters with availBw = {}, usedBw = {}", availBw, usedBw);
 394         return new LinkBuilder(link)
 395             .addAugmentation(
 396                 new Link1Builder(link.augmentation(Link1.class))
 397                     .setAvailableBandwidth(Uint32.valueOf(availBw))
 398                     .setUsedBandwidth(Uint32.valueOf(usedBw))
 399                     .build())
 400             .build();
 401     }
 402
 403     private static List<Link> updateOtnLinkBwParameters(List<Link> supportedLinks, OtnLinkType linkType) {
 404
 405         LOG.debug("in updateOtnLinkBwParameters with supportedLinks = {}, linkType = {}", supportedLinks, linkType);
 406         List<Link> updatedlinks = new ArrayList<>();
 407         for (Link link : supportedLinks) {
 408             updatedlinks.add(
 409                 new LinkBuilder(link)
 410                     .addAugmentation(new Link1Builder(link.augmentation(Link1.class))
 411                         .setAvailableBandwidth(Uint32.valueOf(0))
 412                         .setUsedBandwidth(
 413                             OTNLINKTYPE_BW_MAP.containsKey(linkType)
 414                                 ? Uint32.valueOf(OTNLINKTYPE_BW_MAP.get(linkType))
 415                                 : Uint32.valueOf(0))
 416                         .build())
 417                     .build());
 418         }
 419         return updatedlinks;
 420     }
 421
 422     private static TerminationPoint updateTp(TerminationPoint originalTp, boolean addingTsTpnPoolTermination,
 423             OtnLinkType linkType) {
 424
 425         LOG.debug("in updateTp");
 426         TerminationPointBuilder tpBldr = new TerminationPointBuilder(originalTp);
 427         TerminationPoint1Builder otnTp1Bldr =
 428             new TerminationPoint1Builder(tpBldr.augmentation(TerminationPoint1.class));
 429         XpdrTpPortConnectionAttributesBuilder xtpcaBldr =
 430             new XpdrTpPortConnectionAttributesBuilder(otnTp1Bldr.getXpdrTpPortConnectionAttributes());
 431         if (addingTsTpnPoolTermination) {
 432             Set<Uint16> tsPool = new HashSet<>();
 433             for (int i = 1; i <= NB_TRIB_SLOTS; i++) {
 434                 tsPool.add(Uint16.valueOf(i));
 435             }
 436             xtpcaBldr.setTsPool(tsPool);
 437             Set<Uint16> tpnPool = new HashSet<>();
 438             int nbTribPort = NB_TRIB_PORTS;
 439             if (OtnLinkType.ODUC4.equals(linkType)) {
 440                 nbTribPort = 4;
 441             }
 442             for (int i = 1; i <= nbTribPort; i++) {
 443                 tpnPool.add(Uint16.valueOf(i));
 444             }
 445             OdtuTpnPool oduTpnPool = new OdtuTpnPoolBuilder()
 446                 .setOdtuType(ODTU4TsAllocated.VALUE)
 447                 .setTpnPool(tpnPool)
 448                 .build();
 449             xtpcaBldr.setOdtuTpnPool(ImmutableMap.of(oduTpnPool.key(),oduTpnPool));
 450         } else {
 451             xtpcaBldr.setTsPool(null);
 452             xtpcaBldr.setOdtuTpnPool(ImmutableMap.of());
 453         }
 454         return tpBldr.addAugmentation(otnTp1Bldr.setXpdrTpPortConnectionAttributes(xtpcaBldr.build()).build()).build();
 455     }
 456
 457     private static TerminationPoint updateNodeTpTsPool(TerminationPoint tp, Uint32 serviceRate, Short tribPortNb,
 458             Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
 459
 460         LOG.debug("in updateNodeTpTsPool");
 461         TerminationPointBuilder tpBldr = new TerminationPointBuilder(tp);
 462         @Nullable
 463         XpdrTpPortConnectionAttributesBuilder xtpcaBldr =
 464             new XpdrTpPortConnectionAttributesBuilder(
 465                 tpBldr.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes());
 466         Set<Uint16> tsPool = new HashSet<>(xtpcaBldr.getTsPool());
 467         if (isDeletion) {
 468             for (int i = minTribSlotNb; i <= maxTribSlotNb; i++) {
 469                 tsPool.add(Uint16.valueOf(i));
 470             }
 471         } else {
 472             for (int i = minTribSlotNb; i <= maxTribSlotNb; i++) {
 473                 tsPool.remove(Uint16.valueOf(i));
 474             }
 475         }
 476         xtpcaBldr.setTsPool(tsPool);
 477         Set<Uint16> tpnPool;
 478         List<OdtuTpnPool> odtuTpnPoolValues = new ArrayList<>(xtpcaBldr.getOdtuTpnPool().values());
 479         if (odtuTpnPoolValues.get(0).getTpnPool() == null) {
 480             tpnPool = new HashSet<>();
 481         } else {
 482             tpnPool = new HashSet<>(odtuTpnPoolValues.get(0).getTpnPool());
 483             if (isDeletion) {
 484                 tpnPool.add(Uint16.valueOf(tribPortNb));
 485             } else {
 486                 tpnPool.remove(Uint16.valueOf(tribPortNb));
 487             }
 488         }
 489         OdtuTypeIdentity odtuType;
 490         if (SERVICERATE_ODTUTYPECLASS_MAP.containsKey(serviceRate)) {
 491             odtuType = SERVICERATE_ODTUTYPECLASS_MAP.get(serviceRate);
 492         } else {
 493             odtuType = null;
 494             LOG.warn("Unable to set the odtu-type");
 495         }
 496         OdtuTpnPool odtuTpnPool = new OdtuTpnPoolBuilder()
 497             .setOdtuType(odtuType)
 498             .setTpnPool(tpnPool)
 499             .build();
 500         return tpBldr
 501             .addAugmentation(
 502                 new TerminationPoint1Builder(tp.augmentation(TerminationPoint1.class))
 503                     .setXpdrTpPortConnectionAttributes(
 504                         xtpcaBldr
 505                             .setOdtuTpnPool(ImmutableMap.of(odtuTpnPool.key(),odtuTpnPool))
 506                             .build())
 507                     .build())
 508             .build();
 509     }
 510
 511     private static Map<Integer, OtnTopoNode> convertPortMappingToOtnNodeList(Nodes mappingNode) {
 512
 513         List<Mapping> networkMappings =
 514             mappingNode.nonnullMapping().values().stream()
 515                 .filter(k -> k.getLogicalConnectionPoint().contains("NETWORK"))
 516                 .collect(Collectors.toList());
 517         Map<Integer, OtnTopoNode> xpdrMap = new HashMap<>();
 518         for (Mapping mapping : networkMappings) {
 519             Integer xpdrNb = Integer.parseInt(mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]);
 520             if (!xpdrMap.containsKey(xpdrNb)) {
 521                 List<Mapping> xpdrNetMaps =
 522                     mappingNode.nonnullMapping().values().stream()
 523                         .filter(k -> k.getLogicalConnectionPoint().contains("XPDR" + xpdrNb + NETWORK))
 524                         .collect(Collectors.toList());
 525                 List<Mapping> xpdrClMaps =
 526                     mappingNode.nonnullMapping().values().stream()
 527                         .filter(k -> k.getLogicalConnectionPoint().contains("XPDR" + xpdrNb + CLIENT))
 528                         .collect(Collectors.toList());
 529                 xpdrMap.put(
 530                     xpdrNb,
 531                     new OtnTopoNode(
 532                         mappingNode.getNodeId(),
 533                         mappingNode.getNodeInfo().getNodeClli(),
 534                         xpdrNb,
 535                         mapping.getXpdrType() == null
 536                             ? XpdrNodeTypes.Tpdr
 537                             : mapping.getXpdrType(),
 538                         fillConnectionMapLcp(xpdrNetMaps),
 539                         fillConnectionMapLcp(xpdrClMaps),
 540                         xpdrNetMaps,
 541                         xpdrClMaps
 542                     ));
 543             }
 544         }
 545         LOG.debug("there are {} xpdr to build", xpdrMap.size());
 546         xpdrMap.forEach((k, v) -> LOG.debug("xpdr {} = {} - {} - {} - {}",
 547             k, v.getNodeId(), v.getNodeType(), v.getNbTpClient(), v.getNbTpNetwork()));
 548         return xpdrMap;
 549     }
 550
 551     private static Map<String, String> fillConnectionMapLcp(List<Mapping> mappingList) {
 552
 553         Map<String, String> xpdrConnectionMap = new HashMap<>();
 554         for (Mapping map : mappingList) {
 555             xpdrConnectionMap.put(map.getLogicalConnectionPoint(), map.getConnectionMapLcp());
 556         }
 557         return xpdrConnectionMap;
 558     }
 559
 560     private static Node createTpdr(OtnTopoNode node) {
 561         Map<TerminationPointKey,TerminationPoint> tpMap = new HashMap<>();
 562         createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, false);
 563         createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
 564         // return ietfNode
 565         return new NodeBuilder()
 566             .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 567             .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
 568             .setSupportingNode(createSupportingNodes(node))
 569             .addAugmentation(
 570                 new Node1Builder()
 571                     .setXpdrAttributes(
 572                         new XpdrAttributesBuilder()
 573                             .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
 574                             .build())
 575                     .build())
 576             .addAugmentation(
 577                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 578                     .setNodeType(OpenroadmNodeType.TPDR)
 579                     .setOperationalState(State.InService)
 580                     .setAdministrativeState(AdminStates.InService)
 581                     .build())
 582             .addAugmentation(
 583                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 584                     .Node1Builder()
 585                         .setTerminationPoint(tpMap)
 586                         .build())
 587             .build();
 588     }
 589
 590     // TODO: This is same as createTpdr. After Open ROADM network models are updated,
 591     //    we will revisit this method to include regen based data.
 592     private static Node createRegen(OtnTopoNode node) {
 593         Map<TerminationPointKey,TerminationPoint> tpMap = new HashMap<>();
 594         createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, false);
 595         createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
 596         // return ietfNode
 597         return new NodeBuilder()
 598                 .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 599                 .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
 600                 .setSupportingNode(createSupportingNodes(node))
 601                 .addAugmentation(
 602                         new Node1Builder()
 603                                 .setXpdrAttributes(
 604                                         new XpdrAttributesBuilder()
 605                                                 .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
 606                                                 .build())
 607                                 .build())
 608                 .addAugmentation(
 609                         new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 610                                 .setNodeType(OpenroadmNodeType.TPDR)
 611                                 .setOperationalState(State.InService)
 612                                 .setAdministrativeState(AdminStates.InService)
 613                                 .build())
 614                 .addAugmentation(
 615                         new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 616                                 .Node1Builder()
 617                                 .setTerminationPoint(tpMap)
 618                                 .build())
 619                 .build();
 620     }
 621
 622     private static Node createMuxpdr(OtnTopoNode node) {
 623
 624         // prepare otn-topology node augmentation
 625         // TODO: will need to be completed
 626         Map<NonBlockingListKey, NonBlockingList> nbMap = new HashMap<>();
 627         for (int i = 1; i <= node.getNbTpClient(); i++) {
 628             Set<TpId> tpList = new HashSet<>();
 629             tpList.add(new TpId("XPDR" + node.getXpdrNb() + CLIENT + i));
 630             tpList.add(new TpId("XPDR" + node.getXpdrNb() + "-NETWORK1"));
 631             NonBlockingList nbl = new NonBlockingListBuilder()
 632                 .setNblNumber(Uint16.valueOf(i))
 633                 .setTpList(tpList)
 634                 .setAvailableInterconnectBandwidth(Uint32.valueOf(node.getNbTpNetwork() * 10L))
 635                 .setInterconnectBandwidthUnit(Uint32.valueOf(1000000000))
 636                 .build();
 637             nbMap.put(nbl.key(),nbl);
 638         }
 639         OduSwitchingPools oduSwitchPool = new OduSwitchingPoolsBuilder()
 640             .setSwitchingPoolNumber(Uint16.valueOf(1))
 641             .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
 642             .setNonBlockingList(nbMap)
 643             .build();
 644         Map<TerminationPointKey, TerminationPoint> tpMap = new HashMap<>();
 645         createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true);
 646         createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
 647         // return ietfNode
 648         return new NodeBuilder()
 649             .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 650             .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
 651             .setSupportingNode(createSupportingNodes(node))
 652             .addAugmentation(
 653                 new Node1Builder()
 654                     .setTpBandwidthSharing(new TpBandwidthSharingBuilder().build())
 655                     .setXpdrAttributes(
 656                         new XpdrAttributesBuilder()
 657                             .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
 658                             .build())
 659                     .setSwitchingPools(
 660                         new SwitchingPoolsBuilder()
 661                             .setOduSwitchingPools(Map.of(oduSwitchPool.key(),oduSwitchPool))
 662                             .build())
 663                     .build())
 664             .addAugmentation(
 665                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 666                     .setNodeType(OpenroadmNodeType.MUXPDR)
 667                     .setAdministrativeState(AdminStates.InService)
 668                     .setOperationalState(State.InService)
 669                     .build())
 670             .addAugmentation(
 671                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 672                     .Node1Builder()
 673                         .setTerminationPoint(tpMap)
 674                         .build())
 675             .build();
 676     }
 677
 678     private static Node createSwitch(OtnTopoNode node) {
 679
 680         Set<TpId> tpl = new HashSet<>();
 681         for (int i = 1; i <= node.getNbTpClient(); i++) {
 682             tpl.add(new TpId("XPDR" + node.getXpdrNb() + CLIENT + i));
 683         }
 684         for (int i = 1; i <= node.getNbTpNetwork(); i++) {
 685             tpl.add(new TpId("XPDR" + node.getXpdrNb() + NETWORK + i));
 686         }
 687         Map<NonBlockingListKey, NonBlockingList> nbMap = new HashMap<>();
 688         NonBlockingList nbl = new NonBlockingListBuilder()
 689             .setNblNumber(Uint16.valueOf(1))
 690             .setTpList(tpl)
 691             .build();
 692         nbMap.put(nbl.key(),nbl);
 693         OduSwitchingPools oduSwitchPool = new OduSwitchingPoolsBuilder()
 694             .setSwitchingPoolNumber(Uint16.valueOf(1))
 695             .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
 696             .setNonBlockingList(nbMap)
 697             .build();
 698         Map<OduSwitchingPoolsKey, OduSwitchingPools> oduSwitchPoolList = new HashMap<>();
 699         oduSwitchPoolList.put(oduSwitchPool.key(),oduSwitchPool);
 700         Map<TerminationPointKey, TerminationPoint> tpMap = new HashMap<>();
 701         createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true);
 702         createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
 703         // return ietfNode
 704         return new NodeBuilder()
 705             .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 706             .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
 707             .setSupportingNode(createSupportingNodes(node))
 708             .addAugmentation(
 709                 new Node1Builder()
 710                     .setTpBandwidthSharing(new TpBandwidthSharingBuilder().build())
 711                     .setXpdrAttributes(
 712                         new XpdrAttributesBuilder()
 713                             .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
 714                             .build())
 715                     .setSwitchingPools(
 716                         new SwitchingPoolsBuilder()
 717                             .setOduSwitchingPools(oduSwitchPoolList)
 718                             .build())
 719                     .build())
 720             .addAugmentation(
 721                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 722                     .setNodeType(OpenroadmNodeType.SWITCH)
 723                     .setOperationalState(State.InService)
 724                     .setAdministrativeState(AdminStates.InService)
 725                     .build())
 726             .addAugmentation(
 727                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 728                     .Node1Builder()
 729                         .setTerminationPoint(tpMap)
 730                         .build())
 731             .build();
 732     }
 733
 734     private static void createTP(Map<TerminationPointKey, TerminationPoint> tpMap,
 735             OtnTopoNode node, OpenroadmTpType tpType, boolean withRate) {
 736
 737         List<Mapping> mappings = null;
 738         switch (tpType) {
 739             case XPONDERNETWORK:
 740                 mappings = node.getXpdrNetMappings();
 741                 break;
 742             case XPONDERCLIENT:
 743                 mappings = node.getXpdrClMappings();
 744                 break;
 745             default:
 746                 LOG.error("Error with Termination Point type {}", tpType);
 747                 return;
 748         }
 749         fillTpMap(tpMap, node, tpType, withRate, mappings);
 750     }
 751
 752     private static void fillTpMap(Map<TerminationPointKey, TerminationPoint> tpMap, OtnTopoNode node,
 753             OpenroadmTpType tpType, boolean withRate, List<Mapping> mappings) {
 754
 755         for (Mapping mapping : mappings) {
 756             // openroadm-otn-topoology augmentation
 757             Map<SupportedInterfaceCapabilityKey, SupportedInterfaceCapability> supIfMap = new HashMap<>();
 758             TerminationPoint1Builder otnTp1Bldr = new TerminationPoint1Builder();
 759             if (mapping.getSupportedInterfaceCapability() == null) {
 760                 LOG.warn("mapping {} of node {} has no if-cap-type",
 761                     mapping.getLogicalConnectionPoint(), node.getNodeId());
 762             } else {
 763                 XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder();
 764                 for (org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.SupportedIfCapability
 765                         supInterCapa : mapping.getSupportedInterfaceCapability()) {
 766                     SupportedInterfaceCapability supIfCapa = new SupportedInterfaceCapabilityBuilder()
 767                         .withKey(new SupportedInterfaceCapabilityKey(convertSupIfCapa(supInterCapa.toString())))
 768                         .setIfCapType(convertSupIfCapa(supInterCapa.toString()))
 769                         .build();
 770                     supIfMap.put(supIfCapa.key(), supIfCapa);
 771                 }
 772                 otnTp1Bldr.setTpSupportedInterfaces(
 773                     new TpSupportedInterfacesBuilder()
 774                         .setSupportedInterfaceCapability(supIfMap)
 775                         .build()
 776                 );
 777                 //TODO: It is not logical to assign a priori one of the possible rate to the TP.
 778                 //Would be worth assigning per default "unallocated" at the tp creation step,
 779                 //and updating it with correct rate when it supports a specific service.
 780                 if (withRate) {
 781                     otnTp1Bldr.setXpdrTpPortConnectionAttributes(
 782                         xtpcaBldr.setRate(fixRate(mapping.getSupportedInterfaceCapability())).build());
 783                 }
 784             }
 785             setclientNwTpAttr(
 786                 tpMap,
 787                 node,
 788                 new TpId(mapping.getLogicalConnectionPoint()),
 789                 tpType,
 790                 otnTp1Bldr.build(),
 791                 mapping);
 792         }
 793     }
 794
 795     private static void setclientNwTpAttr(Map<TerminationPointKey, TerminationPoint> tpMap, OtnTopoNode node, TpId tpId,
 796             OpenroadmTpType tpType, TerminationPoint1 otnTp1, Mapping mapping) {
 797         org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.TerminationPoint1Builder cnTP1BLdr
 798                 = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 799                     .TerminationPoint1Builder();
 800         switch (tpType) {
 801             case XPONDERNETWORK:
 802                 if (node.getXpdrNetConnectionMap().get(tpId.getValue()) != null) {
 803                     cnTP1BLdr.setAssociatedConnectionMapTp(Set.of(
 804                             new TpId(node.getXpdrNetConnectionMap().get(tpId.getValue()))));
 805                 }
 806                 SupportingTerminationPoint stp = new SupportingTerminationPointBuilder()
 807                     .setNetworkRef(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))
 808                     .setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 809                     .setTpRef(tpId)
 810                     .build();
 811                 TerminationPoint ietfTpNw =
 812                     buildIetfTp(cnTP1BLdr, otnTp1, tpType, tpId, Map.of(stp.key(), stp), mapping);
 813                 tpMap.put(ietfTpNw.key(),ietfTpNw);
 814                 break;
 815             case XPONDERCLIENT:
 816                 if (node.getXpdrCliConnectionMap().get(tpId.getValue()) != null) {
 817                     cnTP1BLdr.setAssociatedConnectionMapTp(Set.of(
 818                             new TpId(node.getXpdrCliConnectionMap().get(tpId.getValue()))));
 819                 }
 820                 TerminationPoint ietfTpCl = buildIetfTp(cnTP1BLdr, otnTp1, tpType, tpId, null, mapping);
 821                 tpMap.put(ietfTpCl.key(),ietfTpCl);
 822                 break;
 823             default:
 824                 LOG.error("Undefined tpType for Termination point {} of {}", tpId.getValue(), node.getNodeId());
 825                 break;
 826         }
 827     }
 828
 829     private static OduRateIdentity fixRate(
 830             Set<org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.SupportedIfCapability> list) {
 831         for (org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.SupportedIfCapability
 832                 supIfCap: list) {
 833             String simpleName = supIfCap.toString().split("\\{")[0];
 834             if (RATE_MAP.containsKey(simpleName)) {
 835                 return RATE_MAP.get(simpleName);
 836             }
 837         }
 838         return null;
 839     }
 840
 841     private static Map<SupportingNodeKey,SupportingNode> createSupportingNodes(OtnTopoNode node) {
 842
 843         SupportingNode suppNode1 = new SupportingNodeBuilder()
 844             .setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))
 845             .setNodeRef(new NodeId(node.getNodeId()))
 846             .withKey(
 847                 new SupportingNodeKey(
 848                     new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID),
 849                     new NodeId(node.getNodeId())))
 850             .build();
 851         SupportingNode suppNode2 = new SupportingNodeBuilder()
 852             .setNetworkRef(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))
 853             .setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
 854             .withKey(
 855                 new SupportingNodeKey(
 856                     new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID),
 857                     new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
 858             .build();
 859         SupportingNode suppNode3 = new SupportingNodeBuilder()
 860             .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID))
 861             .setNodeRef(new NodeId(node.getClli()))
 862             .withKey(
 863                 new SupportingNodeKey(
 864                     new NetworkId(NetworkUtils.CLLI_NETWORK_ID),
 865                     new NodeId(node.getClli())))
 866             .build();
 867         Map<SupportingNodeKey,SupportingNode> suppNodeMap = new HashMap<>();
 868         suppNodeMap.put(suppNode1.key(),suppNode1);
 869         suppNodeMap.put(suppNode2.key(),suppNode2);
 870         suppNodeMap.put(suppNode3.key(),suppNode3);
 871         return suppNodeMap;
 872     }
 873
 874     private static TerminationPoint buildIetfTp(
 875             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.TerminationPoint1Builder cnTP1BLdr,
 876             TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId,
 877             Map<SupportingTerminationPointKey, SupportingTerminationPoint> supportTpMap, Mapping mapping) {
 878
 879         TerminationPointBuilder ietfTpBldr = new TerminationPointBuilder();
 880         if (supportTpMap != null) {
 881             ietfTpBldr.setSupportingTerminationPoint(supportTpMap);
 882         }
 883         return ietfTpBldr
 884             .setTpId(tpId)
 885             .withKey(new TerminationPointKey(tpId))
 886             .addAugmentation(otnTp1)
 887             .addAugmentation(cnTP1BLdr.setTpType(tpType)
 888                     .setAdministrativeState(TopologyUtils.setNetworkAdminState(mapping.getPortAdminState()))
 889                     .setOperationalState(TopologyUtils.setNetworkOperState(mapping.getPortOperState()))
 890                     .build())
 891                 .build();
 892     }
 893
 894     private static String formatNodeName(String nodeName, String tpName) {
 895
 896         return nodeName.contains(XPDR)
 897                 ? nodeName
 898                 : new StringBuilder(nodeName).append("-").append(tpName.split("-")[0]).toString();
 899     }
 900
 901     private static SupportedIfCapability convertSupIfCapa(String ifCapType) {
 902         ImmutableMap<String, SupportedIfCapability> capTypeMap =
 903             ImmutableMap.<String, SupportedIfCapability>builder()
 904                 .put("If400GE{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-400GE}", If400GE.VALUE)
 905                 .put("IfOTU4ODU4{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-OTU4-ODU4}",
 906                         IfOTU4ODU4.VALUE)
 907                 .put("IfOtsiOtsigroup{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-otsi-otsigroup}",
 908                     IfOtsiOtsigroup.VALUE)
 909                 .put("IfOCH{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-OCH}", IfOCH.VALUE)
 910                 .put("IfOCHOTU4ODU4{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-OCH-OTU4-ODU4}",
 911                     IfOCHOTU4ODU4.VALUE)
 912                 .put("If1GEODU0{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-1GE-ODU0}",
 913                     If1GEODU0.VALUE)
 914                 .put("If10GE{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-10GE}", If10GE.VALUE)
 915                 .put("If10GEODU2{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-10GE-ODU2}",
 916                     If10GEODU2.VALUE)
 917                 .put("If10GEODU2e{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-10GE-ODU2e}",
 918                     If10GEODU2e.VALUE)
 919                 .put("If100GE{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-100GE}", If100GE.VALUE)
 920                 .put("If100GEODU4{qname=(http://org/openroadm/port/types?revision=2023-05-26)if-100GE-ODU4}",
 921                     If100GEODU4.VALUE)
 922                 .build();
 923         if (!capTypeMap.containsKey(ifCapType)) {
 924             LOG.error("supported-if-capability {} not supported", ifCapType);
 925             return null;
 926         }
 927         return capTypeMap.get(ifCapType);
 928     }
 929
 930 }