pce/src/main/java/org/opendaylight/transportpce/pce/gnpy/GnpyTopoImpl.java

   1 /*
   2  * Copyright © 2019 Orange, 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
   9 package org.opendaylight.transportpce.pce.gnpy;
  10
  11 import java.math.BigDecimal;
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.concurrent.ExecutionException;
  17 import java.util.stream.IntStream;
  18
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  21 import org.opendaylight.transportpce.common.NetworkUtils;
  22 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  23 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Coordinate;
  24 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Km;
  25 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.edfa.params.Operational;
  26 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.edfa.params.OperationalBuilder;
  27 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.Edfa;
  28 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.EdfaBuilder;
  29 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.FiberRoadmBuilder;
  30 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.Transceiver;
  31 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.TransceiverBuilder;
  32 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.Params;
  33 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.ParamsBuilder;
  34 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.params.fiberroadm.Fiber;
  35 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.params.fiberroadm.FiberBuilder;
  36 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.params.fiberroadm.Roadm;
  37 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.element.type.choice.element.type.fiberroadm.params.fiberroadm.RoadmBuilder;
  38 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.location.attributes.Location;
  39 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.location.attributes.LocationBuilder;
  40 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.Connections;
  41 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.ConnectionsBuilder;
  42 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.Elements;
  43 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.ElementsBuilder;
  44 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.elements.Metadata;
  45 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.topo.elements.MetadataBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.AmplifiedLink;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.amplified.link.section.element.section.element.Span;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.amplified.link.section.element.section.element.ila.Ila;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.span.attributes.LinkConcatenation;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.rev181130.Node1;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.link.OMSAttributes;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.slf4j.Logger;
  65 import org.slf4j.LoggerFactory;
  66
  67 /**
  68  * Class to create the topology corresponding to GNPy requirements.
  69  *
  70  * @author Ahmed Triki ( ahmed.triki@orange.com )
  71  *
  72  */
  73
  74 public class GnpyTopoImpl {
  75     private static final Logger LOG = LoggerFactory.getLogger(GnpyTopoImpl.class);
  76     private final NetworkTransactionService networkTransactionService;
  77     private List<Elements> elements = new ArrayList<>();
  78     private List<Connections> connections = new ArrayList<>();
  79     //Mapping elements
  80     //Mapping between the ord-topo and ord-ntw node
  81     private Map<String, String> mapDisgNodeRefNode = new HashMap<String, String>();
  82     //Mapping between the ord-ntw and node ip
  83     private Map<String, IpAddress> mapNodeRefIp = new HashMap<String, IpAddress>();
  84     //Mapping between link id and clfi
  85     private Map<String, String> mapLinkFiber = new HashMap<String, String>();
  86     //Mapping between fiber clfi and ipAddress
  87     private Map<String, IpAddress> mapFiberIp = new HashMap<String, IpAddress>();
  88     private static int convertKmM = 1000;
  89
  90     /*
  91      * Construct the ExtractTopoDataStoreImpl.
  92      */
  93     @SuppressWarnings("unchecked")
  94     public GnpyTopoImpl(final NetworkTransactionService networkTransactionService) {
  95         this.networkTransactionService = networkTransactionService;
  96         Map<String, List<?>> map = extractTopo();
  97         if (map.containsKey("Elements")) {
  98             elements = (List<Elements>) map.get("Elements");
  99         } else {
 100             elements = null;
 101         }
 102         if (map.containsKey("Connections")) {
 103             connections = (List<Connections>) map.get("Connections");
 104         } else {
 105             connections = null;
 106         }
 107     }
 108
 109     /*
 110      * extract the topology: all the elements have ipAddress as uid and maintain
 111      * a mapping structure to map between the nodeId and the ipAddress (uid)
 112      *
 113      */
 114     public Map<String, List<?>> extractTopo() {
 115         Map<String, List<?>> map = new HashMap<String, List<?>>();
 116         // Define the elements
 117         List<Elements> topoElements = new ArrayList<>();
 118         // Define the connections
 119         List<Connections> topoConnections = new ArrayList<>();
 120         // Define the instance identifier of the OpenRoadm topology
 121         InstanceIdentifier<Network> insIdOpenRoadmTopo = InstanceIdentifier
 122                 .builder(Networks.class)
 123                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
 124         // Define the instance identifier of the OpenRoadm network
 125         InstanceIdentifier<Network> insIdrOpenRoadmNet = InstanceIdentifier
 126                 .builder(Networks.class)
 127                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))).build();
 128         try {
 129             // Initialize the reading of the networkTransactionService
 130             // read the configuration part of the data broker that concerns
 131             // the openRoadm topology and get all the nodes
 132             java.util.Optional<Network> openRoadmTopo = this.networkTransactionService
 133                     .read(LogicalDatastoreType.CONFIGURATION, insIdOpenRoadmTopo).get();
 134             java.util.Optional<Network> openRoadmNet = this.networkTransactionService
 135                     .read(LogicalDatastoreType.CONFIGURATION, insIdrOpenRoadmNet).get();
 136             if (openRoadmNet.isPresent()) {
 137                 List<Node> openRoadmNetNodeList = openRoadmNet.get().getNode();
 138                 if (openRoadmTopo.isPresent()) {
 139                     List<Node> openRoadmTopoNodeList = openRoadmTopo.get().getNode();
 140                     List<String> nodesList = new ArrayList<>();
 141                     // Create the list of nodes
 142                     if (!openRoadmTopoNodeList.isEmpty()) {
 143                         // Create elements
 144                         for (Node openRoadmTopoNode : openRoadmTopoNodeList) {
 145                             // Retrieve the supporting node and the type of the
 146                             // node in openRoadm network
 147                             List<SupportingNode> supportingNodeList = openRoadmTopoNode.getSupportingNode();
 148                             for (SupportingNode supportingNode : supportingNodeList) {
 149                                 String nodeRef = supportingNode.getNodeRef().getValue();
 150                                 IpAddress ipAddress = null;
 151                                 // Retrieve the mapping between the openRoadm
 152                                 // topology and openRoadm network
 153                                 mapDisgNodeRefNode.put(openRoadmTopoNode.getNodeId().getValue(), nodeRef);
 154                                 Node1 openRoadmNetNode1 = null;
 155                                 for (Node openRoadmNetNode : openRoadmNetNodeList) {
 156                                     if (openRoadmNetNode.getNodeId().getValue().equals(nodeRef)) {
 157                                         openRoadmNetNode1 = openRoadmNetNode.augmentation(Node1.class);
 158                                         ipAddress = openRoadmNetNode1.getIp();
 159                                         mapNodeRefIp.put(nodeRef, ipAddress);
 160                                         break;
 161                                     }
 162                                 }
 163                                 if (openRoadmNetNode1.getNodeType().getName().equals("ROADM")) {
 164                                     if (!nodesList.contains(nodeRef)) {
 165                                         Elements element = addElementsRoadm(2, 0, nodeRef, openRoadmNetNode1.getShelf(),
 166                                                 -20, ipAddress.getIpv4Address().getValue().toString());
 167                                         topoElements.add(element);
 168                                         nodesList.add(nodeRef);
 169                                     }
 170                                 } else if (openRoadmNetNode1.getNodeType().getName().equals("XPONDER")) {
 171                                     if (!nodesList.contains(nodeRef)) {
 172                                         Elements element = addElementsTransceiver(2, 0, nodeRef,
 173                                                 openRoadmNetNode1.getShelf(),
 174                                                 ipAddress.getIpv4Address().getValue().toString());
 175                                         topoElements.add(element);
 176                                         nodesList.add(nodeRef);
 177                                     }
 178                                 } else {
 179                                     LOG.warn("the type is not implemented");
 180                                 }
 181                             }
 182                         }
 183                     } else {
 184                         LOG.warn("no nodes in the network");
 185                     }
 186
 187                     // Create the list of connections
 188                     Network1 nw1 = openRoadmTopo.get().augmentation(Network1.class);
 189                     List<Link> linksList = nw1.getLink();
 190                     // 1:EXPRESS-LINK    2:ADD-LINK       3:DROP-LINK
 191                     // 4:ROADM-To-ROADM  5:XPONDER-INPUT  6:XPONDER-OUTPUT
 192                     int[] externalLink = {4,5,6};
 193                     int idFiber = 0;
 194                     int nbEDFA = 0;
 195                     if (!linksList.isEmpty()) {
 196                         LOG.debug("The link list is not empty");
 197                         for (Link link : linksList) {
 198                             Link1 link1 = link.augmentation(Link1.class);
 199                             int linkType = link1.getLinkType().getIntValue();
 200                             if (IntStream.of(externalLink).anyMatch(x -> x == linkType)) {
 201                                 // Verify if the node is a ROADM
 202                                 String srcId = mapDisgNodeRefNode.get(link.getSource().getSourceNode().getValue());
 203                                 IpAddress srcIp = mapNodeRefIp.get(srcId);
 204                                 String destId = null;
 205                                 IpAddress destIp = null;
 206                                 // Add the links between amplifiers
 207                                 OMSAttributes omsAttributes = link1.getOMSAttributes();
 208                                 if (omsAttributes != null) {
 209                                     if (omsAttributes.getAmplifiedLink() != null) {
 210                                         List<AmplifiedLink> amplifiedLinkList = omsAttributes.getAmplifiedLink()
 211                                                 .getAmplifiedLink();
 212                                         if (!amplifiedLinkList.isEmpty()) {
 213                                             for (AmplifiedLink amplifiedLink : amplifiedLinkList) {
 214                                                 Elements element1 = null;
 215                                                 if (amplifiedLink.getSectionElement()
 216                                                         .getSectionElement() instanceof Ila) {
 217                                                     Ila ila = (Ila) amplifiedLink.getSectionElement()
 218                                                             .getSectionElement();
 219                                                     String nodeId = ila.getNodeId().getValue();
 220                                                     IpAddress ipEdfa = new IpAddress(
 221                                                             new Ipv4Address("1.1.1." + nbEDFA));
 222                                                     nbEDFA++;
 223                                                     mapDisgNodeRefNode.put(nodeId, nodeId);
 224                                                     mapNodeRefIp.put(nodeId, ipEdfa);
 225                                                     element1 = addElementsEdfa(2, 0, "RLD", "Lannion_CAS",
 226                                                             ila.getGain().getValue(), ila.getTilt().getValue(),
 227                                                             ila.getOutVoaAtt().getValue(), "std_medium_gain",
 228                                                             ipEdfa.getIpv4Address().getValue().toString());
 229                                                 } else if (amplifiedLink.getSectionElement()
 230                                                         .getSectionElement() instanceof Span) {
 231                                                     // Create the location
 232                                                     Span span = (Span) amplifiedLink.getSectionElement()
 233                                                             .getSectionElement();
 234                                                     String clfi = span.getSpan().getClfi();
 235                                                     IpAddress ipFiber = new IpAddress(
 236                                                             new Ipv4Address("2.2.2." + idFiber));
 237                                                     mapLinkFiber.put(link.getLinkId().getValue(), clfi);
 238                                                     mapFiberIp.put(clfi, ipFiber);
 239                                                     idFiber++;
 240                                                     element1 = addElementsFiber(2, 0, "RLD", "Lannion_CAS",
 241                                                             ipFiber.getIpv4Address().getValue(), 20, 0, 0.2, 0, 0,
 242                                                             "SSMF");
 243                                                 }
 244                                                 if (element1 != null) {
 245                                                     topoElements.add(element1);
 246                                                     destId = element1.getUid();
 247                                                     destIp = null;
 248                                                     // Create a new link
 249                                                     if (srcId != destId) {
 250                                                         Connections connection = createNewConnection(srcId, srcIp,
 251                                                                 destId, destIp);
 252                                                         topoConnections.add(connection);
 253                                                         srcId = destId;
 254                                                         srcIp = destIp;
 255                                                     }
 256                                                 }
 257                                             }
 258                                         }
 259                                     } else if (omsAttributes.getSpan() != null) {
 260                                         org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
 261                                             .networks.network.link.oms.attributes.@Nullable Span span
 262                                                 = omsAttributes.getSpan();
 263                                         String clfi = span.getClfi();
 264                                         IpAddress ipFiber = new IpAddress(new Ipv4Address("2.2.2." + idFiber));
 265                                         mapLinkFiber.put(link.getLinkId().getValue(), clfi);
 266                                         mapFiberIp.put(clfi, ipFiber);
 267                                         idFiber++;
 268                                         double attIn = 0;
 269                                         double connIn = 0;
 270                                         double connOut = 0;
 271                                         String typeVariety = "SSMF";
 272                                         double length = 0;
 273                                         // Compute the length of the link
 274                                         List<LinkConcatenation> linkConcatenationList = span.getLinkConcatenation();
 275                                         for (LinkConcatenation linkConcatenation : linkConcatenationList) {
 276                                             double srlgLength = linkConcatenation.getSRLGLength();
 277                                             //convert to kilometer
 278                                             length += srlgLength / convertKmM;
 279                                         }
 280                                         double lossCoef = span.getSpanlossCurrent().getValue().doubleValue() / length;
 281                                         Elements element1 = addElementsFiber(2, 0, "RLD", "Lannion_CAS",
 282                                                 ipFiber.getIpv4Address().getValue(), length, attIn, lossCoef, connIn,
 283                                                 connOut, typeVariety);
 284                                         topoElements.add(element1);
 285                                         // Create a new link
 286                                         destId = element1.getUid();
 287                                         destIp = null;
 288                                         if (srcId != destId) {
 289                                             Connections connection = createNewConnection(srcId, srcIp, destId, destIp);
 290                                             topoConnections.add(connection);
 291                                             srcId = destId;
 292                                             srcIp = destIp;
 293                                         }
 294                                     } else {
 295                                         // Add a fiber
 296                                         String clfi = "Fiber" + idFiber;
 297                                         IpAddress ipFiber = new IpAddress(new Ipv4Address("2.2.2." + idFiber));
 298                                         mapLinkFiber.put(link.getLinkId().getValue(), clfi);
 299                                         mapFiberIp.put(clfi, ipFiber);
 300                                         idFiber++;
 301                                         // Create a new element
 302                                         Elements element1 = addElementsFiber(2, 0, "RLD", "Lannion_CAS",
 303                                                 ipFiber.getIpv4Address().getValue(), 20, 0, 0.2, 0, 0, "SSMF");
 304                                         topoElements.add(element1);
 305                                         // Create a new link
 306                                         destId = element1.getUid();
 307                                         destIp = null;
 308                                         if (srcId != destId) {
 309                                             Connections connection = createNewConnection(srcId, srcIp, destId, destIp);
 310                                             topoConnections.add(connection);
 311                                             srcId = destId;
 312                                             srcIp = destIp;
 313                                         }
 314                                     }
 315                                 } else {
 316                                     LOG.warn("The oms attributes is null {} !",link1.getLinkType().getName());
 317                                 }
 318                                 // Create a new link
 319                                 destId = mapDisgNodeRefNode.get(link.getDestination().getDestNode().getValue());
 320                                 destIp = mapNodeRefIp.get(destId);
 321                                 Connections connection = createNewConnection(srcId, srcIp, destId, destIp);
 322                                 topoConnections.add(connection);
 323                             }
 324                         }
 325                     } else {
 326                         LOG.warn("no links in the network");
 327                     }
 328                 } else {
 329                     LOG.warn("No nodes in the selected network ...");
 330                 }
 331             }
 332         } catch (InterruptedException | ExecutionException e) {
 333             LOG.error("Error reading the topology", e);
 334             this.networkTransactionService.close();
 335         }
 336         this.networkTransactionService.close();
 337         map.put("Elements", topoElements);
 338         map.put("Connections", topoConnections);
 339         return map;
 340     }
 341
 342     /*
 343      * Method to add Fiber
 344      */
 345     private Elements addElementsFiber(double latitude, double longitude, String region, String city, String clfi,
 346             double length, double attIn, double lossCoef, double connIn, double connOut, String typeVariety) {
 347         // Create an amplifier after the roadm
 348         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 349         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 350         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 351                 .build();
 352         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 353         Fiber fiber = new FiberBuilder().setLength(new BigDecimal(length)).setLengthUnits(Km.class)
 354                 .setAttIn(new BigDecimal(attIn)).setLossCoef(new BigDecimal(lossCoef)).setConIn(new BigDecimal(connIn))
 355                 .setConOut(new BigDecimal(connOut)).build();
 356         Params params1 = new ParamsBuilder().setFiberroadm(fiber).build();
 357         Elements element1 = new ElementsBuilder().setUid(clfi)
 358                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Fiber.class)
 359                 .setTypeVariety(typeVariety).setMetadata(metadata1)
 360                 .setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 361         return element1;
 362     }
 363
 364     /*
 365      * Method to add Edfa
 366      */
 367     private Elements addElementsEdfa(double latitude, double longitude, String region, String city,
 368             BigDecimal gainTarget, BigDecimal tiltTarget, BigDecimal outVoa, String typeVariety, String uidEdfa) {
 369         // Create an amplifier after the roadm
 370         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 371         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 372         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 373                 .build();
 374         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 375         Operational operational = new OperationalBuilder().setGainTarget(gainTarget).setTiltTarget(tiltTarget)
 376                 .setOutVoa(outVoa).build();
 377         Edfa edfa = new EdfaBuilder()
 378                 .setOperational(operational).build();
 379         Elements element1 = new ElementsBuilder().setUid(uidEdfa)
 380                 // Choose an ip address
 381                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Edfa.class)
 382                 .setMetadata(metadata1).setElementType(edfa).setTypeVariety(typeVariety).build();
 383         return element1;
 384     }
 385
 386     /*
 387      * Method to add ROADM
 388      */
 389     private Elements addElementsRoadm(double latitude, double longitude, String region, String city,
 390             double targetPchOutDb, String uidRoadm) {
 391
 392         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 393         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 394         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 395                 .build();
 396         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 397         // Create the roadm
 398         Roadm roadm = new RoadmBuilder().setTargetPchOutDb(new BigDecimal(targetPchOutDb)).build();
 399         Params params1 = new ParamsBuilder().setFiberroadm(roadm).build();
 400         Elements element1 = new ElementsBuilder().setUid(uidRoadm)
 401                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Roadm.class)
 402                 .setMetadata(metadata1).setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 403         return element1;
 404     }
 405
 406     /*
 407      * Method to add Transceiver
 408      */
 409     private Elements addElementsTransceiver(double latitude, double longitude, String region, String city,
 410             String uidTrans) {
 411         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 412         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 413         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 414                 .build();
 415         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 416         Transceiver transceiver = new TransceiverBuilder().build();
 417         Elements element1 = new ElementsBuilder().setUid(uidTrans)
 418                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Transceiver.class)
 419                 .setMetadata(metadata1).setElementType(transceiver).build();
 420         return element1;
 421     }
 422
 423     private Connections createNewConnection(String srcId, IpAddress srcIp, String destId, IpAddress destIp) {
 424         String fromNode = srcId;
 425         String toNode = destId;
 426         if (srcIp != null) {
 427             fromNode = srcIp.getIpv4Address().getValue().toString();
 428         }
 429         if (destIp != null) {
 430             toNode = destIp.getIpv4Address().getValue().toString();
 431         }
 432         Connections connection1 = new ConnectionsBuilder().setFromNode(fromNode).setToNode(toNode).build();
 433         return (connection1);
 434     }
 435
 436     public List<Elements> getElements() {
 437         return elements;
 438     }
 439
 440     public void setElements(List<Elements> elements) {
 441         this.elements = elements;
 442     }
 443
 444     public List<Connections> getConnections() {
 445         return connections;
 446     }
 447
 448     public void setConnections(List<Connections> connections) {
 449         this.connections = connections;
 450     }
 451
 452     public Map<String, String> getMapDisgNodeRefNode() {
 453         return mapDisgNodeRefNode;
 454     }
 455
 456     public void setMapDisgNodeRefNode(Map<String, String> mapDisgNodeRefNode) {
 457         this.mapDisgNodeRefNode = mapDisgNodeRefNode;
 458     }
 459
 460     public Map<String, IpAddress> getMapNodeRefIp() {
 461         return mapNodeRefIp;
 462     }
 463
 464     public void setMapNodeRefIp(Map<String, IpAddress> mapNodeRefIp) {
 465         this.mapNodeRefIp = mapNodeRefIp;
 466     }
 467
 468     public Map<String, String> getMapLinkFiber() {
 469         return mapLinkFiber;
 470     }
 471
 472     public void setMapLinkFiber(Map<String, String> mapLinkFiber) {
 473         this.mapLinkFiber = mapLinkFiber;
 474     }
 475
 476     public Map<String, IpAddress> getMapFiberIp() {
 477         return mapFiberIp;
 478     }
 479
 480     public void setMapFiberIp(Map<String, IpAddress> mapFiberIp) {
 481         this.mapFiberIp = mapFiberIp;
 482     }
 483 }