tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TopologyUtils.java

   1 /*
   2  * Copyright © 2021 Nokia, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.tapi.topology;
   9
  10 import com.google.common.util.concurrent.FluentFuture;
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import java.nio.charset.Charset;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.NoSuchElementException;
  19 import java.util.Optional;
  20 import java.util.UUID;
  21 import java.util.concurrent.ExecutionException;
  22 import java.util.stream.Collectors;
  23 import org.eclipse.jdt.annotation.NonNull;
  24 import org.eclipse.jdt.annotation.Nullable;
  25 import org.opendaylight.mdsal.binding.api.DataBroker;
  26 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  27 import org.opendaylight.transportpce.common.InstanceIdentifiers;
  28 import org.opendaylight.transportpce.common.NetworkUtils;
  29 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.MappingKey;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
  33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmNodeType;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePoint;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePointKey;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkKey;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyBuilder;
  61 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  62 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66 public final class TopologyUtils {
  67
  68     private final NetworkTransactionService networkTransactionService;
  69     private final DataBroker dataBroker;
  70     private static final Logger LOG = LoggerFactory.getLogger(TopologyUtils.class);
  71     public static final String T0_MULTILAYER = "T0 - Multi-layer topology";
  72     public static final String T0_FULL_MULTILAYER = "T0 - Full Multi-layer topology";
  73     public static final String TPDR_100G = "Transponder 100GE";
  74     private Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSips;
  75
  76     public TopologyUtils(NetworkTransactionService networkTransactionService, DataBroker dataBroker) {
  77         this.networkTransactionService = networkTransactionService;
  78         this.dataBroker = dataBroker;
  79         this.tapiSips = new HashMap<>();
  80     }
  81
  82     public Network readTopology(InstanceIdentifier<Network> networkIID) throws TapiTopologyException {
  83         Network topology = null;
  84         ListenableFuture<Optional<Network>> topologyFuture =
  85                 this.networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, networkIID);
  86         try {
  87             topology = topologyFuture.get().get();
  88         } catch (InterruptedException e) {
  89             Thread.currentThread().interrupt();
  90             throw new TapiTopologyException("Unable to get from mdsal topology: " + networkIID
  91                     .firstKeyOf(Network.class).getNetworkId().getValue(), e);
  92         } catch (ExecutionException e) {
  93             throw new TapiTopologyException("Unable to get from mdsal topology: " + networkIID
  94                     .firstKeyOf(Network.class).getNetworkId().getValue(), e);
  95         } catch (NoSuchElementException e) {
  96             return null;
  97         }
  98         return topology;
  99     }
 100
 101     public Topology createFullOtnTopology() throws TapiTopologyException {
 102         // read openroadm-topology
 103         Network openroadmTopo = readTopology(InstanceIdentifiers.OVERLAY_NETWORK_II);
 104         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER
 105             .getBytes(Charset.forName("UTF-8"))).toString());
 106         Name name = new NameBuilder().setValue(TopologyUtils.T0_FULL_MULTILAYER).setValueName("TAPI Topology Name")
 107             .build();
 108         if (openroadmTopo != null) {
 109             List<Link> linkList = new ArrayList<>();
 110             if (openroadmTopo.augmentation(Network1.class) != null) {
 111                 linkList.addAll(openroadmTopo.augmentation(Network1.class).getLink().values());
 112             }
 113             List<Link> xponderOutLinkList = linkList.stream()
 114                 .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDEROUTPUT))
 115                 .collect(Collectors.toList());
 116             List<Link> xponderInLinkList = linkList.stream()
 117                 .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDERINPUT))
 118                 .collect(Collectors.toList());
 119             // read otn-topology
 120             Network otnTopo = readTopology(InstanceIdentifiers.OTN_NETWORK_II);
 121             Map<NodeId, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 122                 .ietf.network.rev180226.networks.network.Node> otnNodeMap = otnTopo.nonnullNode()
 123                 .values().stream().collect(Collectors.toMap(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 124                     .ietf.network.rev180226.networks.network.Node::getNodeId, node -> node));
 125
 126             Map<String, List<String>> networkPortMap = new HashMap<>();
 127             Iterator<Map.Entry<NodeId, org.opendaylight.yang.gen.v1.urn
 128                 .ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node>> itOtnNodeMap = otnNodeMap
 129                 .entrySet().iterator();
 130             while (itOtnNodeMap.hasNext()) {
 131                 Map.Entry<NodeId, org.opendaylight.yang.gen.v1.urn
 132                     .ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node> entry = itOtnNodeMap.next();
 133                 String portMappingNodeId = entry.getValue().getSupportingNode().values().stream()
 134                     .filter(sn -> sn.getNetworkRef().getValue().equals(NetworkUtils.UNDERLAY_NETWORK_ID))
 135                     .findFirst()
 136                     .get().getNodeRef().getValue();
 137                 List<String> networkPortList = new ArrayList<>();
 138                 for (TerminationPoint tp: entry.getValue().augmentation(Node1.class).getTerminationPoint().values()) {
 139                     // TODO -> why are we checking with respect to XPDR links?? Is there a real purpose on doing that?
 140                     if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)
 141                         && checkTp(entry.getKey().getValue(), portMappingNodeId, tp, xponderOutLinkList,
 142                         xponderInLinkList)) {
 143                         networkPortList.add(tp.getTpId().getValue());
 144                     }
 145                 }
 146                 if (!networkPortList.isEmpty()) {
 147                     networkPortMap.put(entry.getKey().getValue(), networkPortList);
 148                 }
 149             }
 150             Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
 151                 tapiNodeList = new HashMap<>();
 152             Map<LinkKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link>
 153                 tapiLinkList = new HashMap<>();
 154             ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topoUuid);
 155             Iterator<Map.Entry<String, List<String>>> it = networkPortMap.entrySet().iterator();
 156             while (it.hasNext()) {
 157                 String nodeId = it.next().getKey();
 158                 tapiFactory.convertNode(otnNodeMap.get(new NodeId(nodeId)), networkPortMap.get(nodeId));
 159                 tapiNodeList.putAll(tapiFactory.getTapiNodes());
 160                 tapiLinkList.putAll(tapiFactory.getTapiLinks());
 161             }
 162             // roadm infrastructure not abstracted
 163             // read openroadm-network
 164             Network openroadmNet = readTopology(InstanceIdentifiers.UNDERLAY_NETWORK_II);
 165             if (openroadmNet != null && openroadmNet.nonnullNode().values().stream().filter(nt ->
 166                 nt.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
 167                     .getNodeType().equals(OpenroadmNodeType.ROADM)).count() > 0) {
 168                 // map roadm nodes
 169                 for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 170                     .ietf.network.rev180226.networks.network.Node roadm:openroadmNet.nonnullNode().values().stream()
 171                     .filter(nt -> nt.augmentation(org.opendaylight.yang.gen.v1.http
 172                         .org.openroadm.common.network.rev200529.Node1.class)
 173                         .getNodeType().equals(OpenroadmNodeType.ROADM))
 174                     .collect(Collectors.toList())) {
 175                     tapiFactory.convertRoadmNode(roadm, openroadmTopo);
 176                     tapiNodeList.putAll(tapiFactory.getTapiNodes());
 177                 }
 178             } else {
 179                 LOG.warn("No roadm nodes exist in the network");
 180             }
 181             // map roadm to roadm link
 182             List<Link> rdmTordmLinkList = linkList.stream()
 183                 .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.ROADMTOROADM))
 184                 .collect(Collectors.toList());
 185             tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList);
 186             tapiLinkList.putAll(tapiFactory.getTapiLinks());
 187             // map xpdr_input to roadm and xpdr_output to roadm links.
 188             xponderInLinkList.addAll(xponderOutLinkList);
 189             tapiFactory.convertXpdrToRdmLinks(xponderInLinkList);
 190             tapiLinkList.putAll(tapiFactory.getTapiLinks());
 191
 192             if (otnTopo.augmentation(Network1.class) != null) {
 193                 Map<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks
 194                     .network.LinkKey, Link> otnLinkMap = otnTopo.augmentation(Network1.class).getLink();
 195                 tapiFactory.convertLinks(otnLinkMap);
 196                 tapiLinkList.putAll(tapiFactory.getTapiLinks());
 197             }
 198             // Retrieve created sips map in TapiFactory when mapping all the nodes
 199             this.tapiSips = tapiFactory.getTapiSips();
 200             return new TopologyBuilder()
 201                 .setName(Map.of(name.key(), name))
 202                 .setUuid(topoUuid)
 203                 .setNode(tapiNodeList)
 204                 .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.ODU,
 205                     LayerProtocolName.DSR))
 206                 .setLink(tapiLinkList).build();
 207         }
 208         return new TopologyBuilder()
 209             .setName(Map.of(name.key(), name))
 210             .setUuid(topoUuid)
 211             .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.ODU,
 212                 LayerProtocolName.DSR))
 213             .build();
 214     }
 215
 216     public Map<ServiceInterfacePointKey, ServiceInterfacePoint> getSipMap() {
 217         return tapiSips;
 218     }
 219
 220     public boolean checkTp(String nodeIdTopo, String nodeIdPortMap, TerminationPoint tp, List<Link> xpdOut,
 221                            List<Link> xpdIn) {
 222         LOG.info("Inside Checktp for node {}-{}", nodeIdTopo, nodeIdPortMap);
 223         String networkLcp;
 224         if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERCLIENT)) {
 225             networkLcp = tp.augmentation(
 226                     org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
 227                     .getAssociatedConnectionMapPort();
 228         } else {
 229             networkLcp = tp.getTpId().getValue();
 230         }
 231         LOG.info("Network LCP associated = {}", networkLcp);
 232         @NonNull
 233         KeyedInstanceIdentifier<Mapping, MappingKey> pmIID = InstanceIdentifier.create(
 234                 org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.Network.class)
 235                 .child(Nodes.class, new NodesKey(nodeIdPortMap)).child(Mapping.class, new MappingKey(networkLcp));
 236         @NonNull
 237         FluentFuture<Optional<Mapping>> mappingOpt = this.dataBroker.newReadOnlyTransaction().read(
 238                 LogicalDatastoreType.CONFIGURATION, pmIID);
 239         Mapping mapping = null;
 240         if (mappingOpt.isDone()) {
 241             try {
 242                 mapping = mappingOpt.get().get();
 243             } catch (InterruptedException | ExecutionException e) {
 244                 LOG.error("Error getting mapping for {}", networkLcp,e);
 245                 return false;
 246             }
 247         } else {
 248             LOG.error("Impossible to get mapping of associated network port {} of tp {}", networkLcp, tp.getTpId()
 249                     .getValue());
 250             return false;
 251         }
 252         LOG.info("Mapping found = {}", mapping);
 253         String networkPortDirection = mapping.getPortDirection();
 254         // long count = 0;
 255         switch (networkPortDirection) {
 256             // TODO -> remove the part of counting only if the Network LCP is part of a Link.
 257             //  We want to have all OTN nodes in the TAPI topology
 258             case "bidirectional":
 259                 return true;
 260             case "tx":
 261             case "rx":
 262                 @Nullable
 263                 String partnerLcp = mapping.getPartnerLcp();
 264                 LOG.info("PartnerLCP = {}", partnerLcp);
 265                 return true;
 266             default:
 267                 LOG.error("Invalid port direction for {}", networkLcp);
 268                 return false;
 269         }
 270     }
 271
 272     public org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.topology.details.output.Topology
 273             transformTopology(Topology topology) {
 274         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 275             .get.topology.details.output.TopologyBuilder topologyBuilder =
 276                 new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 277             .get.topology.details.output.TopologyBuilder()
 278                 .setUuid(topology.getUuid())
 279                 .setName(topology.getName())
 280                 .setLayerProtocolName(topology.getLayerProtocolName())
 281                 .setNode(topology.getNode())
 282                 .setLink(topology.getLink());
 283         if (topology.getNode() == null) {
 284             topologyBuilder.setNode(topology.getNode());
 285             return topologyBuilder.build();
 286         }
 287         // TODO -> Need to remove CEPs from NEPs. If not error from get Topology details output
 288         Map<NodeKey, Node> mapNode = new HashMap<>();
 289         for (Node node: topology.getNode().values()) {
 290             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 291             for (OwnedNodeEdgePoint onep: node.getOwnedNodeEdgePoint().values()) {
 292                 OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class);
 293                 if (onep1 == null) {
 294                     onepMap.put(onep.key(), onep);
 295                     continue;
 296                 }
 297                 OwnedNodeEdgePointBuilder newOnepBuilder = new OwnedNodeEdgePointBuilder()
 298                         .setUuid(onep.getUuid())
 299                         .setLayerProtocolName(onep.getLayerProtocolName())
 300                         .setName(onep.getName())
 301                         .setSupportedCepLayerProtocolQualifier(onep.getSupportedCepLayerProtocolQualifier())
 302                         .setAdministrativeState(onep.getAdministrativeState())
 303                         .setOperationalState(onep.getOperationalState())
 304                         .setLifecycleState(onep.getLifecycleState())
 305                         .setTerminationDirection(onep.getTerminationDirection())
 306                         .setTerminationState(onep.getTerminationState())
 307                         .setLinkPortDirection(onep.getLinkPortDirection())
 308                         .setLinkPortRole(onep.getLinkPortRole());
 309                 if (onep.getMappedServiceInterfacePoint() != null) {
 310                     newOnepBuilder.setMappedServiceInterfacePoint(onep.getMappedServiceInterfacePoint());
 311                 }
 312                 OwnedNodeEdgePoint nep = newOnepBuilder.build();
 313                 onepMap.put(nep.key(), nep);
 314             }
 315             Node newNode = new NodeBuilder(node)
 316                     .setOwnedNodeEdgePoint(onepMap)
 317                     .build();
 318             mapNode.put(newNode.key(), newNode);
 319         }
 320         topologyBuilder.setNode(mapNode);
 321         return topologyBuilder.build();
 322     }
 323 }