networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java

   1 /*
   2  * Copyright © 2016 AT&T 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
   9 package org.opendaylight.transportpce.networkmodel.util;
  10
  11 import static org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes.Tpdr;
  12
  13 import java.util.ArrayList;
  14 import java.util.Comparator;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19 import java.util.concurrent.ExecutionException;
  20 import java.util.concurrent.TimeUnit;
  21 import java.util.concurrent.TimeoutException;
  22 import java.util.stream.Collectors;
  23 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  24 import org.opendaylight.transportpce.common.NetworkUtils;
  25 import org.opendaylight.transportpce.common.fixedflex.GridUtils;
  26 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  27 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.Mapping;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.Nodes;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1Builder;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.Node1;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.Node1Builder;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.DegreeAttributes;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.DegreeAttributesBuilder;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.SrgAttributes;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.SrgAttributesBuilder;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmTpType;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkKey;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.link.DestinationBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.link.SourceBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
  65 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  66 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  67 import org.opendaylight.yangtools.yang.common.Uint16;
  68 import org.slf4j.Logger;
  69 import org.slf4j.LoggerFactory;
  70
  71 public final class OpenRoadmTopology {
  72
  73     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmTopology.class);
  74
  75     private static Map<String, OpenroadmTpType> PORTQUAL_ORD_TYPE_MAP = Map.of(
  76         "xpdr-network", OpenroadmTpType.XPONDERNETWORK,
  77         "switch-network", OpenroadmTpType.XPONDERNETWORK,
  78         "xpdr-client", OpenroadmTpType.XPONDERCLIENT
  79     );
  80     private static Map<String, List<OpenroadmTpType>> PORTDIR_ORD_TYPE_MAP = Map.of(
  81         "bidirectional", List.of(OpenroadmTpType.DEGREETXRXTTP, OpenroadmTpType.SRGTXRXPP),
  82         "tx", List.of(OpenroadmTpType.DEGREETXTTP, OpenroadmTpType.SRGTXPP),
  83         "rx", List.of(OpenroadmTpType.DEGREERXTTP, OpenroadmTpType.SRGRXPP)
  84     );
  85
  86     private OpenRoadmTopology() {
  87     }
  88
  89     public static TopologyShard createTopologyShard(Nodes mappingNode) {
  90         return createTopologyShard(mappingNode, true);
  91     }
  92
  93     public static TopologyShard createTopologyShard(Nodes mappingNode, boolean firstMount) {
  94         switch (mappingNode.getNodeInfo().getNodeType()) {
  95             case Rdm :
  96                 return createRdmTopologyShard(mappingNode, firstMount);
  97             case Xpdr :
  98                 return createXpdrTopologyShard(mappingNode);
  99             default :
 100                 LOG.error("Device node Type not managed yet");
 101                 return null;
 102         }
 103     }
 104
 105     public static TopologyShard createRdmTopologyShard(Nodes mappingNode, boolean firstMount) {
 106         List<Node> nodes = new ArrayList<>();
 107         LOG.info("creating rdm node in openroadmtopology for node {}",
 108                 mappingNode.getNodeId());
 109         // transform flat mapping list to per degree and per srg mapping lists
 110         Map<String, List<Mapping>> mapDeg = new HashMap<>();
 111         Map<String, List<Mapping>> mapSrg = new HashMap<>();
 112         List<Mapping> mappingList = new ArrayList<>(mappingNode.nonnullMapping().values());
 113         mappingList.sort(Comparator.comparing(Mapping::getLogicalConnectionPoint));
 114         List<String> nodeShardList = new ArrayList<>();
 115         for (Mapping mapping : mappingList) {
 116             String str = mapping.getLogicalConnectionPoint().split("-")[0];
 117             if (!nodeShardList.contains(str)) {
 118                 nodeShardList.add(str);
 119             }
 120         }
 121         for (String str : nodeShardList) {
 122             List<Mapping> interList =
 123                     mappingList.stream()
 124                             .filter(x -> x.getLogicalConnectionPoint().split("-")[0].equals(str))
 125                             .collect(Collectors.toList());
 126             if (str.contains("DEG")) {
 127                 mapDeg.put(str, interList);
 128             } else if (str.contains("SRG")) {
 129                 mapSrg.put(str, interList);
 130             } else {
 131                 LOG.error("unknow element");
 132             }
 133         }
 134         // create degree nodes
 135         for (Map.Entry<String, List<Mapping>> entry : mapDeg.entrySet()) {
 136             nodes.add(
 137                 createDegree(entry.getKey(), entry.getValue(), mappingNode.getNodeId(),
 138                         mappingNode.getNodeInfo().getNodeClli(), firstMount)
 139                     .build());
 140         }
 141         // create srg nodes
 142         for (Map.Entry<String, List<Mapping>> entry : mapSrg.entrySet()) {
 143             nodes.add(
 144                 createSrg(entry.getKey(), entry.getValue(), mappingNode.getNodeId(),
 145                         mappingNode.getNodeInfo().getNodeClli(), firstMount)
 146                     .build());
 147         }
 148         LOG.info("adding links numOfDegrees={} numOfSrgs={}", mapDeg.size(), mapSrg.size());
 149         List<Link> links = createNewLinks(nodes);
 150         LOG.info("created nodes/links: {}/{}", nodes.size(), links.size());
 151         return new TopologyShard(nodes, links);
 152     }
 153
 154     public static TopologyShard createXpdrTopologyShard(Nodes mappingNode) {
 155         List<Node> nodes = new ArrayList<>();
 156         List<Mapping> networkMappings =
 157                 mappingNode.nonnullMapping().values()
 158                         .stream().filter(k -> k.getLogicalConnectionPoint().contains("NETWORK"))
 159                         .collect(Collectors.toList());
 160         List<Integer> tpdrList = new ArrayList<>();
 161         for (Mapping mapping : networkMappings) {
 162             Integer xpdrNb = Integer.parseInt(mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]);
 163             if (!tpdrList.contains(xpdrNb)) {
 164                 tpdrList.add(xpdrNb);
 165                 List<Mapping> extractedMappings = mappingNode.nonnullMapping().values()
 166                         .stream().filter(lcp -> lcp.getLogicalConnectionPoint().contains("XPDR" + xpdrNb))
 167                         .collect(Collectors.toList());
 168                 Boolean isOtn;
 169                 String xpdrType;
 170                 switch (mapping.getXponderType() == null ? Tpdr : mapping.getXponderType()) {
 171                     case Tpdr :
 172                         isOtn = false;
 173                         xpdrType = "Tpdr";
 174                         break;
 175                     case Mpdr :
 176                     case Switch :
 177                         isOtn = true;
 178                         xpdrType = mapping.getXponderType().getName();
 179                         break;
 180                     default :
 181                         LOG.warn("cannot create xpdr node {} in openroadm-topology: type {} not supported",
 182                              mappingNode.getNodeId() + "-XPDR" + xpdrNb, mapping.getXponderType().getName());
 183                         continue;
 184                 }
 185                 LOG.info("creating xpdr node {} of type {} in openroadm-topology",
 186                         mappingNode.getNodeId() + "-XPDR" + xpdrNb, xpdrType);
 187                 nodes.add(createXpdr(
 188                                 mappingNode.getNodeId(),
 189                                 mappingNode.getNodeInfo().getNodeClli(),
 190                                 xpdrNb,
 191                                 extractedMappings,
 192                                 isOtn)
 193                           .build());
 194             }
 195         }
 196         return nodes.isEmpty() ? null : new TopologyShard(nodes, new ArrayList<Link>());
 197     }
 198
 199     private static NodeBuilder createXpdr(String nodeId, String clli, Integer xpdrNb, List<Mapping> mappings,
 200                                           boolean isOtn) {
 201         // Create ietf node setting supporting-node data
 202         String nodeIdtopo = new StringBuilder().append(nodeId).append("-XPDR").append(xpdrNb).toString();
 203         NodeBuilder ietfNodeBldr = createTopoLayerNode(nodeId, clli)
 204                 .setNodeId(new NodeId(nodeIdtopo))
 205                 .withKey((new NodeKey(new NodeId(nodeIdtopo))))
 206                 .addAugmentation(
 207                     // Create openroadm-network-topo augmentation to set node type to Xponder
 208                     new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 209                         .setNodeType(OpenroadmNodeType.XPONDER)
 210                         .setAdministrativeState(AdminStates.InService)
 211                         .setOperationalState(State.InService)
 212                         .build());
 213         // Create tp-map
 214         Map<TerminationPointKey, TerminationPoint> tpMap = new HashMap<>();
 215         for (Mapping m : mappings) {
 216             if (!PORTQUAL_ORD_TYPE_MAP.containsKey(m.getPortQual())) {
 217                 continue;
 218             }
 219             if (isOtn && m.getPortQual().equals("xpdr-client")) {
 220                 continue;
 221             }
 222             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.TerminationPoint1Builder
 223                     ocnTp1Bldr = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 224                     .TerminationPoint1Builder()
 225                     .setTpType(PORTQUAL_ORD_TYPE_MAP.get(m.getPortQual()))
 226                     .setAdministrativeState(TopologyUtils.setNetworkAdminState(m.getPortAdminState()))
 227                     .setOperationalState(TopologyUtils.setNetworkOperState(m.getPortOperState()));
 228             if (!isOtn && m.getConnectionMapLcp() != null) {
 229                 ocnTp1Bldr.setAssociatedConnectionMapTp(Set.of(new TpId(m.getConnectionMapLcp())));
 230             }
 231             TerminationPointBuilder ietfTpBldr = createTpBldr(m.getLogicalConnectionPoint())
 232                 .addAugmentation(
 233                     // Add openroadm-network-topology tp augmentations
 234                         ocnTp1Bldr.build());
 235             TerminationPoint ietfTp = ietfTpBldr.build();
 236             tpMap.put(ietfTp.key(),ietfTp);
 237         }
 238         // Create ietf node augmentation to support ietf tp-list
 239         return ietfNodeBldr.addAugmentation(
 240             new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder()
 241                     .setTerminationPoint(tpMap)
 242                     .build());
 243     }
 244
 245     private static NodeBuilder createDegree(String degNb, List<Mapping> degListMap, String nodeId, String clli,
 246                                             boolean firstMount) {
 247         // Create tp-list
 248         Map<TerminationPointKey,TerminationPoint> tpMap = new HashMap<>();
 249         for (Mapping m : degListMap) {
 250             // Add openroadm-common-network tp type augmentations
 251             // Added states to degree port. TODO: add to mapping relation between abstracted and physical node states
 252             if (!PORTDIR_ORD_TYPE_MAP.containsKey(m.getPortDirection())) {
 253                 LOG.error("impossible to set tp-type to {}", m.getLogicalConnectionPoint());
 254             }
 255             TerminationPoint ietfTp =  createTpBldr(m.getLogicalConnectionPoint())
 256                 .addAugmentation(
 257                     new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 258                             .TerminationPoint1Builder()
 259                         .setTpType(PORTDIR_ORD_TYPE_MAP.get(m.getPortDirection()).get(0))
 260                         .setAdministrativeState(TopologyUtils.setNetworkAdminState(m.getPortAdminState()))
 261                         .setOperationalState(TopologyUtils.setNetworkOperState(m.getPortOperState()))
 262                         .build())
 263                 .build();
 264             tpMap.put(ietfTp.key(),ietfTp);
 265         }
 266         // Add CTP to tp-list + added states. TODO: same comment as before with the relation between states
 267         TerminationPoint ietfTp = createTpBldr(degNb + "-CTP-TXRX")
 268                 .addAugmentation(new org.opendaylight.yang.gen.v1.http
 269                     .org.openroadm.common.network.rev211210.TerminationPoint1Builder()
 270                          .setTpType(OpenroadmTpType.DEGREETXRXCTP)
 271                          .setAdministrativeState(AdminStates.InService)
 272                          .setOperationalState(State.InService)
 273                          .build())
 274                  .build();
 275         tpMap.put(ietfTp.key(),ietfTp);
 276         // set degree-attributes
 277         DegreeAttributesBuilder degAttBldr = new DegreeAttributesBuilder()
 278                 .setDegreeNumber(Uint16.valueOf(degNb.split("DEG")[1]));
 279         if (firstMount) {
 280             degAttBldr.setAvailFreqMaps(GridUtils.initFreqMaps4FixedGrid2Available());
 281         }
 282         DegreeAttributes degAtt = degAttBldr.build();
 283         // set node-id
 284         String nodeIdtopo = new StringBuilder().append(nodeId).append("-").append(degNb).toString();
 285         // Create ietf node setting supporting-node data
 286         return createTopoLayerNode(nodeId, clli)
 287                 .setNodeId(new NodeId(nodeIdtopo))
 288                 .withKey((new NodeKey(new NodeId(nodeIdtopo))))
 289                 .addAugmentation(new Node1Builder().setDegreeAttributes(degAtt).build())
 290                 .addAugmentation(
 291                     new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 292                             .Node1Builder()
 293                         .setNodeType(OpenroadmNodeType.DEGREE)
 294                         .setAdministrativeState(AdminStates.InService)
 295                         .setOperationalState(State.InService)
 296                         .build())
 297                 .addAugmentation(
 298                     new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 299                             .Node1Builder()
 300                         .setTerminationPoint(tpMap)
 301                         .build());
 302     }
 303
 304     private static NodeBuilder createSrg(String srgNb, List<Mapping> srgListMap, String nodeId, String clli,
 305                                          boolean firstMount) {
 306         // Create tp-list
 307         Map<TerminationPointKey,TerminationPoint> tpMap = new HashMap<>();
 308         for (Mapping m : srgListMap) {
 309             // Added states to srg port. TODO: add to mapping relation between abstracted and physical node states
 310             if (!PORTDIR_ORD_TYPE_MAP.containsKey(m.getPortDirection())) {
 311                 LOG.error("impossible to set tp-type to {}", m.getLogicalConnectionPoint());
 312             }
 313             TerminationPoint ietfTp = createTpBldr(m.getLogicalConnectionPoint())
 314                 .addAugmentation(
 315                     // Add openroadm-common-network tp type augmentations
 316                     new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 317                             .TerminationPoint1Builder()
 318                         .setTpType(PORTDIR_ORD_TYPE_MAP.get(m.getPortDirection()).get(1))
 319                         .setAdministrativeState(TopologyUtils.setNetworkAdminState(m.getPortAdminState()))
 320                         .setOperationalState(TopologyUtils.setNetworkOperState(m.getPortOperState()))
 321                         .build())
 322                 .build();
 323             tpMap.put(ietfTp.key(),ietfTp);
 324         }
 325         // Add CP to tp-list + added states. TODO: same comment as before with the relation between states
 326         TerminationPoint ietfTp = createTpBldr(srgNb + "-CP-TXRX")
 327             .addAugmentation(
 328                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 329                         .TerminationPoint1Builder()
 330                     .setTpType(OpenroadmTpType.SRGTXRXCP)
 331                     .setAdministrativeState(AdminStates.InService)
 332                     .setOperationalState(State.InService)
 333                     .build())
 334             .build();
 335         tpMap.put(ietfTp.key(),ietfTp);
 336         // set srg-attributes
 337         SrgAttributesBuilder srgAttrBldr = new SrgAttributesBuilder();
 338         if (firstMount) {
 339             srgAttrBldr.setAvailFreqMaps(GridUtils.initFreqMaps4FixedGrid2Available());
 340         }
 341         SrgAttributes srgAttr = srgAttrBldr.build();
 342         // Create ietf node augmentation to support ietf tp-list
 343         // Create ietf node setting supporting-node data
 344         String nodeIdtopo = new StringBuilder().append(nodeId).append("-").append(srgNb).toString();
 345         return createTopoLayerNode(nodeId, clli)
 346             .setNodeId(new NodeId(nodeIdtopo))
 347             .withKey((new NodeKey(new NodeId(nodeIdtopo))))
 348             .addAugmentation(new Node1Builder().setSrgAttributes(srgAttr).build())
 349             .addAugmentation(
 350                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 351                         .Node1Builder()
 352                     .setNodeType(OpenroadmNodeType.SRG)
 353                     .setAdministrativeState(AdminStates.InService)
 354                     .setOperationalState(State.InService)
 355                     .build())
 356             .addAugmentation(
 357                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 358                        .Node1Builder()
 359                     .setTerminationPoint(tpMap)
 360                     .build());
 361     }
 362
 363     private static NodeBuilder createTopoLayerNode(String nodeId, String clli) {
 364         // Sets the value of Network-ref and Node-ref as a part of the supporting node
 365         // attribute
 366         SupportingNode support1 = new SupportingNodeBuilder()
 367                 .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID), new NodeId(nodeId)))
 368                 .setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))
 369                 .setNodeRef(new NodeId(nodeId))
 370                 .build();
 371         SupportingNode support2 = new SupportingNodeBuilder()
 372                 .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID), new NodeId(clli)))
 373                 .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID))
 374                 .setNodeRef(new NodeId(clli))
 375                 .build();
 376         Map<SupportingNodeKey, SupportingNode> supportlist = new HashMap<>();
 377         supportlist.put(support1.key(), support1);
 378         supportlist.put(support2.key(), support2);
 379         return new NodeBuilder().setSupportingNode(supportlist);
 380     }
 381
 382
 383     // This method returns a generic termination point builder for a given tpid
 384     private static TerminationPointBuilder createTpBldr(String tpId) {
 385         TpId tp = new TpId(tpId);
 386         return new TerminationPointBuilder().withKey(new TerminationPointKey(tp)).setTpId(tp);
 387     }
 388
 389     private static LinkBuilder createLink(String srcNode, String destNode, String srcTp, String destTp) {
 390         LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, destNode, destTp);
 391         return new LinkBuilder()
 392                 .setSource(
 393                     new SourceBuilder()
 394                         .setSourceNode(new NodeId(srcNode))
 395                         .setSourceTp(new TpId(srcTp))
 396                         .build())
 397                 .setDestination(
 398                     new DestinationBuilder()
 399                         .setDestNode(new NodeId(destNode))
 400                         .setDestTp(new TpId(destTp))
 401                         .build())
 402                 .setLinkId(linkId)
 403                 .withKey(new LinkKey(linkId));
 404     }
 405
 406     private static List<Link> createNewLinks(List<Node> nodes) {
 407         List<Link> links = new ArrayList<>();
 408         String srcNode;
 409         String destNode;
 410         String srcTp;
 411         String destTp;
 412         for (int i = 0; i < nodes.size() - 1; i++) {
 413             for (int j = i + 1; j < nodes.size(); j++) {
 414                 srcNode = nodes.get(i).getNodeId().getValue();
 415                 destNode = nodes.get(j).getNodeId().getValue();
 416                 // A to Z direction
 417                 srcTp = nodes.get(i)
 418                         .augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 419                                 .ietf.network.topology.rev180226.Node1.class)
 420                         .nonnullTerminationPoint().values().stream()
 421                         .filter(tp -> tp.getTpId().getValue().contains("CP") || tp.getTpId().getValue().contains("CTP"))
 422                         .findFirst().get().getTpId().getValue();
 423                 destTp = nodes.get(j)
 424                         .augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 425                                 .ietf.network.topology.rev180226.Node1.class)
 426                         .nonnullTerminationPoint().values().stream()
 427                         .filter(tp -> tp.getTpId().getValue().contains("CP") || tp.getTpId().getValue().contains("CTP"))
 428                         .findFirst().get().getTpId().getValue();
 429                 Link1Builder ocnAzLinkBldr = new Link1Builder();
 430                 Link1Builder ocnZaLinkBldr = new Link1Builder();
 431                 int srcNodeType = nodes.get(i).augmentation(org.opendaylight.yang.gen.v1.http
 432                         .org.openroadm.common.network.rev211210.Node1.class).getNodeType().getIntValue();
 433                 int destNodeType = nodes.get(j).augmentation(org.opendaylight.yang.gen.v1.http
 434                         .org.openroadm.common.network.rev211210.Node1.class).getNodeType().getIntValue();
 435
 436                 if (srcNodeType == 11 && destNodeType == 11) {
 437                     ocnAzLinkBldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
 438                     ocnZaLinkBldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
 439                 } else if (srcNodeType == 11 && destNodeType == 12) {
 440                     ocnAzLinkBldr.setLinkType(OpenroadmLinkType.DROPLINK);
 441                     ocnZaLinkBldr.setLinkType(OpenroadmLinkType.ADDLINK);
 442                 } else if (srcNodeType == 12 && destNodeType == 11) {
 443                     ocnAzLinkBldr.setLinkType(OpenroadmLinkType.ADDLINK);
 444                     ocnZaLinkBldr.setLinkType(OpenroadmLinkType.DROPLINK);
 445                 } else {
 446                     continue;
 447                 }
 448
 449                 // Add state to link. Based on the operational state of the TPs at the edge of the link.
 450                 // Similar to getting srcTp and destTp
 451                 State srcTpState = nodes.get(i)
 452                         .augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 453                             .ietf.network.topology.rev180226.Node1.class)
 454                         .getTerminationPoint().values().stream()
 455                         .filter(tp -> tp.getTpId().getValue().contains("CP") || tp.getTpId().getValue().contains("CTP"))
 456                         .findFirst().get()
 457                         .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 458                             .TerminationPoint1.class)
 459                         .getOperationalState();
 460                 State destTpState = nodes.get(j)
 461                         .augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
 462                             .ietf.network.topology.rev180226.Node1.class)
 463                         .getTerminationPoint().values().stream()
 464                         .filter(tp -> tp.getTpId().getValue().contains("CP") || tp.getTpId().getValue().contains("CTP"))
 465                         .findFirst().get()
 466                         .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 467                             .TerminationPoint1.class)
 468                         .getOperationalState();
 469                 if (State.InService.equals(srcTpState) && State.InService.equals(destTpState)) {
 470                     ocnAzLinkBldr.setAdministrativeState(AdminStates.InService)
 471                             .setOperationalState(State.InService);
 472                     ocnZaLinkBldr.setAdministrativeState(AdminStates.InService)
 473                             .setOperationalState(State.InService);
 474                 } else {
 475                     ocnAzLinkBldr.setAdministrativeState(AdminStates.OutOfService)
 476                             .setOperationalState(State.OutOfService);
 477                     ocnZaLinkBldr.setAdministrativeState(AdminStates.OutOfService)
 478                             .setOperationalState(State.OutOfService);
 479                 }
 480                 // set opposite link augmentations
 481                 LinkBuilder ietfAzLinkBldr = createLink(srcNode, destNode, srcTp, destTp);
 482                 LinkBuilder ietfZaLinkBldr = createLink(destNode, srcNode, destTp, srcTp);
 483                 ocnAzLinkBldr.setOppositeLink(ietfZaLinkBldr.getLinkId());
 484                 ietfAzLinkBldr.addAugmentation(ocnAzLinkBldr.build());
 485                 ocnZaLinkBldr.setOppositeLink(ietfAzLinkBldr.getLinkId());
 486                 ietfZaLinkBldr.addAugmentation(ocnZaLinkBldr.build());
 487                 links.add(ietfAzLinkBldr.build());
 488                 links.add(ietfZaLinkBldr.build());
 489             }
 490         }
 491         return links;
 492     }
 493
 494     // This method returns the linkBuilder object for given source and destination
 495     public static boolean deleteLink(String srcNode, String dstNode, String srcTp, String destTp,
 496                                      NetworkTransactionService networkTransactionService) {
 497         LOG.info("deleting link for {}-{}", srcNode, dstNode);
 498         LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp);
 499         if (deleteLinkLinkId(linkId, networkTransactionService)) {
 500             LOG.debug("Link Id {} updated to have admin state down", linkId);
 501             return true;
 502         } else {
 503             LOG.debug("Link Id not found for Source {} and Dest {}", srcNode, dstNode);
 504             return false;
 505         }
 506     }
 507
 508     // This method returns the linkBuilder object for given source and destination
 509     public static boolean deleteLinkLinkId(LinkId linkId , NetworkTransactionService networkTransactionService) {
 510         LOG.info("deleting link for LinkId: {}", linkId.getValue());
 511         try {
 512             InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier.builder(Networks.class)
 513                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 514                 .augmentation(Network1.class)
 515                 .child(Link.class, new LinkKey(linkId));
 516             java.util.Optional<Link> link =
 517                     networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,linkIID.build()).get();
 518             if (link.isEmpty()) {
 519                 LOG.error("No link found for given LinkId: {}", linkId);
 520                 return false;
 521             }
 522             LinkBuilder linkBuilder = new LinkBuilder(link.get());
 523             networkTransactionService.merge(
 524                 LogicalDatastoreType.CONFIGURATION,
 525                 linkIID.build(),
 526                 linkBuilder
 527                     .removeAugmentation(Link1.class)
 528                     .addAugmentation(
 529                         new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210
 530                             .Link1Builder(linkBuilder
 531                                 .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210
 532                                     .Link1.class))
 533                                 .build())
 534                     .build());
 535             networkTransactionService.commit().get(1, TimeUnit.SECONDS);
 536             return true;
 537
 538         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 539             LOG.error("Error deleting link {}", linkId.getValue(), e);
 540             return false;
 541         }
 542     }
 543
 544     /**
 545      * Get a builder for instance identifier related to common network termination point.
 546      * @param nodeId String
 547      * @param tpId String
 548      * @return InstanceIdentifierBuilder
 549      */
 550     public static InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 551             .TerminationPoint1> createCommonNetworkTerminationPointIIDBuilder(String nodeId, String tpId) {
 552         return InstanceIdentifier.builder(Networks.class)
 553                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 554                 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
 555                         .networks.network.Node.class,
 556                     new NodeKey(new NodeId(nodeId)))
 557                 .augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 558                     .Node1.class)
 559                 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 560                         .networks.network.node.TerminationPoint.class,
 561                     new TerminationPointKey(new TpId(tpId)))
 562                 .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 563                         .TerminationPoint1.class);
 564     }
 565
 566     /**
 567      * Get an instance identifier related to network node.
 568      * @param nodeId String
 569      * @return InstanceIdentifier
 570      */
 571     public static InstanceIdentifier<Node1> createNetworkNodeIID(String nodeId) {
 572         return InstanceIdentifier.builder(Networks.class)
 573                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 574                 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
 575                         .networks.network.Node.class,
 576                      new NodeKey(new NodeId(nodeId)))
 577                 .augmentation(Node1.class).build();
 578     }
 579
 580     /**
 581      * Get an instance identifier related to common network node.
 582      * @param nodeId String
 583      * @return InstanceIdentifier
 584      */
 585     public static InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 586             .Node1> createCommonNetworkNodeIID(String nodeId) {
 587         return InstanceIdentifier.builder(Networks.class)
 588                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 589                 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
 590                         .networks.network.Node.class,
 591                     new NodeKey(new NodeId(nodeId)))
 592                 .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1.class)
 593                 .build();
 594     }
 595 }