olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java

   1 /*
   2  * Copyright © 2017 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.olm.service;
  10
  11 import com.google.common.base.Strings;
  12 import com.google.common.util.concurrent.ListenableFuture;
  13 import java.math.BigDecimal;
  14 import java.math.RoundingMode;
  15 import java.util.ArrayList;
  16 import java.util.Collections;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Map.Entry;
  21 import java.util.Optional;
  22 import java.util.Set;
  23 import java.util.concurrent.ExecutionException;
  24 import java.util.concurrent.Future;
  25 import java.util.concurrent.TimeUnit;
  26 import java.util.concurrent.TimeoutException;
  27 import java.util.stream.Collectors;
  28 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  29 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  31 import org.opendaylight.transportpce.common.InstanceIdentifiers;
  32 import org.opendaylight.transportpce.common.NetworkUtils;
  33 import org.opendaylight.transportpce.common.Timeouts;
  34 import org.opendaylight.transportpce.common.device.DeviceTransaction;
  35 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  36 import org.opendaylight.transportpce.common.mapping.PortMapping;
  37 import org.opendaylight.transportpce.olm.power.PowerMgmt;
  38 import org.opendaylight.transportpce.olm.util.OlmUtils;
  39 import org.opendaylight.transportpce.olm.util.OtsPmHolder;
  40 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput;
  41 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutput;
  42 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutputBuilder;
  43 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput;
  44 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutput;
  45 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutputBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
  47 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInputBuilder;
  48 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput;
  49 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder;
  50 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput;
  51 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetOutput;
  52 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput;
  53 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutput;
  54 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutputBuilder;
  55 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput;
  56 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput;
  57 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder;
  58 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.calculate.spanloss.base.output.Spans;
  59 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.calculate.spanloss.base.output.SpansBuilder;
  60 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements;
  61 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.RatioDB;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1Builder;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.Ots;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder;
  73 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
  74 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
  75 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.get.pm.input.ResourceIdentifierBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  78 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  79 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  82 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
  83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
  85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  87 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  88 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  89 import org.slf4j.Logger;
  90 import org.slf4j.LoggerFactory;
  91
  92 public class  OlmPowerServiceImpl implements OlmPowerService {
  93     private static final Logger LOG = LoggerFactory.getLogger(OlmPowerServiceImpl.class);
  94     private static final String SUCCESS = "Success";
  95     private static final String FAILED = "Failed";
  96     private final DataBroker dataBroker;
  97     private final PowerMgmt powerMgmt;
  98     private final DeviceTransactionManager deviceTransactionManager;
  99     private final PortMapping portMapping;
 100
 101     public OlmPowerServiceImpl(DataBroker dataBroker, PowerMgmt powerMgmt,
 102             DeviceTransactionManager deviceTransactionManager, PortMapping portMapping) {
 103         this.dataBroker = dataBroker;
 104         this.powerMgmt = powerMgmt;
 105         this.portMapping = portMapping;
 106         this.deviceTransactionManager = deviceTransactionManager;
 107     }
 108
 109     public void init() {
 110         LOG.info("init ...");
 111     }
 112
 113     public void close() {
 114         LOG.info("close ...");
 115     }
 116
 117
 118     @Override
 119     public GetPmOutput getPm(GetPmInput pmInput) {
 120         GetPmOutputBuilder pmOutputBuilder = OlmUtils.pmFetch(pmInput, this.deviceTransactionManager);
 121         return pmOutputBuilder.build();
 122     }
 123
 124     @Override
 125     public ServicePowerSetupOutput servicePowerSetup(ServicePowerSetupInput powerSetupInput) {
 126         ServicePowerSetupOutputBuilder powerSetupOutput = new ServicePowerSetupOutputBuilder();
 127         boolean successValPowerCalculation = this.powerMgmt.setPower(powerSetupInput);
 128
 129         if (successValPowerCalculation) {
 130             powerSetupOutput.setResult(SUCCESS);
 131         } else {
 132             powerSetupOutput.setResult(FAILED);
 133         }
 134         return powerSetupOutput.build();
 135     }
 136
 137     @Override
 138     public ServicePowerTurndownOutput servicePowerTurndown(
 139             ServicePowerTurndownInput powerTurndownInput) {
 140
 141         ServicePowerTurndownOutputBuilder powerTurnDownOutput = new ServicePowerTurndownOutputBuilder();
 142         // TODO add flag or return failure instead of string
 143         if (this.powerMgmt.powerTurnDown(powerTurndownInput)) {
 144             powerTurnDownOutput.setResult(SUCCESS);
 145         } else {
 146             powerTurnDownOutput.setResult(FAILED);
 147         }
 148         return powerTurnDownOutput.build();
 149     }
 150
 151     @Override
 152     public CalculateSpanlossBaseOutput calculateSpanlossBase(CalculateSpanlossBaseInput spanlossBaseInput) {
 153
 154         LOG.info("CalculateSpanlossBase Request received for source type {}", spanlossBaseInput.getSrcType());
 155         List<Link> networkLinks = getNetworkLinks();
 156         if (networkLinks.isEmpty()) {
 157             LOG.warn("Failed to get links form {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
 158             return new CalculateSpanlossBaseOutputBuilder().setResult(FAILED).build();
 159         }
 160
 161         if (! CalculateSpanlossBaseInput.SrcType.All.equals(spanlossBaseInput.getSrcType())) {
 162             networkLinks = networkLinks.stream()
 163                     .filter(link -> link.getLinkId().equals(spanlossBaseInput.getLinkId()))
 164                     .collect(Collectors.toList());
 165         }
 166
 167         List<Link> roadmLinks = new ArrayList<>();
 168         for (Link link : networkLinks) {
 169             Link1 roadmLinkAugmentation = link.augmentation(Link1.class);
 170             if (roadmLinkAugmentation == null) {
 171                 LOG.debug("Missing OpenRoadm link augmentation in link {} from {} topology.",
 172                         link.getLinkId().getValue(), NetworkUtils.OVERLAY_NETWORK_ID);
 173                 continue;
 174             }
 175             if (OpenroadmLinkType.ROADMTOROADM.equals(roadmLinkAugmentation.getLinkType())) {
 176                 // Only calculate spanloss for Roadm-to-Roadm links
 177                 roadmLinks.add(link);
 178             }
 179         }
 180
 181         if (roadmLinks.isEmpty()) {
 182             LOG.warn("Topology {} does not have any Roadm-to-Roadm links.", NetworkUtils.OVERLAY_NETWORK_ID);
 183             return new CalculateSpanlossBaseOutputBuilder().setResult(FAILED).build();
 184         }
 185
 186         Map<LinkId, BigDecimal> spanLossResult = getLinkSpanloss(roadmLinks);
 187         CalculateSpanlossBaseOutputBuilder spanLossBaseBuilder = new CalculateSpanlossBaseOutputBuilder();
 188
 189         if (spanLossResult != null && !spanLossResult.isEmpty()) {
 190             spanLossBaseBuilder.setResult(SUCCESS);
 191             List<Spans> listSpans = new ArrayList<>();
 192             Set<Entry<LinkId, BigDecimal>> spanLossResultSet = spanLossResult.entrySet();
 193             for (Entry<LinkId, BigDecimal> entry : spanLossResultSet) {
 194                 Spans span = new SpansBuilder().setLinkId(entry.getKey()).setSpanloss(entry.getValue().toString())
 195                     .build();
 196                 listSpans.add(span);
 197             }
 198             spanLossBaseBuilder.setSpans(listSpans);
 199             return spanLossBaseBuilder.build();
 200         } else {
 201             LOG.warn("Spanloss calculation failed");
 202             spanLossBaseBuilder.setResult(FAILED);
 203             return spanLossBaseBuilder.build();
 204         }
 205
 206     }
 207
 208     @Override
 209     public CalculateSpanlossCurrentOutput calculateSpanlossCurrent(CalculateSpanlossCurrentInput input) {
 210         LOG.info("calculateSpanlossCurrent Request received for all links in network model.");
 211         List<Link> networkLinks = getNetworkLinks();
 212         if (networkLinks.isEmpty()) {
 213             LOG.warn("Failed to get links form {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
 214             return null;
 215         }
 216         List<Link> roadmLinks = new ArrayList<>();
 217         for (Link link : networkLinks) {
 218             Link1 roadmLinkAugmentation = link.augmentation(Link1.class);
 219             if (roadmLinkAugmentation == null) {
 220                 LOG.debug("Missing OpenRoadm link augmentation in link {} from {} topology.",
 221                         link.getLinkId().getValue(), NetworkUtils.OVERLAY_NETWORK_ID);
 222                 continue;
 223             }
 224             if (OpenroadmLinkType.ROADMTOROADM.equals(roadmLinkAugmentation.getLinkType())) {
 225                 // Only calculate spanloss for Roadm-to-Roadm links
 226                 roadmLinks.add(link);
 227             }
 228         }
 229
 230         if (roadmLinks.isEmpty()) {
 231             LOG.warn("Topology {} does not have any Roadm-to-Roadm links.", NetworkUtils.OVERLAY_NETWORK_ID);
 232             return null;
 233         }
 234
 235         Map<LinkId, BigDecimal> spanLossResult = getLinkSpanloss(roadmLinks);
 236         CalculateSpanlossCurrentOutputBuilder spanLossCurrentBuilder = new CalculateSpanlossCurrentOutputBuilder();
 237         if (spanLossResult != null && !spanLossResult.isEmpty()) {
 238             spanLossCurrentBuilder.setResult(SUCCESS);
 239             return spanLossCurrentBuilder.build();
 240         } else {
 241             LOG.error("Spanloss Current calculation failed");
 242             spanLossCurrentBuilder.setResult(FAILED);
 243             return spanLossCurrentBuilder.build();
 244         }
 245     }
 246
 247     @Override
 248     public ServicePowerResetOutput servicePowerReset(ServicePowerResetInput input) {
 249         // TODO
 250         return null;
 251     }
 252
 253     private List<Link> getNetworkLinks() {
 254         NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID));
 255
 256         InstanceIdentifier<Network1> networkIID = InstanceIdentifier.builder(Networks.class)
 257             .child(Network.class, overlayTopologyKey)
 258                 .augmentation(Network1.class)
 259                 .build();
 260         Optional<Network1> networkOptional;
 261         try (ReadOnlyTransaction rtx = this.dataBroker.newReadOnlyTransaction()) {
 262             //TODO change to constant from Timeouts class when it will be merged.
 263             networkOptional = rtx.read(LogicalDatastoreType.CONFIGURATION, networkIID).get(Timeouts.DATASTORE_READ,
 264                     TimeUnit.MILLISECONDS).toJavaUtil();
 265         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 266             LOG.warn("Read of {} topology failed", NetworkUtils.OVERLAY_NETWORK_ID);
 267             return Collections.emptyList();
 268         }
 269
 270         if (! networkOptional.isPresent()) {
 271             LOG.warn("Network augmentation with links data is not present in {} topology.",
 272                     NetworkUtils.OVERLAY_NETWORK_ID);
 273             return Collections.emptyList();
 274         }
 275
 276         List<Link> networkLinks = networkOptional.get().getLink();
 277         if ((networkLinks == null) || networkLinks.isEmpty()) {
 278             LOG.warn("Links are not present in {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
 279             return Collections.emptyList();
 280         }
 281         return networkLinks;
 282     }
 283
 284     /**
 285      * This method retrieves OTS PM from current PM list by nodeId and TPId: Steps:
 286      *
 287      * <p>
 288      * 1. Get OTS interface name from port mapping by TPId 2. Call getPm RPC to get OTS PM
 289      *
 290      * <p>
 291      *
 292      * @param nodeId Node-id of the NE.
 293      * @param tpID Termination point Name.
 294      * @param pmName PM name which need to be retrieved
 295      * @return reference to OtsPmHolder
 296      */
 297     private OtsPmHolder getPmMeasurements(String nodeId, String tpID, String pmName) {
 298         String realNodeId = getRealNodeId(nodeId);
 299         Mapping mapping = this.portMapping.getMapping(realNodeId, tpID);
 300         if (mapping == null) {
 301             return null;
 302         }
 303         GetPmInput getPmInput = new GetPmInputBuilder().setNodeId(realNodeId)
 304                 .setResourceType(ResourceTypeEnum.Interface).setGranularity(PmGranularity._15min)
 305                 .setResourceIdentifier(
 306                         new ResourceIdentifierBuilder().setResourceName(mapping.getSupportingOts()).build())
 307                 .build();
 308         GetPmOutput otsPmOutput = getPm(getPmInput);
 309
 310         if (otsPmOutput == null) {
 311             LOG.info("OTS PM not found for NodeId: {} TP Id:{} PMName:{}", realNodeId, tpID, pmName);
 312             return null;
 313         }
 314         try {
 315             for (Measurements measurement : otsPmOutput.getMeasurements()) {
 316                 if (pmName.equals(measurement.getPmparameterName())) {
 317                     return new OtsPmHolder(pmName, Double.parseDouble(measurement.getPmparameterValue()),
 318                             mapping.getSupportingOts());
 319                 }
 320             }
 321         } catch (NumberFormatException e) {
 322             LOG.warn("Unable to get PM for NodeId: {} TP Id:{} PMName:{}", realNodeId, tpID, pmName, e);
 323         }
 324         return null;
 325     }
 326
 327     /**
 328      * This method Sets Spanloss on A-End and Z-End OTS interface: Steps:
 329      *
 330      * <p>
 331      * 1. Read existing interface details
 332      *
 333      * <p>
 334      * 2. Set spanloss
 335      *
 336      * @param nodeId nodeId of NE on which spanloss need to be updated
 337      * @param interfaceName OTS interface for NE on which spanloss is cacluated
 338      * @param spanLoss calculated spanloss value
 339      * @param direction for which spanloss is calculated.It can be either Tx or Rx
 340      * @return true/false
 341      */
 342     private boolean setSpanLoss(String nodeId, String interfaceName, BigDecimal spanLoss, String direction) {
 343         String realNodeId = getRealNodeId(nodeId);
 344         LOG.info("Setting Spanloss in device for {}, InterfaceName: {}", realNodeId, interfaceName);
 345         switch (direction) {
 346             case "TX":
 347                 LOG.info("Setting 'span-loss-transmit' in device:  {}, Interface: {}", realNodeId, interfaceName);
 348                 break;
 349             case "RX":
 350                 LOG.info("Setting 'span-loss-receive' in device:  {}, Interface: {}", realNodeId, interfaceName);
 351                 break;
 352             default:
 353                 LOG.error("Impossible to set spanloss in device:  {}, Interface: {}", realNodeId, interfaceName);
 354                 break;
 355         }
 356         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 357                 .child(Interface.class, new InterfaceKey(interfaceName));
 358         com.google.common.base.Optional<Interface> interfaceObject;
 359         try {
 360             Future<Optional<DeviceTransaction>> deviceTxFuture =
 361                     this.deviceTransactionManager.getDeviceTransaction(realNodeId);
 362             java.util.Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
 363             DeviceTransaction deviceTx;
 364             if (deviceTxOpt.isPresent()) {
 365                 deviceTx = deviceTxOpt.get();
 366             } else {
 367                 LOG.error("Device transaction for device {} was not found!", nodeId);
 368                 return false;
 369             }
 370             interfaceObject = deviceTx.read(LogicalDatastoreType.CONFIGURATION, interfacesIID).get();
 371             BigDecimal initialSpanloss = new BigDecimal(0);
 372             RatioDB spanLossRx = new RatioDB(initialSpanloss);
 373             RatioDB spanLossTx = new RatioDB(initialSpanloss);
 374             if (interfaceObject.isPresent()) {
 375                 Interface intf = interfaceObject.get();
 376                 InterfaceBuilder interfaceBuilder = new InterfaceBuilder(intf);
 377                 OtsBuilder otsBuilder = new OtsBuilder();
 378                 if ((intf.augmentation(Interface1.class) != null)
 379                     && (intf.augmentation(Interface1.class).getOts() != null)) {
 380                     Ots ots = intf.augmentation(Interface1.class).getOts();
 381                     otsBuilder.setFiberType(ots.getFiberType());
 382                     spanLossRx = ots.getSpanLossReceive();
 383                     spanLossTx = ots.getSpanLossTransmit();
 384                 } else {
 385                     spanLossRx = new RatioDB(spanLoss);
 386                     spanLossTx = new RatioDB(spanLoss);
 387                 }
 388                 Interface1Builder intf1Builder = new Interface1Builder();
 389                 if (direction.equals("TX")) {
 390                     otsBuilder.setSpanLossTransmit(new RatioDB(spanLoss));
 391                     otsBuilder.setSpanLossReceive(spanLossRx);
 392                 } else {
 393                     otsBuilder.setSpanLossTransmit(spanLossTx).setSpanLossReceive(new RatioDB(spanLoss));
 394                 }
 395                 interfaceBuilder.addAugmentation(Interface1.class, intf1Builder.setOts(otsBuilder.build()).build());
 396                 deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, interfaceBuilder.build());
 397                 ListenableFuture<Void> submit =
 398                         deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
 399                 submit.get();
 400                 LOG.info("Spanloss Value update completed successfully");
 401                 return true;
 402             }
 403         } catch (InterruptedException | ExecutionException e) {
 404             LOG.warn("Unable to set spanloss", e);
 405         }
 406         return false;
 407     }
 408
 409     /**
 410      * This method calculates Spanloss by TranmistPower - Receive Power Steps:
 411      *
 412      * <p>
 413      * 1. Read PM measurement
 414      *
 415      * <p>
 416      * 2. Set Spanloss value for interface
 417      *
 418      * @param roadmLinks
 419      *            reference to list of RoadmLinks
 420      * @return map with list of spans with their spanloss value
 421      */
 422     private Map<LinkId, BigDecimal> getLinkSpanloss(List<Link> roadmLinks) {
 423         Map<LinkId, BigDecimal> map = new HashMap<LinkId, BigDecimal>();
 424         LOG.info("Executing GetLinkSpanLoss");
 425         BigDecimal spanLoss = new BigDecimal(0);
 426         for (Link link : roadmLinks) {
 427             String sourceNodeId = link.getSource().getSourceNode().getValue();
 428             String sourceTpId = link.getSource().getSourceTp().toString();
 429             String destNodeId = link.getDestination().getDestNode().getValue();
 430             String destTpId = link.getDestination().getDestTp().toString();
 431             OtsPmHolder srcOtsPmHoler = getPmMeasurements(sourceNodeId, sourceTpId, "OpticalPowerOutput");
 432             OtsPmHolder destOtsPmHoler = getPmMeasurements(destNodeId, destTpId, "OpticalPowerInput");
 433             spanLoss = new BigDecimal(srcOtsPmHoler.getOtsParameterVal() - destOtsPmHoler.getOtsParameterVal())
 434                 .setScale(0, RoundingMode.HALF_UP);
 435             LOG.info("Spanloss Calculated as :" + spanLoss + "=" + srcOtsPmHoler.getOtsParameterVal() + "-"
 436                 + destOtsPmHoler.getOtsParameterVal());
 437             if ((spanLoss.doubleValue() < 28) && (spanLoss.doubleValue() > 0)) {
 438                 if (!setSpanLoss(sourceNodeId, srcOtsPmHoler.getOtsInterfaceName(), spanLoss, "TX")) {
 439                     LOG.info("Setting spanLoss failed for " + sourceNodeId);
 440                     return null;
 441                 }
 442                 if (!setSpanLoss(destNodeId, destOtsPmHoler.getOtsInterfaceName(), spanLoss, "RX")) {
 443                     LOG.info("Setting spanLoss failed for " + destNodeId);
 444                     return null;
 445                 }
 446                 map.put(link.getLinkId(), spanLoss);
 447             }
 448         }
 449         return map;
 450     }
 451
 452     private String getRealNodeId(String mappedNodeId) {
 453         KeyedInstanceIdentifier<Node, NodeKey> mappedNodeII =
 454                 InstanceIdentifiers.OVERLAY_NETWORK_II.child(Node.class, new NodeKey(new NodeId(mappedNodeId)));
 455         com.google.common.base.Optional<Node> realNode;
 456         try (ReadOnlyTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction()) {
 457             realNode = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, mappedNodeII).get();
 458         } catch (InterruptedException | ExecutionException e) {
 459             LOG.error(e.getMessage(), e);
 460             throw new IllegalStateException(e);
 461         }
 462         if (!realNode.isPresent() || (realNode.get().getSupportingNode() == null)) {
 463             throw new IllegalArgumentException(
 464                     String.format("Could not find node %s, or supporting node is not present", mappedNodeId));
 465         }
 466         List<SupportingNode> collect = realNode.get().getSupportingNode().stream()
 467                 .filter(node -> (node.getNetworkRef() != null)
 468                         && NetworkUtils.UNDERLAY_NETWORK_ID.equals(node.getNetworkRef().getValue())
 469                         && (node.getNodeRef() != null) && !Strings.isNullOrEmpty(node.getNodeRef().getValue()))
 470                 .collect(Collectors.toList());
 471         if (collect.isEmpty() || (collect.size() > 1)) {
 472             throw new IllegalArgumentException(String.format("Invalid support node count [%d] was found for node %s",
 473                     collect.size(), mappedNodeId));
 474         }
 475         return collect.iterator().next().getNodeRef().getValue();
 476     }
 477
 478 }