X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=networkmodel%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fnetworkmodel%2Futil%2FOpenRoadmOtnTopology.java;h=fa02061f1d0de0215bc455d6b7ebabb2ac3a343d;hb=b5ee86a522ce3cf5c6216f10647edb08b31c72e9;hp=9702247bbb7a1a921c906f1532d40025ded8e05a;hpb=4378fca1d31d1f75c0480c752aa711fb885e6135;p=transportpce.git diff --git a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmOtnTopology.java b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmOtnTopology.java index 9702247bb..fa02061f1 100644 --- a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmOtnTopology.java +++ b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmOtnTopology.java @@ -8,49 +8,61 @@ package org.opendaylight.transportpce.networkmodel.util; +import com.google.common.collect.ImmutableMap; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; - +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.transportpce.common.NetworkUtils; import org.opendaylight.transportpce.networkmodel.dto.OtnTopoNode; import org.opendaylight.transportpce.networkmodel.dto.TopologyShard; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.Nodes; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.Mapping; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.XpdrNodeTypes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.OduSwitchingPools; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev181130.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmTpType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.xpdr.tp.supported.interfaces.SupportedInterfaceCapability; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.ODU0; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.ODU2e; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.ODU4; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.OduRateIdentity; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.Node1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.Node1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.TerminationPoint1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.TerminationPoint1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.SwitchingPools; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.SwitchingPoolsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.TpBandwidthSharing; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.TpBandwidthSharingBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.XpdrAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.XpdrAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.termination.point.TpSupportedInterfaces; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.termination.point.TpSupportedInterfacesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev181130.networks.network.node.termination.point.XpdrTpPortConnectionAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.If100GE; -import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.If100GEODU4; -import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.If10GEODU2e; -import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.IfOCHOTU4ODU4; -import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.SupportedIfCapability; -import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev181130.SwitchingPoolTypes; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210927.mapping.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210927.network.Nodes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.OduSwitchingPools; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.OduSwitchingPoolsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev200327.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmNodeType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.xpdr.tp.supported.interfaces.SupportedInterfaceCapability; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTU4TsAllocated; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTUCnTs; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU0; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU2; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU2e; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OdtuTypeIdentity; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OduRateIdentity; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPools; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPoolsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.TpBandwidthSharing; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.TpBandwidthSharingBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.XpdrAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.XpdrAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.TpSupportedInterfaces; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.TpSupportedInterfacesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.XpdrTpPortConnectionAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.SupportedIfCapability; +import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.SwitchingPoolTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPool; +import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPoolBuilder; +import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node; @@ -61,17 +73,27 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPoint; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPointBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.termination.point.SupportingTerminationPointKey; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public final class OpenRoadmOtnTopology { private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmOtnTopology.class); + private static final String CLIENT = "-CLIENT"; + private static final String NETWORK = "-NETWORK"; + private static final String XPDR = "-XPDR"; + private static final int NB_TRIB_PORTS = 80; + private static final int NB_TRIB_SLOTS = 80; + private static final int NB_TRIB_SLOT_PER_10GE = 8; private OpenRoadmOtnTopology() { } @@ -99,24 +121,391 @@ public final class OpenRoadmOtnTopology { return new TopologyShard(nodes, links); } + public static TopologyShard createOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ, + OtnLinkType linkType) { + List links = null; + if (OtnLinkType.OTU4.equals(linkType) || OtnLinkType.OTUC4.equals(linkType)) { + links = initialiseOtnLinks(nodeA, tpA, nodeZ, tpZ, linkType); + } + return new TopologyShard(null, links); + } + + public static TopologyShard createOtnLinks( + org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.renderer.rpc.result.sp + .Link notifLink, + OtnLinkType linkType) { + + return new TopologyShard(null, initialiseOtnLinks(notifLink.getATermination().getNodeId(), + notifLink.getATermination().getTpId(), notifLink.getZTermination().getNodeId(), + notifLink.getZTermination().getTpId(), linkType)); + } + + public static TopologyShard createOtnLinks( + org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.renderer.rpc.result.sp + .Link notifLink, + List supportedOtu4links, + List supportedTPs, + OtnLinkType linkType) { + + List links; + switch (linkType) { + case OTU4: + case OTUC4: + links = initialiseOtnLinks( + notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(), + notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType); + return new TopologyShard(null, links); + case ODTU4: + case ODUC4: + links = initialiseOtnLinks( + notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(), + notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType); + links.addAll(updateOtnLinkBwParameters(supportedOtu4links, linkType)); + List updatedTPs = new ArrayList<>(); + for (TerminationPoint tp : supportedTPs) { + updatedTPs.add(updateTp(tp, true, linkType)); + } + return new TopologyShard(null, links, updatedTPs); + default: + return null; + } + } + + public static TopologyShard createOtnLinks(List suppOtuLinks, List oldTps, + OtnLinkType linkType) { + List links = new ArrayList<>(); + for (Link link : suppOtuLinks) { + if (OtnLinkType.ODTU4.equals(linkType) && link.augmentation(Link1.class) != null + && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(100000))) { + links.add(updateOtnLinkBwParameters(link, 0L, 100000L)); + } else if (OtnLinkType.ODUC4.equals(linkType) && link.augmentation(Link1.class) != null + && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(400000))) { + links.add(updateOtnLinkBwParameters(link, 0L, 400000L)); + } else { + LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue()); + } + } + if (links.size() == 2) { + links.addAll(initialiseOtnLinks(suppOtuLinks.get(0).getSource().getSourceNode().getValue(), + suppOtuLinks.get(0).getSource().getSourceTp().getValue(), + suppOtuLinks.get(0).getDestination().getDestNode().getValue(), + suppOtuLinks.get(0).getDestination().getDestTp().getValue(), + linkType)); + } + List tps = new ArrayList<>(); + for (TerminationPoint tp : oldTps) { + tps.add(updateTp(tp, true, linkType)); + } + if (links.size() == 4 && tps.size() == 2) { + return new TopologyShard(null, links, tps); + } else { + return new TopologyShard(null, null, null); + } + } + + public static TopologyShard updateOtnLinks(List suppOduLinks, List oldTps, + Uint32 serviceRate, Short tribPortNb, Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) { + List links = new ArrayList<>(); + Long bwIncr; + switch (serviceRate.intValue()) { + case 1: + bwIncr = 1000L; + break; + case 10: + bwIncr = 10000L; + break; + case 100: + bwIncr = 100000L; + break; + default: + LOG.warn("Error with not managed service rate {}", serviceRate.toString()); + return new TopologyShard(null, null, null); + } + for (Link link : suppOduLinks) { + if (link.augmentation(Link1.class) != null && link.augmentation(Link1.class).getAvailableBandwidth() != null + && link.augmentation(Link1.class).getUsedBandwidth() != null) { + Uint32 avlBw = link.augmentation(Link1.class).getAvailableBandwidth(); + Uint32 usedBw = link.augmentation(Link1.class).getUsedBandwidth(); + if (avlBw.toJava() < bwIncr) { + bwIncr = 0L; + } + if (isDeletion) { + links.add(updateOtnLinkBwParameters(link, avlBw.toJava() + bwIncr, + usedBw.toJava() - bwIncr)); + } else { + links.add(updateOtnLinkBwParameters(link, avlBw.toJava() - bwIncr, + usedBw.toJava() + bwIncr)); + } + } else { + LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue()); + } + } + List tps = new ArrayList<>(); + for (TerminationPoint tp : oldTps) { + if (bwIncr != 0) { + tps.add(updateNodeTpTsPool(tp, serviceRate, tribPortNb, minTribSlotNb, maxTribSlotNb, isDeletion)); + } + } + if (!links.isEmpty() && !tps.isEmpty()) { + return new TopologyShard(null, links, tps); + } else { + LOG.error("unable to update otn links"); + return new TopologyShard(null, null, null); + } + } + + public static TopologyShard updateOtnLinks(List suppOtuLinks, boolean isDeletion) { + List links = new ArrayList<>(); + for (Link link : suppOtuLinks) { + if (link.augmentation(Link1.class) == null + || link.augmentation(Link1.class).getAvailableBandwidth() == null + || link.augmentation(Link1.class).getUsedBandwidth() == null) { + LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue()); + } else { + if (isDeletion) { + links.add(updateOtnLinkBwParameters(link, Long.valueOf(100000), Long.valueOf(0))); + } else { + links.add(updateOtnLinkBwParameters(link, Long.valueOf(0), Long.valueOf(100000))); + } + } + } + if (links.isEmpty()) { + LOG.error("unable to update otn links"); + return new TopologyShard(null, null, null); + } else { + return new TopologyShard(null, links, null); + } + } + + public static TopologyShard deleteOtnLinks(List suppOtuLinks, List oldTps, + OtnLinkType linkType) { + List links = new ArrayList<>(); + OtnLinkType otnLinkType = null; + for (Link link : suppOtuLinks) { + if (link.augmentation(Link1.class) != null && link.augmentation( + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1.class) != null) { + otnLinkType = link.augmentation( + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1.class).getOtnLinkType(); + if (OtnLinkType.OTU4.equals(otnLinkType)) { + links.add(updateOtnLinkBwParameters(link, 100000L, 0L)); + } else if (OtnLinkType.OTUC4.equals(otnLinkType)) { + links.add(updateOtnLinkBwParameters(link, 400000L, 0L)); + } else { + LOG.warn("Unexpected otn-link-type {} for link {}", otnLinkType, link.getLinkId()); + } + } else { + LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue()); + return new TopologyShard(null, null, null); + } + } + List tps = new ArrayList<>(); + for (TerminationPoint tp : oldTps) { + tps.add(updateTp(tp, false, linkType)); + } + if (!links.isEmpty() && !tps.isEmpty()) { + return new TopologyShard(null, links, tps); + } else { + return new TopologyShard(null, null, null); + } + } + + private static List initialiseOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ, + OtnLinkType linkType) { + List links = new ArrayList<>(); + String nodeATopo = formatNodeName(nodeA, tpA); + String nodeZTopo = formatNodeName(nodeZ, tpZ); + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1 tpceLink1 + = new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1Builder() + .setOtnLinkType(linkType).build(); + Link1Builder otnLink1Bldr = new Link1Builder() + .setUsedBandwidth(Uint32.valueOf(0)); + switch (linkType) { + case OTU4: + case ODTU4: + otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(100000)); + break; + case OTUC4: + case ODUC4: + otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(400000)); + break; + default: + LOG.error("unable to set available bandwidth to unknown link type"); + break; + } + // create link A-Z + LinkBuilder ietfLinkAZBldr = TopologyUtils.createLink(nodeATopo, nodeZTopo, tpA, tpZ, linkType.getName()); + ietfLinkAZBldr + .addAugmentation(tpceLink1) + .addAugmentation(otnLink1Bldr.build()) + .addAugmentation( + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder( + ietfLinkAZBldr.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1.class)) + .setLinkType(OpenroadmLinkType.OTNLINK) + .setOperationalState(State.InService) + .setAdministrativeState(AdminStates.InService) + .build()); + links.add(ietfLinkAZBldr.build()); + // create link Z-A + LinkBuilder ietfLinkZABldr = TopologyUtils.createLink(nodeZTopo, nodeATopo, tpZ, tpA, linkType.getName()); + ietfLinkZABldr + .addAugmentation(tpceLink1) + .addAugmentation(otnLink1Bldr.build()) + .addAugmentation( + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder( + ietfLinkZABldr.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1.class)) + .setLinkType(OpenroadmLinkType.OTNLINK) + .setOperationalState(State.InService) + .setAdministrativeState(AdminStates.InService) + .build()); + links.add(ietfLinkZABldr.build()); + return links; + } + + private static Link updateOtnLinkBwParameters(Link link, Long availBw, Long usedBw) { + LOG.debug("in updateOtnLinkBwParameters with availBw = {}, usedBw = {}", availBw, usedBw); + LinkBuilder updatedLinkBldr = new LinkBuilder(link); + Link1Builder updatedLink1Bldr = new Link1Builder(link.augmentation(Link1.class)) + .setAvailableBandwidth(Uint32.valueOf(availBw)) + .setUsedBandwidth(Uint32.valueOf(usedBw)); + updatedLinkBldr.addAugmentation(updatedLink1Bldr.build()); + return updatedLinkBldr.build(); + } + + private static List updateOtnLinkBwParameters(List supportedLinks, OtnLinkType linkType) { + LOG.debug("in updateOtnLinkBwParameters with supportedLinks = {}, linkType = {}", supportedLinks, linkType); + Uint32 usedBw; + switch (linkType) { + case ODTU4: + usedBw = Uint32.valueOf(100000); + break; + case ODUC4: + usedBw = Uint32.valueOf(400000); + break; + default: + usedBw = Uint32.valueOf(0); + break; + } + List updatedlinks = new ArrayList<>(); + for (Link link : supportedLinks) { + LinkBuilder updatedLinkBldr = new LinkBuilder(link); + updatedLinkBldr.addAugmentation(new Link1Builder(link.augmentation(Link1.class)) + .setAvailableBandwidth(Uint32.valueOf(0)) + .setUsedBandwidth(usedBw) + .build()); + updatedlinks.add(updatedLinkBldr.build()); + } + return updatedlinks; + } + + private static TerminationPoint updateTp(TerminationPoint originalTp, boolean addingTsTpnPoolTermination, + OtnLinkType linkType) { + LOG.debug("in updateTp"); + TerminationPointBuilder tpBldr = new TerminationPointBuilder(originalTp); + TerminationPoint1Builder otnTp1Bldr = new TerminationPoint1Builder( + tpBldr.augmentation(TerminationPoint1.class)); + XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder(otnTp1Bldr + .getXpdrTpPortConnectionAttributes()); + if (addingTsTpnPoolTermination) { + List tsPool = new ArrayList<>(); + for (int i = 1; i <= NB_TRIB_SLOTS; i++) { + tsPool.add(Uint16.valueOf(i)); + } + xtpcaBldr.setTsPool(tsPool); + List tpnPool = new ArrayList<>(); + int nbTribPort = NB_TRIB_PORTS; + if (OtnLinkType.ODUC4.equals(linkType)) { + nbTribPort = 4; + } + for (int i = 1; i <= nbTribPort; i++) { + tpnPool.add(Uint16.valueOf(i)); + } + OdtuTpnPool oduTpnPool = new OdtuTpnPoolBuilder().setOdtuType(ODTU4TsAllocated.class) + .setTpnPool(tpnPool).build(); + xtpcaBldr.setOdtuTpnPool(ImmutableMap.of(oduTpnPool.key(),oduTpnPool)); + } else { + xtpcaBldr.setTsPool(null); + xtpcaBldr.setOdtuTpnPool(ImmutableMap.of()); + } + return tpBldr.addAugmentation(otnTp1Bldr.setXpdrTpPortConnectionAttributes(xtpcaBldr.build()).build()).build(); + } + + private static TerminationPoint updateNodeTpTsPool(TerminationPoint tp, Uint32 serviceRate, Short tribPortNb, + Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) { + LOG.debug("in updateNodeTpTsPool"); + TerminationPointBuilder tpBldr = new TerminationPointBuilder(tp); + @Nullable + XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder( + tpBldr.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes()); + List tsPool = new ArrayList<>(xtpcaBldr.getTsPool()); + if (isDeletion) { + for (int i = minTribSlotNb; i <= maxTribSlotNb; i++) { + tsPool.add(Uint16.valueOf(i)); + } + } else { + for (int i = minTribSlotNb; i <= maxTribSlotNb; i++) { + tsPool.remove(Uint16.valueOf(i)); + } + } + xtpcaBldr.setTsPool(tsPool); + List tpnPool; + List odtuTpnPoolValues = new ArrayList<>(xtpcaBldr.getOdtuTpnPool().values()); + if (odtuTpnPoolValues.get(0).getTpnPool() != null) { + tpnPool = new ArrayList<>(odtuTpnPoolValues.get(0).getTpnPool()); + if (isDeletion) { + tpnPool.add(Uint16.valueOf(tribPortNb)); + } else { + tpnPool.remove(Uint16.valueOf(tribPortNb)); + } + } else { + tpnPool = new ArrayList<>(); + } + Class odtuType = null; + switch (serviceRate.intValue()) { + case 1: + case 10: + odtuType = ODTU4TsAllocated.class; + break; + case 100: + odtuType = ODTUCnTs.class; + break; + default: + LOG.warn("Unable to set the odtu-type"); + break; + } + OdtuTpnPool odtuTpnPool = new OdtuTpnPoolBuilder().setOdtuType(odtuType) + .setTpnPool(tpnPool).build(); + xtpcaBldr.setOdtuTpnPool(ImmutableMap.of(odtuTpnPool.key(),odtuTpnPool)); + + tpBldr.addAugmentation(new TerminationPoint1Builder(tp.augmentation(TerminationPoint1.class)) + .setXpdrTpPortConnectionAttributes(xtpcaBldr.build()).build()); + return tpBldr.build(); + } + private static Map convertPortMappingToOtnNodeList(Nodes mappingNode) { - List networkMappings = mappingNode.getMapping().stream().filter(k -> k.getLogicalConnectionPoint() + List networkMappings = mappingNode.nonnullMapping().values() + .stream().filter(k -> k.getLogicalConnectionPoint() .contains("NETWORK")).collect(Collectors.toList()); Map xpdrMap = new HashMap<>(); for (Mapping mapping : networkMappings) { Integer xpdrNb = Integer.parseInt(mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]); if (!xpdrMap.containsKey(xpdrNb)) { - List xpdrNetMaps = mappingNode.getMapping().stream().filter(k -> k.getLogicalConnectionPoint() - .contains("XPDR" + xpdrNb + "-NETWORK")).collect(Collectors.toList()); - List xpdrClMaps = mappingNode.getMapping().stream().filter(k -> k.getLogicalConnectionPoint() - .contains("XPDR" + xpdrNb + "-CLIENT")).collect(Collectors.toList()); + List xpdrNetMaps = mappingNode.nonnullMapping().values() + .stream().filter(k -> k.getLogicalConnectionPoint() + .contains("XPDR" + xpdrNb + NETWORK)).collect(Collectors.toList()); + List xpdrClMaps = mappingNode.nonnullMapping().values() + .stream().filter(k -> k.getLogicalConnectionPoint() + .contains("XPDR" + xpdrNb + CLIENT)).collect(Collectors.toList()); OtnTopoNode otnNode = null; if (mapping.getXponderType() != null) { otnNode = new OtnTopoNode(mappingNode.getNodeId(), mappingNode.getNodeInfo().getNodeClli(), xpdrNb, - mapping.getXponderType(), fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps)); + mapping.getXponderType(), fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps), + xpdrNetMaps, xpdrClMaps); } else { otnNode = new OtnTopoNode(mappingNode.getNodeId(), mappingNode.getNodeInfo().getNodeClli(), xpdrNb, - XpdrNodeTypes.Tpdr, fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps)); + XpdrNodeTypes.Tpdr, fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps), + xpdrNetMaps, xpdrClMaps); } xpdrMap.put(xpdrNb, otnNode); } @@ -140,102 +529,103 @@ public final class OpenRoadmOtnTopology { } private static Node createTpdr(OtnTopoNode node) { - //create otn-topology node augmentation + // create otn-topology node augmentation XpdrAttributes xpdrAttr = new XpdrAttributesBuilder() - .setXpdrNumber(Integer.valueOf(node.getXpdrNb())) + .setXpdrNumber(Uint16.valueOf(node.getXpdrNb())) .build(); Node1 otnNodeAug = new Node1Builder() .setXpdrAttributes(xpdrAttr) .build(); - org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1 ocnNodeAug = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1Builder() - .setNodeType(OpenroadmNodeType.TPDR).build(); - //create ietf node augmentation to add TP list - List tpList = new ArrayList<>(); + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug = + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder() + .setNodeType(OpenroadmNodeType.TPDR) + .setOperationalState(State.InService) + .setAdministrativeState(AdminStates.InService) + .build(); + // create ietf node augmentation to add TP list + Map tpMap = new HashMap<>(); // creation of tps - createTP(tpList, node, OpenroadmTpType.XPONDERCLIENT, If100GE.class, false); - createTP(tpList, node, OpenroadmTpType.XPONDERNETWORK, IfOCHOTU4ODU4.class, true); + createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, false); + createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder() - .setTerminationPoint(tpList) + .setTerminationPoint(tpMap) .build(); - //return ietfNode + // return ietfNode return new NodeBuilder() - .setNodeId(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb())) - .withKey(new NodeKey(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb()))) + .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())) + .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))) .setSupportingNode(createSupportingNodes(node)) - .addAugmentation(Node1.class, otnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1.class, - ocnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226 - .Node1.class, ietfNodeAug) + .addAugmentation(otnNodeAug) + .addAugmentation(ocnNodeAug) + .addAugmentation(ietfNodeAug) .build(); } private static Node createMuxpdr(OtnTopoNode node) { - //create otn-topology node augmentation - TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build(); // to be completed + // create otn-topology node augmentation + // TODO: will need to be completed + TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build(); XpdrAttributes xpdrAttr = new XpdrAttributesBuilder() - .setXpdrNumber(Integer.valueOf(node.getXpdrNb())) + .setXpdrNumber(Uint16.valueOf(node.getXpdrNb())) .build(); - List nblList = new ArrayList<>(); + Map nbMap = new HashMap<>(); for (int i = 1; i <= node.getNbTpClient(); i++) { List tpList = new ArrayList<>(); - TpId tpId = new TpId("XPDR" + node.getXpdrNb() + "-CLIENT" + i); + TpId tpId = new TpId("XPDR" + node.getXpdrNb() + CLIENT + i); tpList.add(tpId); tpId = new TpId("XPDR" + node.getXpdrNb() + "-NETWORK1"); tpList.add(tpId); NonBlockingList nbl = new NonBlockingListBuilder() - .setNblNumber(i) + .setNblNumber(Uint16.valueOf(i)) .setTpList(tpList) - .setAvailableInterconnectBandwidth(Long.valueOf(node.getNbTpNetwork() * 10)) - .setInterconnectBandwidthUnit(Long.valueOf(1000000000)) + .setAvailableInterconnectBandwidth(Uint32.valueOf(node.getNbTpNetwork() * 10L)) + .setInterconnectBandwidthUnit(Uint32.valueOf(1000000000)) .build(); - nblList.add(nbl); + nbMap.put(nbl.key(),nbl); } OduSwitchingPools oduSwitchPool = new OduSwitchingPoolsBuilder() - .setSwitchingPoolNumber(Integer.valueOf(1)) + .setSwitchingPoolNumber(Uint16.valueOf(1)) .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking) - .setNonBlockingList(nblList) + .setNonBlockingList(nbMap) .build(); - List oduSwitchPoolList = new ArrayList<>(); - oduSwitchPoolList.add(oduSwitchPool); SwitchingPools switchingPools = new SwitchingPoolsBuilder() - .setOduSwitchingPools(oduSwitchPoolList) + .setOduSwitchingPools(Map.of(oduSwitchPool.key(),oduSwitchPool)) .build(); Node1 otnNodeAug = new Node1Builder() .setTpBandwidthSharing(tpBwSh) .setXpdrAttributes(xpdrAttr) .setSwitchingPools(switchingPools) .build(); - org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1 ocnNodeAug = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1Builder() - .setNodeType(OpenroadmNodeType.MUXPDR).build(); + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug = + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder() + .setNodeType(OpenroadmNodeType.MUXPDR) + .setAdministrativeState(AdminStates.InService) + .setOperationalState(State.InService) + .build(); - //create ietf node augmentation to add TP list - List tpList = new ArrayList<>(); + // create ietf node augmentation to add TP list + Map tpMap = new HashMap<>(); // creation of tps - createTP(tpList, node, OpenroadmTpType.XPONDERCLIENT, If10GEODU2e.class, true); - createTP(tpList, node, OpenroadmTpType.XPONDERNETWORK, IfOCHOTU4ODU4.class, true); + createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true); + createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder() - .setTerminationPoint(tpList) + .setTerminationPoint(tpMap) .build(); - //return ietfNode + // return ietfNode return new NodeBuilder() - .setNodeId(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb())) - .withKey(new NodeKey(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb()))) + .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())) + .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))) .setSupportingNode(createSupportingNodes(node)) - .addAugmentation(Node1.class, otnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1.class, - ocnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226 - .Node1.class, ietfNodeAug) + .addAugmentation(otnNodeAug) + .addAugmentation(ocnNodeAug) + .addAugmentation(ietfNodeAug) .build(); } @@ -243,35 +633,36 @@ public final class OpenRoadmOtnTopology { List tpl = new ArrayList<>(); TpId tpId = null; for (int i = 1; i <= node.getNbTpClient(); i++) { - tpId = new TpId("XPDR" + node.getXpdrNb() + "-CLIENT" + i); + tpId = new TpId("XPDR" + node.getXpdrNb() + CLIENT + i); tpl.add(tpId); } for (int i = 1; i <= node.getNbTpNetwork(); i++) { - tpId = new TpId("XPDR" + node.getXpdrNb() + "-NETWORK" + i); + tpId = new TpId("XPDR" + node.getXpdrNb() + NETWORK + i); tpl.add(tpId); } - List nblList = new ArrayList<>(); + Map nbMap = new HashMap<>(); NonBlockingList nbl = new NonBlockingListBuilder() - .setNblNumber(Integer.valueOf(1)) + .setNblNumber(Uint16.valueOf(1)) .setTpList(tpl) .build(); - nblList.add(nbl); + nbMap.put(nbl.key(),nbl); OduSwitchingPools oduSwitchPool = new OduSwitchingPoolsBuilder() - .setSwitchingPoolNumber(Integer.valueOf(1)) + .setSwitchingPoolNumber(Uint16.valueOf(1)) .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking) - .setNonBlockingList(nblList) + .setNonBlockingList(nbMap) .build(); - List oduSwitchPoolList = new ArrayList<>(); - oduSwitchPoolList.add(oduSwitchPool); + Map oduSwitchPoolList = new HashMap<>(); + oduSwitchPoolList.put(oduSwitchPool.key(),oduSwitchPool); SwitchingPools switchingPools = new SwitchingPoolsBuilder() .setOduSwitchingPools(oduSwitchPoolList) .build(); - //create otn-topology node augmentation - TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build(); // to be completed + // create otn-topology node augmentation + // TODO: will need to be completed + TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build(); XpdrAttributes xpdrAttr = new XpdrAttributesBuilder() - .setXpdrNumber(Integer.valueOf(node.getXpdrNb())) + .setXpdrNumber(Uint16.valueOf(node.getXpdrNb())) .build(); Node1 otnNodeAug = new Node1Builder() @@ -279,103 +670,135 @@ public final class OpenRoadmOtnTopology { .setXpdrAttributes(xpdrAttr) .setSwitchingPools(switchingPools) .build(); - org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1 ocnNodeAug = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1Builder() - .setNodeType(OpenroadmNodeType.SWITCH).build(); + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug = + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder() + .setNodeType(OpenroadmNodeType.SWITCH) + .setOperationalState(State.InService) + .setAdministrativeState(AdminStates.InService) + .build(); - //create ietf node augmentation to add TP list - List tpList = new ArrayList<>(); + // create ietf node augmentation to add TP list + Map tpMap = new HashMap<>(); // creation of tps - createTP(tpList, node, OpenroadmTpType.XPONDERCLIENT, If100GEODU4.class, true); - createTP(tpList, node, OpenroadmTpType.XPONDERNETWORK, IfOCHOTU4ODU4.class, true); + createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true); + createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder() - .setTerminationPoint(tpList) + .setTerminationPoint(tpMap) .build(); - //return ietfNode + // return ietfNode return new NodeBuilder() - .setNodeId(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb())) - .withKey(new NodeKey(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb()))) + .setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())) + .withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))) .setSupportingNode(createSupportingNodes(node)) - .addAugmentation(Node1.class, otnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1.class, - ocnNodeAug) - .addAugmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226 - .Node1.class, ietfNodeAug) + .addAugmentation(otnNodeAug) + .addAugmentation(ocnNodeAug) + .addAugmentation(ietfNodeAug) .build(); } - private static void createTP(List tpList, OtnTopoNode node, OpenroadmTpType tpType, - Class ifCapType, boolean withRate) { - long nbTps = 0; - if (OpenroadmTpType.XPONDERCLIENT.equals(tpType)) { - nbTps = node.getNbTpClient(); - } else if (OpenroadmTpType.XPONDERNETWORK.equals(tpType)) { - nbTps = node.getNbTpNetwork(); - } else { - LOG.warn("Wrong tp-type {}, cannot create tp {}", tpType.getName()); + private static void createTP(Map tpMap, + OtnTopoNode node, OpenroadmTpType tpType, boolean withRate) { + List mappings = null; + switch (tpType) { + case XPONDERNETWORK: + mappings = node.getXpdrNetMappings(); + break; + case XPONDERCLIENT: + mappings = node.getXpdrClMappings(); + break; + default: + LOG.error("Error with Termination Point type {}", tpType); + return; } + fillTpMap(tpMap, node, tpType, withRate, mappings); + } - for (int i = 1; i <= nbTps; i++) { - //openroadm-otn-topoology augmentation - SupportedInterfaceCapability supIfCapa = new SupportedInterfaceCapabilityBuilder() - .setIfCapType(ifCapType) - .build(); - List supIfCapaList = new ArrayList<>(); - supIfCapaList.add(supIfCapa); - TpSupportedInterfaces tpSupIf = new TpSupportedInterfacesBuilder() - .setSupportedInterfaceCapability(supIfCapaList) - .build(); - - XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder(); - if (withRate) { - xtpcaBldr.setRate(fixRate(ifCapType)); + private static void fillTpMap(Map tpMap, OtnTopoNode node, + OpenroadmTpType tpType, boolean withRate, List mappings) { + for (Mapping mapping : mappings) { + // openroadm-otn-topoology augmentation + Map supIfMap = new HashMap<>(); + TerminationPoint1Builder otnTp1Bldr = new TerminationPoint1Builder(); + if (mapping.getSupportedInterfaceCapability() != null) { + XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder(); + for (Class supInterCapa : mapping.getSupportedInterfaceCapability()) { + SupportedInterfaceCapability supIfCapa = new SupportedInterfaceCapabilityBuilder() + .withKey(new SupportedInterfaceCapabilityKey(supInterCapa)) + .setIfCapType(supInterCapa) + .build(); + supIfMap.put(supIfCapa.key(), supIfCapa); + } + TpSupportedInterfaces tpSupIf = new TpSupportedInterfacesBuilder() + .setSupportedInterfaceCapability(supIfMap) + .build(); + otnTp1Bldr.setTpSupportedInterfaces(tpSupIf); + //TODO: It is not logical to assign a priori one of the possible rate to the TP. + //Would be worth assigning per default "unallocated" at the tp creation step, + //and updating it with correct rate when it supports a specific service. + if (withRate) { + xtpcaBldr.setRate(fixRate(mapping.getSupportedInterfaceCapability())); + otnTp1Bldr.setXpdrTpPortConnectionAttributes(xtpcaBldr.build()); + } + } else { + LOG.warn("mapping {} of node {} has no if-cap-type", mapping.getLogicalConnectionPoint(), + node.getNodeId()); } - TerminationPoint1 otnTp1 = new TerminationPoint1Builder() - .setTpSupportedInterfaces(tpSupIf) - .setXpdrTpPortConnectionAttributes(xtpcaBldr.build()) - .build(); - org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.TerminationPoint1Builder tpceTp1Bldr = - new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.TerminationPoint1Builder(); - if (OpenroadmTpType.XPONDERNETWORK.equals(tpType)) { - TpId tpId = new TpId("XPDR" + node.getXpdrNb() + "-NETWORK" + i); + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr = + new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder(); + TpId tpId = new TpId(mapping.getLogicalConnectionPoint()); + setclientNwTpAttr(tpMap, node, tpId, tpType, otnTp1Bldr.build(), tpceTp1Bldr, mapping); + } + } + + private static void setclientNwTpAttr(Map tpMap, OtnTopoNode node, TpId tpId, + OpenroadmTpType tpType, TerminationPoint1 otnTp1, + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr, + Mapping mapping) { + switch (tpType) { + case XPONDERNETWORK: if (node.getXpdrNetConnectionMap().get(tpId.getValue()) != null) { tpceTp1Bldr.setAssociatedConnectionMapPort(node.getXpdrNetConnectionMap().get(tpId.getValue())); } SupportingTerminationPoint stp = new SupportingTerminationPointBuilder() .setNetworkRef(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)) - .setNodeRef(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb())) - .setTpRef("XPDR" + node.getXpdrNb() + "-NETWORK" + i) + .setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())) + .setTpRef(tpId) .build(); - List supportTpList = new ArrayList<>(); - supportTpList.add(stp); - tpList.add(buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, supportTpList)); - } else if (OpenroadmTpType.XPONDERCLIENT.equals(tpType)) { - TpId tpId = new TpId("XPDR" + node.getXpdrNb() + "-CLIENT" + i); + TerminationPoint ietfTpNw = buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, Map.of(stp.key(), stp), + mapping); + tpMap.put(ietfTpNw.key(),ietfTpNw); + break; + case XPONDERCLIENT: if (node.getXpdrCliConnectionMap().get(tpId.getValue()) != null) { tpceTp1Bldr.setAssociatedConnectionMapPort(node.getXpdrCliConnectionMap().get(tpId.getValue())); } - tpList.add(buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, null)); - } + TerminationPoint ietfTpCl = buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, null, mapping); + tpMap.put(ietfTpCl.key(),ietfTpCl); + break; + default: + LOG.error("Undefined tpType for Termination point {} of {}", tpId.getValue(), node.getNodeId()); + break; } } - private static Class fixRate(Class ifCapaType) { - switch (ifCapaType.getSimpleName()) { - case "If100GEODU4": - case "IfOCHOTU4ODU4": - return ODU4.class; - case "If1GEODU0": - return ODU0.class; - case "If10GEODU2e": - return ODU2e.class; - default: - return null; + private static Class fixRate(List> list) { + Map> rateMap = Map.of( + "If100GEODU4", ODU4.class, + "IfOCHOTU4ODU4", ODU4.class, + "If1GEODU0", ODU0.class, + "If10GEODU2", ODU2.class, + "If10GEODU2e", ODU2e.class); + for (Class class1 : list) { + if (rateMap.containsKey(class1.getSimpleName())) { + return rateMap.get(class1.getSimpleName()); + } } + return null; } - private static List createSupportingNodes(OtnTopoNode node) { + private static Map createSupportingNodes(OtnTopoNode node) { SupportingNode suppNode1 = new SupportingNodeBuilder() .setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)) .setNodeRef(new NodeId(node.getNodeId())) @@ -384,9 +807,9 @@ public final class OpenRoadmOtnTopology { .build(); SupportingNode suppNode2 = new SupportingNodeBuilder() .setNetworkRef(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)) - .setNodeRef(new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb())) + .setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())) .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID), - new NodeId(node.getNodeId() + "-XPDR" + node.getXpdrNb()))) + new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))) .build(); SupportingNode suppNode3 = new SupportingNodeBuilder() .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)) @@ -394,34 +817,42 @@ public final class OpenRoadmOtnTopology { .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID), new NodeId(node.getClli()))) .build(); - List suppNodeList = new ArrayList<>(); - suppNodeList.add(suppNode1); - suppNodeList.add(suppNode2); - suppNodeList.add(suppNode3); - return suppNodeList; + Map suppNodeMap = new HashMap<>(); + suppNodeMap.put(suppNode1.key(),suppNode1); + suppNodeMap.put(suppNode2.key(),suppNode2); + suppNodeMap.put(suppNode3.key(),suppNode3); + return suppNodeMap; } - private static TerminationPoint buildIetfTp(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129 - .TerminationPoint1Builder tpceTp1Bldr, TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId, - List supportTpList) { + private static TerminationPoint buildIetfTp( + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr, + TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId, + Map supportTpMap, Mapping mapping) { TerminationPointBuilder ietfTpBldr = new TerminationPointBuilder(); if (tpceTp1Bldr.getAssociatedConnectionMapPort() != null) { - ietfTpBldr.addAugmentation(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129 - .TerminationPoint1.class, tpceTp1Bldr.build()); - } - if (supportTpList != null) { - ietfTpBldr.setSupportingTerminationPoint(supportTpList); - } - org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1 ocnTp = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130 - .TerminationPoint1Builder().setTpType(tpType).build(); - - ietfTpBldr.setTpId(tpId) - .withKey(new TerminationPointKey(tpId)) - .addAugmentation(TerminationPoint1.class, otnTp1) - .addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130 - .TerminationPoint1.class, ocnTp); - return ietfTpBldr.build(); + ietfTpBldr.addAugmentation(tpceTp1Bldr.build()); + } + if (supportTpMap != null) { + ietfTpBldr.setSupportingTerminationPoint(supportTpMap); + } + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1 ocnTp = + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder() + .setTpType(tpType) + .setAdministrativeState(TopologyUtils.setNetworkAdminState(mapping.getPortAdminState())) + .setOperationalState(TopologyUtils.setNetworkOperState(mapping.getPortOperState())) + .build(); + + return ietfTpBldr.setTpId(tpId) + .withKey(new TerminationPointKey(tpId)) + .addAugmentation(otnTp1) + .addAugmentation(ocnTp) + .build(); + } + + private static String formatNodeName(String nodeName, String tpName) { + return nodeName.contains(XPDR) + ? nodeName + : new StringBuilder(nodeName).append("-").append(tpName.split("-")[0]).toString(); } }