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         List<Link> linkList = new ArrayList<>();
 105         if (openroadmTopo.augmentation(Network1.class) != null) {
 106             linkList.addAll(openroadmTopo.augmentation(Network1.class).getLink().values());
 107         }
 108         List<Link> xponderOutLinkList = linkList.stream()
 109             .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDEROUTPUT))
 110             .collect(Collectors.toList());
 111         List<Link> xponderInLinkList = linkList.stream()
 112             .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDERINPUT))
 113             .collect(Collectors.toList());
 114         // read otn-topology
 115         Network otnTopo = readTopology(InstanceIdentifiers.OTN_NETWORK_II);
 116         Map<NodeId, org.opendaylight.yang.gen.v1.urn
 117             .ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node> otnNodeMap = otnTopo.nonnullNode()
 118             .values().stream().collect(Collectors.toMap(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 119                 .ietf.network.rev180226.networks.network.Node::getNodeId, node -> node));
 120
 121         Map<String, List<String>> networkPortMap = new HashMap<>();
 122         Iterator<Map.Entry<NodeId, org.opendaylight.yang.gen.v1.urn
 123             .ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node>> itOtnNodeMap = otnNodeMap
 124             .entrySet().iterator();
 125         while (itOtnNodeMap.hasNext()) {
 126             Map.Entry<NodeId, org.opendaylight.yang.gen.v1.urn
 127                 .ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node> entry = itOtnNodeMap.next();
 128             String portMappingNodeId = entry.getValue().getSupportingNode().values().stream()
 129                 .filter(sn -> sn.getNetworkRef().getValue().equals(NetworkUtils.UNDERLAY_NETWORK_ID))
 130                 .findFirst()
 131                 .get().getNodeRef().getValue();
 132             List<String> networkPortList = new ArrayList<>();
 133             for (TerminationPoint tp: entry.getValue().augmentation(Node1.class).getTerminationPoint().values()) {
 134                 // TODO -> why are we checking with respect to XPDR links?? Is there a real purpose on doing that?
 135                 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)
 136                     && checkTp(entry.getKey().getValue(), portMappingNodeId, tp, xponderOutLinkList,
 137                     xponderInLinkList)) {
 138                     networkPortList.add(tp.getTpId().getValue());
 139                 }
 140             }
 141             if (!networkPortList.isEmpty()) {
 142                 networkPortMap.put(entry.getKey().getValue(), networkPortList);
 143             }
 144         }
 145         Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node>
 146             tapiNodeList = new HashMap<>();
 147         Map<LinkKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link>
 148             tapiLinkList = new HashMap<>();
 149         Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER
 150             .getBytes(Charset.forName("UTF-8"))).toString());
 151         ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topoUuid);
 152         Iterator<Map.Entry<String, List<String>>> it = networkPortMap.entrySet().iterator();
 153         while (it.hasNext()) {
 154             String nodeId = it.next().getKey();
 155             tapiFactory.convertNode(otnNodeMap.get(new NodeId(nodeId)), networkPortMap.get(nodeId));
 156             tapiNodeList.putAll(tapiFactory.getTapiNodes());
 157             tapiLinkList.putAll(tapiFactory.getTapiLinks());
 158         }
 159         // roadm infrastructure not abstracted
 160         // read openroadm-network
 161         Network openroadmNet = readTopology(InstanceIdentifiers.UNDERLAY_NETWORK_II);
 162         if (openroadmNet != null && openroadmNet.nonnullNode().values().stream().filter(nt ->
 163                 nt.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
 164                         .getNodeType().equals(OpenroadmNodeType.ROADM)).count() > 0) {
 165             // map roadm nodes
 166             for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node
 167                     roadm:openroadmNet.nonnullNode().values().stream().filter(
 168                             nt -> nt.augmentation(org.opendaylight.yang.gen.v1.http
 169                             .org.openroadm.common.network.rev200529.Node1.class)
 170                             .getNodeType().equals(OpenroadmNodeType.ROADM))
 171                     .collect(Collectors.toList())) {
 172                 tapiFactory.convertRoadmNode(roadm, openroadmTopo);
 173                 tapiNodeList.putAll(tapiFactory.getTapiNodes());
 174             }
 175         } else {
 176             LOG.warn("No roadm nodes exist in the network");
 177         }
 178         // map roadm to roadm link
 179         List<Link> rdmTordmLinkList = linkList.stream()
 180                 .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.ROADMTOROADM))
 181                 .collect(Collectors.toList());
 182         tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList);
 183         tapiLinkList.putAll(tapiFactory.getTapiLinks());
 184         // map xpdr_input to roadm and xpdr_output to roadm links.
 185         xponderInLinkList.addAll(xponderOutLinkList);
 186         tapiFactory.convertXpdrToRdmLinks(xponderInLinkList);
 187         tapiLinkList.putAll(tapiFactory.getTapiLinks());
 188
 189         if (otnTopo.augmentation(Network1.class) != null) {
 190             Map<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks
 191                     .network.LinkKey, Link> otnLinkMap = otnTopo.augmentation(Network1.class).getLink();
 192             tapiFactory.convertLinks(otnLinkMap);
 193             tapiLinkList.putAll(tapiFactory.getTapiLinks());
 194         }
 195         Name name = new NameBuilder().setValue(TopologyUtils.T0_FULL_MULTILAYER).setValueName("TAPI Topology Name")
 196                 .build();
 197         // Retrieve created sips map in TapiFactory when mapping all the nodes
 198         this.tapiSips = tapiFactory.getTapiSips();
 199         return new TopologyBuilder()
 200                 .setName(Map.of(name.key(), name))
 201                 .setUuid(topoUuid)
 202                 .setNode(tapiNodeList)
 203                 .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.ODU,
 204                         LayerProtocolName.DSR))
 205                 .setLink(tapiLinkList).build();
 206     }
 207
 208     public Map<ServiceInterfacePointKey, ServiceInterfacePoint> getSipMap() {
 209         return tapiSips;
 210     }
 211
 212     public boolean checkTp(String nodeIdTopo, String nodeIdPortMap, TerminationPoint tp, List<Link> xpdOut,
 213                            List<Link> xpdIn) {
 214         LOG.info("Inside Checktp for node {}-{}", nodeIdTopo, nodeIdPortMap);
 215         String networkLcp;
 216         if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERCLIENT)) {
 217             networkLcp = tp.augmentation(
 218                     org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
 219                     .getAssociatedConnectionMapPort();
 220         } else {
 221             networkLcp = tp.getTpId().getValue();
 222         }
 223         LOG.info("Network LCP associated = {}", networkLcp);
 224         @NonNull
 225         KeyedInstanceIdentifier<Mapping, MappingKey> pmIID = InstanceIdentifier.create(
 226                 org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.Network.class)
 227                 .child(Nodes.class, new NodesKey(nodeIdPortMap)).child(Mapping.class, new MappingKey(networkLcp));
 228         @NonNull
 229         FluentFuture<Optional<Mapping>> mappingOpt = this.dataBroker.newReadOnlyTransaction().read(
 230                 LogicalDatastoreType.CONFIGURATION, pmIID);
 231         Mapping mapping = null;
 232         if (mappingOpt.isDone()) {
 233             try {
 234                 mapping = mappingOpt.get().get();
 235             } catch (InterruptedException | ExecutionException e) {
 236                 LOG.error("Error getting mapping for {}", networkLcp,e);
 237                 return false;
 238             }
 239         } else {
 240             LOG.error("Impossible to get mapping of associated network port {} of tp {}", networkLcp, tp.getTpId()
 241                     .getValue());
 242             return false;
 243         }
 244         LOG.info("Mapping found = {}", mapping);
 245         String networkPortDirection = mapping.getPortDirection();
 246         // long count = 0;
 247         switch (networkPortDirection) {
 248             // TODO -> remove the part of counting only if the Network LCP is part of a Link.
 249             //  We want to have all OTN nodes in the TAPI topology
 250             case "bidirectional":
 251                 return true;
 252             case "tx":
 253             case "rx":
 254                 @Nullable
 255                 String partnerLcp = mapping.getPartnerLcp();
 256                 LOG.info("PartnerLCP = {}", partnerLcp);
 257                 return true;
 258             default:
 259                 LOG.error("Invalid port direction for {}", networkLcp);
 260                 return false;
 261         }
 262     }
 263
 264     public org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.topology.details.output.Topology
 265             transformTopology(Topology topology) {
 266         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 267             .get.topology.details.output.TopologyBuilder topologyBuilder =
 268                 new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
 269             .get.topology.details.output.TopologyBuilder()
 270                 .setUuid(topology.getUuid())
 271                 .setName(topology.getName())
 272                 .setLayerProtocolName(topology.getLayerProtocolName())
 273                 .setNode(topology.getNode())
 274                 .setLink(topology.getLink());
 275         if (topology.getNode() == null) {
 276             topologyBuilder.setNode(topology.getNode());
 277             return topologyBuilder.build();
 278         }
 279         // TODO -> Need to remove CEPs from NEPs. If not error from get Topology details output
 280         Map<NodeKey, Node> mapNode = new HashMap<>();
 281         for (Node node: topology.getNode().values()) {
 282             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 283             for (OwnedNodeEdgePoint onep: node.getOwnedNodeEdgePoint().values()) {
 284                 OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class);
 285                 if (onep1 == null) {
 286                     onepMap.put(onep.key(), onep);
 287                     continue;
 288                 }
 289                 OwnedNodeEdgePointBuilder newOnepBuilder = new OwnedNodeEdgePointBuilder()
 290                         .setUuid(onep.getUuid())
 291                         .setLayerProtocolName(onep.getLayerProtocolName())
 292                         .setName(onep.getName())
 293                         .setSupportedCepLayerProtocolQualifier(onep.getSupportedCepLayerProtocolQualifier())
 294                         .setAdministrativeState(onep.getAdministrativeState())
 295                         .setOperationalState(onep.getOperationalState())
 296                         .setLifecycleState(onep.getLifecycleState())
 297                         .setTerminationDirection(onep.getTerminationDirection())
 298                         .setTerminationState(onep.getTerminationState())
 299                         .setLinkPortDirection(onep.getLinkPortDirection())
 300                         .setLinkPortRole(onep.getLinkPortRole());
 301                 if (onep.getMappedServiceInterfacePoint() != null) {
 302                     newOnepBuilder.setMappedServiceInterfacePoint(onep.getMappedServiceInterfacePoint());
 303                 }
 304                 OwnedNodeEdgePoint nep = newOnepBuilder.build();
 305                 onepMap.put(nep.key(), nep);
 306             }
 307             Node newNode = new NodeBuilder(node)
 308                     .setOwnedNodeEdgePoint(onepMap)
 309                     .build();
 310             mapNode.put(newNode.key(), newNode);
 311         }
 312         topologyBuilder.setNode(mapNode);
 313         return topologyBuilder.build();
 314     }
 315
 316 }