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