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