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.regex.Pattern;
  18 import java.util.stream.IntStream;
  19
  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.common.network.rev181130.Link1;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.SpanAttributes;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.AmplifiedLink;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.amplified.link.section.element.section.element.Span;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.amplified.link.section.element.section.element.ila.Ila;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.span.attributes.LinkConcatenation;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.rev181130.Node1;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.link.OMSAttributes;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  65 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 /**
  70  * Class to create the topology corresponding to GNPy requirements.
  71  *
  72  * @author Ahmed Triki ( ahmed.triki@orange.com )
  73  *
  74  */
  75
  76 public class GnpyTopoImpl {
  77     private static final Logger LOG = LoggerFactory.getLogger(GnpyTopoImpl.class);
  78     private final NetworkTransactionService networkTransactionService;
  79     //List of elements
  80     private List<Elements> elements = new ArrayList<>();
  81     private List<Connections> connections = new ArrayList<>();
  82     //Mapping elements
  83     //Mapping between the ord-topo and ord-ntw node
  84     private Map<String, String> mapDisgNodeRefNode = new HashMap<String, String>();
  85     //Mapping between the ord-ntw and node ip
  86     private Map<String, IpAddress> mapNodeRefIp = new HashMap<String, IpAddress>();
  87     //Mapping between the ROADM-ROADM linkId/secElement and the linkId
  88     private Map<String, List<String>> mapLinkFiber = new HashMap<String, List<String>>();
  89     //Mapping between the ROADM-ROADM linkId/secElement and ipAddress
  90     private Map<String, IpAddress> mapFiberIp = new HashMap<String, IpAddress>();
  91     //List of Xponders
  92     private List<String> trxList = new ArrayList<>();
  93     //Initialize the 32 bit identifiers for the edfa and the fiber.
  94     //These 32-bit identifiers are not ipv4 addresses (despite having ipv4Adresses format, dotted-decimal notation).
  95     //They are imposed by the GNPy yang model to identify network elements and not used for any routing purposes.
  96     private Ipv4Address edfaId;
  97     private Ipv4Address fiberId;
  98     private static final double LATITUDE = 0;
  99     private static final double LONGITUTE = 0;
 100     private static final String REGION = "N/A";
 101     private static final String CITY = "N/A";
 102     private static final int CONVERT_KM_M = 1000;
 103     private static final double TARGET_PCH_OUT_DB = -20;
 104
 105     /*
 106      * Construct the ExtractTopoDataStoreImpl.
 107      */
 108     public GnpyTopoImpl(final NetworkTransactionService networkTransactionService) throws GnpyException {
 109         this.networkTransactionService = networkTransactionService;
 110         //32-bit identifier for the fiber. The dotted decimal notation has the format 243.x.x.x (0<=x<=255)
 111         fiberId = new Ipv4Address("243.0.0.1");
 112         //32-bit identifier for the edfa. The dotted decimal notation has the format 244.x.x.x (0<=x<=255)
 113         edfaId = new Ipv4Address("244.0.0.1");
 114         try {
 115             extractTopo();
 116         } catch (NullPointerException e) {
 117             throw new GnpyException("In GnpyTopoImpl: one of the elements is null",e);
 118         }
 119     }
 120
 121     /*
 122      * extract the topology: all the elements have ipAddress as uid and maintain
 123      * a mapping structure to map between the nodeId and the ipAddress (uid)
 124      *
 125      */
 126     private void extractTopo() throws GnpyException {
 127         // Define the instance identifier of the OpenRoadm topology
 128         InstanceIdentifier<Network> insIdOpenRoadmTopo = InstanceIdentifier
 129                 .builder(Networks.class)
 130                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
 131         // Define the instance identifier of the OpenRoadm network
 132         InstanceIdentifier<Network> insIdrOpenRoadmNet = InstanceIdentifier
 133                 .builder(Networks.class)
 134                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))).build();
 135         try {
 136             // Initialize the reading of the networkTransactionService
 137             // read the configuration part of the data broker that concerns the openRoadm topology and get all the nodes
 138             java.util.Optional<Network> openRoadmTopo = this.networkTransactionService
 139                     .read(LogicalDatastoreType.CONFIGURATION, insIdOpenRoadmTopo).get();
 140             java.util.Optional<Network> openRoadmNet = this.networkTransactionService
 141                     .read(LogicalDatastoreType.CONFIGURATION, insIdrOpenRoadmNet).get();
 142             if (openRoadmNet.isPresent() && openRoadmTopo.isPresent()) {
 143                 extractElements(openRoadmTopo,openRoadmNet);
 144                 extractConnections(openRoadmTopo,openRoadmNet);
 145                 LOG.debug("In GnpyTopoImpl : elements and connections are well extracted");
 146             }
 147             else {
 148                 throw new GnpyException(
 149                     "In GnpyTopoImpl : openroadm topology network or openroadm network are not well mounted ...");
 150             }
 151         } catch (InterruptedException | ExecutionException e) {
 152             this.networkTransactionService.close();
 153             throw new GnpyException("In gnpyTopoImpl: error in reading the topology", e);
 154         }
 155         this.networkTransactionService.close();
 156     }
 157
 158     private void extractElements(java.util.Optional<Network> openRoadmTopo,
 159             java.util.Optional<Network> openRoadmNet) throws GnpyException {
 160         // Create the list of nodes
 161         List<Node> openRoadmNetNodeList = openRoadmNet.get().getNode();
 162         List<Node> openRoadmTopoNodeList = openRoadmTopo.get().getNode();
 163         List<String> nodesList = new ArrayList<>();
 164
 165         if (openRoadmTopoNodeList.isEmpty() || openRoadmNetNodeList.isEmpty()) {
 166             throw new GnpyException("In gnpyTopoImpl: no nodes in the openradm topology or openroadm network");
 167         }
 168         // Create elements
 169         for (Node openRoadmTopoNode : openRoadmTopoNodeList) {
 170             // Retrieve the supporting node and the type of the node in openRoadm network
 171             List<SupportingNode> supportingNodeList = openRoadmTopoNode.getSupportingNode();
 172             for (SupportingNode supportingNode : supportingNodeList) {
 173                 IpAddress ipAddress = null;
 174                 String nodeRef = supportingNode.getNodeRef().getValue();
 175                 // Retrieve the mapping between the openRoadm topology and openRoadm network
 176                 mapDisgNodeRefNode.put(openRoadmTopoNode.getNodeId().getValue(), nodeRef);
 177                 Node1 openRoadmNetNode1 = null;
 178                 org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130
 179                     .Node1 commonNetworkNode1 = null;
 180                 for (Node openRoadmNetNode : openRoadmNetNodeList) {
 181                     if (openRoadmNetNode.getNodeId().getValue().equals(nodeRef)) {
 182                         openRoadmNetNode1 = openRoadmNetNode.augmentation(Node1.class);
 183                         commonNetworkNode1 = openRoadmNetNode.augmentation(org.opendaylight.yang.gen.v1
 184                             .http.org.openroadm.common.network.rev181130.Node1.class);
 185                         ipAddress = openRoadmNetNode1.getIp();
 186                         mapNodeRefIp.put(nodeRef, ipAddress);
 187                         break;
 188                     }
 189                 }
 190                 if (commonNetworkNode1.getNodeType().getName().equals("ROADM")) {
 191                     if (!nodesList.contains(nodeRef)) {
 192                         Elements element = createElementsRoadm(LATITUDE, LONGITUTE, nodeRef,
 193                                 openRoadmNetNode1.getShelf(),TARGET_PCH_OUT_DB, ipAddress.getIpv4Address().getValue());
 194                         this.elements.add(element);
 195                         nodesList.add(nodeRef);
 196                     }
 197                 } else if (commonNetworkNode1.getNodeType().getName().equals("XPONDER")) {
 198                     if (!nodesList.contains(nodeRef)) {
 199                         Elements element = createElementsTransceiver(LATITUDE, LONGITUTE, nodeRef,
 200                                 openRoadmNetNode1.getShelf(),ipAddress.getIpv4Address().getValue());
 201                         this.elements.add(element);
 202                         nodesList.add(nodeRef);
 203                         trxList.add(nodeRef);
 204                     }
 205                 } else {
 206                     throw new GnpyException("In gnpyTopoImpl: the type is not implemented");
 207                 }
 208             }
 209         }
 210     }
 211
 212     private void extractConnections(java.util.Optional<Network> openRoadmTopo,
 213             java.util.Optional<Network> openRoadmNet) throws GnpyException {
 214         // Create the list of connections
 215         Network1 nw1 = openRoadmTopo.get().augmentation(Network1.class);
 216         List<Link> linksList = nw1.getLink();
 217         // 1:EXPRESS-LINK    2:ADD-LINK       3:DROP-LINK
 218         // 4:ROADM-To-ROADM  5:XPONDER-INPUT  6:XPONDER-OUTPUT
 219         int[] externalLink = {OpenroadmLinkType.ROADMTOROADM.getIntValue(),OpenroadmLinkType.XPONDERINPUT.getIntValue(),
 220             OpenroadmLinkType.XPONDEROUTPUT.getIntValue()};
 221
 222         if (linksList.isEmpty()) {
 223             throw new GnpyException("In gnpyTopoImpl: no links in the network");
 224         }
 225
 226         for (Link link : linksList) {
 227             Link1 link1 = link.augmentation(Link1.class);
 228             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
 229                 .Link1 openroadmNetworkLink1 = link.augmentation(org.opendaylight.yang.gen.v1.http.org
 230                 .openroadm.network.topology.rev181130.Link1.class);
 231             int linkType = link1.getLinkType().getIntValue();
 232             if (! IntStream.of(externalLink).anyMatch(x -> x == linkType)) {
 233                 continue;
 234             }
 235
 236             String srcId = mapDisgNodeRefNode.get(link.getSource().getSourceNode().getValue());
 237             IpAddress srcIp = mapNodeRefIp.get(srcId);
 238             String linkId = link.getLinkId().getValue();
 239             String destId = null;
 240             IpAddress destIp = null;
 241             if (linkType == OpenroadmLinkType.ROADMTOROADM.getIntValue()) {
 242                 OMSAttributes omsAttributes = openroadmNetworkLink1.getOMSAttributes();
 243                 if (omsAttributes == null) {
 244                     throw new GnpyException(String.format(
 245                         "In gnpyTopoImpl: OMS attributes do not exit for ROADM to ROADM link: %s",linkId));
 246                 }
 247                 //Case of amplified link
 248                 if (omsAttributes.getAmplifiedLink() != null) {
 249                     srcIp = extractAmplifiedLink(omsAttributes, linkId, srcIp);
 250                 }
 251                 //Case of one span link
 252                 if (omsAttributes.getSpan() != null) {
 253                     srcIp = extractSpanLink(omsAttributes, linkId, srcIp);
 254                 }
 255             }
 256             // Create a new link
 257             destId = mapDisgNodeRefNode.get(link.getDestination().getDestNode().getValue());
 258             destIp = mapNodeRefIp.get(destId);
 259             createNewConnection(srcIp,destIp);
 260         }
 261     }
 262
 263     private IpAddress extractAmplifiedLink(OMSAttributes omsAttributes, String linkId, IpAddress srcIp)
 264         throws GnpyException {
 265
 266         List<AmplifiedLink> amplifiedLinkList = omsAttributes.getAmplifiedLink()
 267             .getAmplifiedLink();
 268         IpAddress destIp = null;
 269         if (!amplifiedLinkList.isEmpty()) {
 270             for (AmplifiedLink amplifiedLink : amplifiedLinkList) {
 271                 String secElt = amplifiedLink.getSectionEltNumber().toString();
 272                 //Case of ILA
 273                 if (amplifiedLink.getSectionElement().getSectionElement() instanceof Ila) {
 274                     Ila ila = (Ila) amplifiedLink.getSectionElement().getSectionElement();
 275                     destIp = extractILAFromAmpLink(ila);
 276                 }
 277                 //Case of Span
 278                 if (amplifiedLink.getSectionElement().getSectionElement() instanceof Span) {
 279                     Span span = (Span) amplifiedLink.getSectionElement().getSectionElement();
 280                     destIp = extractSpan((SpanAttributes) span.getSpan(), linkId, secElt);
 281                 }
 282                 // Create a new link
 283                 if (createNewConnection(srcIp,destIp)) {
 284                     srcIp = destIp;
 285                 }
 286             }
 287         }
 288         return srcIp;
 289     }
 290
 291     private IpAddress extractSpanLink(OMSAttributes omsAttributes, String linkId, IpAddress srcIp)
 292         throws GnpyException {
 293
 294         SpanAttributes span = omsAttributes.getSpan();
 295         IpAddress destIp = extractSpan((SpanAttributes) span, linkId, linkId);
 296         if (createNewConnection(srcIp, destIp)) {
 297             return destIp;
 298         }
 299         return srcIp;
 300     }
 301
 302     private IpAddress extractILAFromAmpLink(Ila ila) throws GnpyException {
 303         String nodeId = ila.getNodeId().getValue();
 304         IpAddress ipEdfa = new IpAddress(edfaId);
 305         edfaId = incrementIdentifier(edfaId);
 306         mapDisgNodeRefNode.put(nodeId, nodeId);
 307         mapNodeRefIp.put(nodeId, ipEdfa);
 308         Elements element = createElementsEdfa(LATITUDE, LONGITUTE, REGION, CITY,
 309                 ila.getGain().getValue(), ila.getTilt().getValue(),
 310                 ila.getOutVoaAtt().getValue(), "std_medium_gain",
 311                 ipEdfa.getIpv4Address().getValue());
 312         this.elements.add(element);
 313         return ipEdfa;
 314     }
 315
 316     private IpAddress extractSpan(SpanAttributes span, String linkId, String subLinkId) throws GnpyException {
 317         IpAddress ipFiber = new IpAddress(fiberId);
 318
 319         if (!mapLinkFiber.containsKey(linkId)) {
 320             mapLinkFiber.put(linkId, new ArrayList<String>());
 321         }
 322         mapLinkFiber.get(linkId).add(subLinkId);
 323         mapFiberIp.put(subLinkId, ipFiber);
 324         fiberId = incrementIdentifier(fiberId);
 325         double attIn = 0;
 326         double connIn = 0;
 327         double connOut = 0;
 328         String typeVariety = "SSMF";
 329         double length = 0;
 330         // Compute the length of the link
 331         List<LinkConcatenation> linkConcatenationList = span.getLinkConcatenation();
 332         for (LinkConcatenation linkConcatenation : linkConcatenationList) {
 333             double srlgLength = linkConcatenation.getSRLGLength();
 334             //convert to kilometer
 335             length += srlgLength / CONVERT_KM_M;
 336         }
 337         double lossCoef = span.getSpanlossCurrent().getValue().doubleValue() / length;
 338         Elements element = createElementsFiber(LATITUDE, LONGITUTE, REGION, CITY,
 339             ipFiber.getIpv4Address().getValue(), length, attIn, lossCoef, connIn, connOut, typeVariety);
 340         this.elements.add(element);
 341         return ipFiber;
 342
 343     }
 344
 345     /*
 346      * Method to create Fiber
 347      */
 348     private Elements createElementsFiber(double latitude, double longitude, String region, String city, String uidFiber,
 349             double length, double attIn, double lossCoef, double connIn, double connOut, String typeVariety) {
 350         // Create an amplifier after the ROADM
 351         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 352         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 353         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 354                 .build();
 355         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 356         Fiber fiber = new FiberBuilder().setLength(new BigDecimal(length)).setLengthUnits(Km.class)
 357                 .setAttIn(new BigDecimal(attIn)).setLossCoef(new BigDecimal(lossCoef)).setConIn(new BigDecimal(connIn))
 358                 .setConOut(new BigDecimal(connOut)).build();
 359         Params params1 = new ParamsBuilder().setFiberroadm(fiber).build();
 360         Elements element1 = new ElementsBuilder().setUid(uidFiber)
 361                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Fiber.class)
 362                 .setTypeVariety(typeVariety).setMetadata(metadata1)
 363                 .setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 364         return element1;
 365     }
 366
 367     /*
 368      * Method to create EDFA
 369      */
 370     private Elements createElementsEdfa(double latitude, double longitude, String region, String city,
 371             BigDecimal gainTarget, BigDecimal tiltTarget, BigDecimal outVoa, String typeVariety, String uidEdfa) {
 372         // Create an amplifier after the ROADM
 373         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 374         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 375         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 376                 .build();
 377         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 378         Operational operational = new OperationalBuilder().setGainTarget(gainTarget).setTiltTarget(tiltTarget)
 379                 .setOutVoa(outVoa).build();
 380         Edfa edfa = new EdfaBuilder()
 381                 .setOperational(operational).build();
 382         Elements element1 = new ElementsBuilder().setUid(uidEdfa)
 383                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Edfa.class)
 384                 .setMetadata(metadata1).setElementType(edfa).setTypeVariety(typeVariety).build();
 385         return element1;
 386     }
 387
 388     /*
 389      * Method to create ROADM
 390      */
 391     private Elements createElementsRoadm(double latitude, double longitude, String region, String city,
 392             double targetPchOutDb, String uidRoadm) {
 393
 394         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 395         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 396         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 397                 .build();
 398         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 399         Roadm roadm = new RoadmBuilder().setTargetPchOutDb(new BigDecimal(targetPchOutDb)).build();
 400         Params params1 = new ParamsBuilder().setFiberroadm(roadm).build();
 401         Elements element1 = new ElementsBuilder().setUid(uidRoadm)
 402                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Roadm.class)
 403                 .setMetadata(metadata1).setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 404         return element1;
 405     }
 406
 407     /*
 408      * Method to create Transceiver
 409      */
 410     private Elements createElementsTransceiver(double latitude, double longitude, String region, String city,
 411             String uidTrans) {
 412         Coordinate c1 = new Coordinate(new BigDecimal(latitude));
 413         Coordinate c2 = new Coordinate(new BigDecimal(longitude));
 414         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 415                 .build();
 416         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 417         Transceiver transceiver = new TransceiverBuilder().build();
 418         Elements element1 = new ElementsBuilder().setUid(uidTrans)
 419                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev181214.Transceiver.class)
 420                 .setMetadata(metadata1).setElementType(transceiver).build();
 421         return element1;
 422     }
 423
 424     /*
 425      * Method to create Connection
 426      */
 427     private boolean createNewConnection(IpAddress srcIp, IpAddress destIp) throws GnpyException {
 428         if (srcIp == null || destIp == null) {
 429             throw new GnpyException("create new connection : null node IpAddress");
 430         }
 431         String fromNode = srcIp.getIpv4Address().getValue();
 432         String toNode = destIp.getIpv4Address().getValue();
 433         if (fromNode == toNode) {
 434             return false;
 435         }
 436         Connections connection = new ConnectionsBuilder().setFromNode(fromNode).setToNode(toNode).build();
 437         this.connections.add(connection);
 438         return true;
 439     }
 440
 441     /*
 442      * Increment 32-bit identifier
 443      */
 444     private Ipv4Address incrementIdentifier(Ipv4Address id)  throws GnpyException {
 445         String ips = id.getValue();
 446         String [] fields = ips.split(Pattern.quote("."));
 447         int intF1 = Integer.parseInt(fields[1]);
 448         int intF2 = Integer.parseInt(fields[2]);
 449         int intF3 = Integer.parseInt(fields[3]);
 450         if (intF3 < 255) {
 451             intF3++;
 452         } else {
 453             if (intF2 < 255) {
 454                 intF2++;
 455                 intF3 = 0;
 456             } else {
 457                 if (intF1 < 255) {
 458                     intF1++;
 459                     intF2 = 0;
 460                     intF3 = 0;
 461                 } else {
 462                     throw new GnpyException("GnpyTopoImpl : the topology is not supported by gnpy");
 463                 }
 464                 fields[1] = Integer.toString(intF1);
 465             }
 466             fields[2] = Integer.toString(intF2);
 467         }
 468         fields[3] = Integer.toString(intF3);
 469         String nidString = fields[0] + "." + fields[1] + "." + fields[2] + "." + fields[3];
 470         Ipv4Address nid = new Ipv4Address(nidString);
 471         return nid;
 472     }
 473
 474     public List<Elements> getElements() {
 475         return elements;
 476     }
 477
 478     public void setElements(List<Elements> elements) {
 479         this.elements = elements;
 480     }
 481
 482     public List<Connections> getConnections() {
 483         return connections;
 484     }
 485
 486     public void setConnections(List<Connections> connections) {
 487         this.connections = connections;
 488     }
 489
 490     public Map<String, String> getMapDisgNodeRefNode() {
 491         return mapDisgNodeRefNode;
 492     }
 493
 494     public void setMapDisgNodeRefNode(Map<String, String> mapDisgNodeRefNode) {
 495         this.mapDisgNodeRefNode = mapDisgNodeRefNode;
 496     }
 497
 498     public Map<String, IpAddress> getMapNodeRefIp() {
 499         return mapNodeRefIp;
 500     }
 501
 502     public void setMapNodeRefIp(Map<String, IpAddress> mapNodeRefIp) {
 503         this.mapNodeRefIp = mapNodeRefIp;
 504     }
 505
 506     public Map<String, List<String>> getMapLinkFiber() {
 507         return mapLinkFiber;
 508     }
 509
 510     public void setMapLinkFiber(Map<String, List<String>> mapLinkFiber) {
 511         this.mapLinkFiber = mapLinkFiber;
 512     }
 513
 514     public Map<String, IpAddress> getMapFiberIp() {
 515         return mapFiberIp;
 516     }
 517
 518     public void setMapFiberIp(Map<String, IpAddress> mapFiberIp) {
 519         this.mapFiberIp = mapFiberIp;
 520     }
 521
 522     public List<String> getTrxList() {
 523         return trxList;
 524     }
 525
 526     public void setTrxList(List<String> trxList) {
 527         this.trxList = trxList;
 528     }
 529 }