olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmt.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.power;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import java.math.BigDecimal;
  14 import java.util.HashMap;
  15 import java.util.Map;
  16 import java.util.concurrent.ExecutionException;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.MountPoint;
  19 import org.opendaylight.controller.md.sal.binding.api.MountPointService;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  21 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  22 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  24 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  25 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaces;
  26 import org.opendaylight.transportpce.renderer.provisiondevice.CrossConnect;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1Builder;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.och.container.OchBuilder;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.network.topology.topology.topology.types.TopologyNetconf;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.olm.rev170418.ServicePowerSetupInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.olm.rev170418.ServicePowerTurndownInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.Network;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.Nodes;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.NodesKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.Mapping;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.MappingKey;
  50 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  51 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  52 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60
  61 public class PowerMgmt {
  62     private static final Logger LOG = LoggerFactory.getLogger(PowerMgmt.class);
  63     private final DataBroker db;
  64     private final MountPointService mps;
  65     public static final InstanceIdentifier<Topology> NETCONF_TOPO_IID =
  66             InstanceIdentifier
  67                     .create(NetworkTopology.class)
  68                     .child(Topology.class,
  69                             new TopologyKey(new TopologyId(TopologyNetconf.QNAME.getLocalName())));
  70
  71     public PowerMgmt(DataBroker db, MountPointService mps) {
  72         this.db = db;
  73         this.mps = mps;
  74     }
  75
  76     /**
  77      * This methods measures power requirement for turning up a WL
  78      * from the Spanloss at OTS transmit direction and update
  79      * roadm-connection target-output-power.
  80      *
  81      * @param input
  82      *            Input parameter from the olm servicePowerSetup rpc
  83      *
  84      * @return true/false based on status of operation.
  85      */
  86     public Boolean setPower(ServicePowerSetupInput input) {
  87         LOG.info("Olm-setPower initiated");
  88         for (int i = 0; i < input.getNodes().size(); i++) {
  89             String nodeId = input.getNodes().get(i).getNodeId();
  90             String srcTpId =  input.getNodes().get(i).getSrcTp();
  91             String destTpId = input.getNodes().get(i).getDestTp();
  92             DataBroker deviceDb = getDeviceDataBroker(nodeId , mps);
  93             Nodes inputNode = getNode(nodeId, mps, db);
  94             LOG.info("Getting data from input node {}",inputNode.getNodeType());
  95             LOG.info("Getting mapping data for node is {}",inputNode.getMapping().stream().filter(o -> o.getKey()
  96                             .equals(new MappingKey(destTpId))).findFirst().toString());
  97             // If node type is transponder
  98             if (inputNode.getNodeType() != null && inputNode.getNodeType().equals(NodeTypes.Xpdr)) {
  99                 // If its A-End transponder
 100                 if (destTpId.toLowerCase().contains("network")) {
 101                     java.util.Optional<Mapping> mappingObject = inputNode.getMapping().stream().filter(o -> o.getKey()
 102                             .equals(new MappingKey(destTpId))).findFirst();
 103                     if (mappingObject.isPresent()) {
 104                         Map<String, Double> txPowerRangeMap = getXponderPowerRange(nodeId, mappingObject.get()
 105                                 .getSupportingCircuitPackName(),
 106                                 mappingObject.get().getSupportingPort(),deviceDb);
 107                         if (!txPowerRangeMap.isEmpty()) {
 108                             LOG.info("Transponder range exists for nodeId: {}", nodeId);
 109                             String srgId =  input.getNodes().get(i + 1).getSrcTp();
 110                             String nextNodeId = input.getNodes().get(i + 1).getNodeId();
 111                             DataBroker deviceDbSRG = getDeviceDataBroker(nextNodeId , mps);
 112                             Map<String, Double> rxSRGPowerRangeMap = getSRGRxPowerRange(nextNodeId, srgId, deviceDbSRG);
 113                             Double powerValue = new Double(0);
 114                             if (!rxSRGPowerRangeMap.isEmpty()) {
 115                                 LOG.info("SRG Rx Power range exists for nodeId: {}", nodeId);
 116                                 if (txPowerRangeMap.get("MaxTx").doubleValue()
 117                                         <= rxSRGPowerRangeMap.get("MaxRx").doubleValue()) {
 118                                     powerValue = txPowerRangeMap.get("MaxTx").doubleValue();
 119                                 } else if (rxSRGPowerRangeMap.get("MaxRx").doubleValue()
 120                                         < txPowerRangeMap.get("MaxTx").doubleValue()) {
 121                                     powerValue = rxSRGPowerRangeMap.get("MaxRx").doubleValue();
 122                                 }
 123                                 LOG.info("Calculated Transponder Power value is {}" , powerValue);
 124                                 if (setTransponderPower(nodeId, destTpId, destTpId + "-" + input.getWaveNumber(),
 125                                         new BigDecimal(powerValue), deviceDb)) {
 126                                     LOG.info("Transponder OCH connection: {} power updated ",
 127                                             destTpId + "-" + input.getWaveNumber());
 128                                     try {
 129                                         LOG.info("Now going in sleep mode");
 130                                         Thread.sleep(180000);
 131                                     } catch (InterruptedException e) {
 132                                         LOG.info("Transponder warmup failed for OCH connection: {}",
 133                                               destTpId + "-" + input.getWaveNumber(), e);
 134                                     }
 135                                 } else {
 136                                     LOG.info("Transponder OCH connection: {} power update failed ",
 137                                            destTpId + "-" + input.getWaveNumber());
 138                                 }
 139                             } else {
 140                                 LOG.info("SRG Power Range not found");
 141                             }
 142                         } else {
 143                             LOG.info("Tranponder range not available seting to default "
 144                                     + "power for nodeId: {}", nodeId);
 145                             if (setTransponderPower(nodeId, destTpId, destTpId + "-" + input.getWaveNumber(),
 146                                     new BigDecimal(-5), deviceDb)) {
 147                                 LOG.info("Transponder OCH connection: {} power updated ",
 148                                         destTpId + "-" + input.getWaveNumber());
 149                                 try {
 150                                     Thread.sleep(180000);
 151                                 } catch (InterruptedException e) {
 152                                     // TODO Auto-generated catch block
 153                                     LOG.info("Transponder warmup failed for OCH connection: {}",
 154                                             destTpId + "-" + input.getWaveNumber(), e);
 155                                 }
 156                             } else {
 157                                 LOG.info("Transponder OCH connection: {} power update failed ",
 158                                          destTpId + "-" + input.getWaveNumber());
 159                             }
 160                         }
 161                     } else {
 162                         LOG.info("Mapping object not found for nodeId: {}", nodeId);
 163                         return false;
 164                     }
 165                 } else {
 166                     LOG.info("{} is a drop node. Net power settings needed", nodeId);
 167                 }
 168             } else if (inputNode.getNodeType() != null && inputNode.getNodeType().equals(NodeTypes.Rdm)) {
 169             // If Degree is transmitting end then set power
 170                 if (destTpId.toLowerCase().contains("deg")) {
 171                     java.util.Optional<Mapping> mappingObject = inputNode.getMapping().stream().filter(o -> o.getKey()
 172                             .equals(new MappingKey(destTpId))).findFirst();
 173                     Mapping portMapping = mappingObject.get();
 174                     if (portMapping != null && deviceDb != null) {
 175                         BigDecimal spanLossTx = new OpenRoadmInterfaces(db, mps, nodeId, destTpId)
 176                                 .getInterface(portMapping.getSupportingOts()).getAugmentation(Interface1.class).getOts()
 177                                 .getSpanLossTransmit().getValue();
 178                         Double powerValue = Math.min(spanLossTx.doubleValue() - 9 , 2);
 179                         CrossConnect roadmCrossConnect = new CrossConnect(deviceDb, srcTpId
 180                                + "-" + destTpId + "-" + input.getWaveNumber());
 181                         try {
 182                             Boolean setXconnPowerSuccessVal = roadmCrossConnect.setPowerLevel(OpticalControlMode.Power,
 183                                     new PowerDBm(BigDecimal.valueOf(powerValue)));
 184                             if (setXconnPowerSuccessVal) {
 185                                 LOG.info("Roadm-connection: {} updated ");
 186                                 //TODO - commented code because one vendor is not supporting
 187                                 //GainLoss with target-output-power
 188                                 Thread.sleep(20000);
 189                                 roadmCrossConnect.setPowerLevel(OpticalControlMode.GainLoss,
 190                                         new PowerDBm(BigDecimal.valueOf(powerValue)));
 191                             } else {
 192                                 LOG.info("Set Power failed for Roadm-connection: {} on Node: {}",
 193                                         srcTpId + "-" + destTpId + "-" + input.getWaveNumber(), nodeId);
 194                                 return false;
 195                             }
 196                         } catch (InterruptedException e) {
 197                             LOG.error("Olm-setPower wait failed {}",e);
 198                             return false;
 199                         }
 200                     }
 201                   // If Drop node leave node is power mode
 202                 } else if (destTpId.toLowerCase().contains("srg")) {
 203                     LOG.info("Setting power at drop node");
 204                     CrossConnect roadmDropCrossConnect = new CrossConnect(deviceDb, srcTpId + "-"
 205                             + destTpId + "-" + input.getWaveNumber());
 206                     roadmDropCrossConnect.setPowerLevel(OpticalControlMode.Power, null);
 207                 }
 208             }
 209         }
 210         return true;
 211     }
 212
 213     /**
 214      * This methods turns down power a WL by performing
 215      * following steps:
 216      *
 217      * <p>
 218      * 1. Pull interfaces used in service and change
 219      * status to outOfService
 220      *
 221      * <p>
 222      * 2. For each of the ROADM node set target-output-power
 223      * to -60dbm, wait for 20 seconds, turn power mode to off
 224      *
 225      * <p>
 226      * 3. Turn down power in Z to A direction and A to Z
 227      *
 228      * @param input
 229      *            Input parameter from the olm servicePowerTurndown rpc
 230      *
 231      * @return true/false based on status of operation
 232      */
 233     public Boolean powerTurnDown(ServicePowerTurndownInput input) {
 234         LOG.info("Olm-powerTurnDown initiated");
 235         /**Starting with last element into the list Z -> A for
 236           turning down A -> Z **/
 237         for (int i = input.getNodes().size() - 1; i >= 0; i--) {
 238             String nodeId = input.getNodes().get(i).getNodeId();
 239             String srcTpId =  input.getNodes().get(i).getSrcTp();
 240             String destTpId = input.getNodes().get(i).getDestTp();
 241             Long wlNumber = input.getWaveNumber();
 242             DataBroker deviceDb = getDeviceDataBroker(nodeId , mps);
 243             if (!setInterfaceOutOfService(nodeId, srcTpId,
 244                     srcTpId + "-" + wlNumber, deviceDb)) {
 245                 LOG.warn("Out of service status update failed for interface {} ",
 246                        srcTpId + "-" + wlNumber);
 247                 return false;
 248             }
 249             if (!setInterfaceOutOfService(nodeId, destTpId,
 250                     destTpId + "-" + wlNumber, deviceDb)) {
 251                 LOG.warn("Out of service status update failed for interface {} ",
 252                        destTpId + "-" + wlNumber);
 253                 return false;
 254             }
 255             CrossConnect roadmCrossConnect = new CrossConnect(deviceDb, srcTpId
 256                     + "-" + destTpId + "-" + wlNumber);
 257             if (destTpId.toLowerCase().contains("srg")) {
 258                 roadmCrossConnect.setPowerLevel(OpticalControlMode.Off, null);
 259             } else if (destTpId.toLowerCase().contains("deg")) {
 260                 try {
 261                     if (!roadmCrossConnect.setPowerLevel(OpticalControlMode.Power,
 262                             new PowerDBm(new BigDecimal(-60)))) {
 263                         LOG.warn("Power down failed for Roadm-connection: {}", srcTpId
 264                                 + "-" + destTpId + "-" + wlNumber);
 265                         return false;
 266                     }
 267                     Thread.sleep(20000);
 268                     if (!roadmCrossConnect.setPowerLevel(OpticalControlMode.Off,
 269                             null)) {
 270                         LOG.warn("Setting power-control mode off failed for Roadm-connection: {}",
 271                                 srcTpId + "-" + destTpId + "-" + wlNumber);
 272                         return false;
 273                     }
 274                 } catch (InterruptedException e) {
 275                     // TODO Auto-generated catch block
 276                     LOG.error("Olm-powerTurnDown wait failed {}",e);
 277                     return false;
 278                 }
 279             }
 280         }
 281         return true;
 282     }
 283
 284     /**
 285      * This method updates interface administrative state to
 286      * outOfService.
 287      *
 288      * @param nodeId
 289      *            Unique identifier for the mounted netconf- node
 290      * @param tpId
 291      *            Termination point of mounted netconf - node
 292      * @param interfaceName
 293      *            Name of interface which needs status update
 294      * @param deviceDb
 295      *            Reference to device data broker
 296      * @return true/false based on status of operation
 297      */
 298     public Boolean setInterfaceOutOfService(String nodeId, String tpId,
 299             String interfaceName, DataBroker deviceDb) {
 300         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier
 301                 .create(OrgOpenroadmDevice.class)
 302                 .child(Interface.class, new InterfaceKey(interfaceName));
 303         Interface nodeInterface = new OpenRoadmInterfaces(db, mps, nodeId, tpId)
 304                 .getInterface(interfaceName);
 305         InterfaceBuilder intfBuilder = new InterfaceBuilder(nodeInterface);
 306         intfBuilder.setAdministrativeState(AdminStates.OutOfService);
 307         final WriteTransaction writeTransaction = deviceDb.newWriteOnlyTransaction();
 308         writeTransaction.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, intfBuilder.build());
 309         final CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 310         try {
 311             submit.checkedGet();
 312             LOG.info("Successfully posted interface {}" , interfaceName);
 313             return true;
 314         } catch (TransactionCommitFailedException ex) {
 315             LOG.warn("Failed to post {} ", interfaceName ,ex);
 316             return false;
 317         }
 318     }
 319
 320     /**
 321      * This static method returns the DataBroker for a netconf node.
 322      *
 323      * @param nodeId
 324      *            Unique identifier for the mounted netconf- node
 325      * @param mps
 326      *            Reference to mount service
 327      * @return Databroker for the given device
 328      */
 329     public static DataBroker getDeviceDataBroker(String nodeId, MountPointService mps) {
 330         MountPoint netconfNode = getDeviceMountPoint(nodeId, mps);
 331         if (netconfNode != null) {
 332             DataBroker netconfNodeDataBroker = netconfNode.getService(DataBroker.class).get();
 333             return netconfNodeDataBroker;
 334         } else {
 335             LOG.info("Device Data broker not found for :" + nodeId);
 336             return null;
 337         }
 338     }
 339
 340     /**
 341      * This static method returns the Mountpoint for a netconf node.
 342      *
 343      * @param nodeId
 344      *            Unique identifier for the mounted netconf- node
 345      * @param mps
 346      *            Reference to mount service
 347      * @return MountPoint for the given device
 348      */
 349     public static MountPoint getDeviceMountPoint(String nodeId, MountPointService mps) {
 350         final Optional<MountPoint> netconfNodeOptional = mps.getMountPoint(NETCONF_TOPO_IID
 351                 .child(Node.class, new NodeKey(new NodeId(nodeId))));
 352         // Get mount point for specified device
 353         if (netconfNodeOptional.isPresent()) {
 354             MountPoint netconfNode = netconfNodeOptional.get();
 355             return netconfNode;
 356         } else {
 357             LOG.info("Mount Point not found for :" + nodeId);
 358             return null;
 359         }
 360
 361     }
 362
 363     /**
 364      * This static method returns the DataBroker for a netconf node.
 365      *
 366      * @param nodeId
 367      *            Unique identifier for the mounted netconf- node
 368      * @param mps
 369      *            Reference to mount service
 370      * @param db
 371      *            Databroker
 372      * @return Nodes from portMapping for given nodeId
 373      */
 374     public static Nodes getNode(String nodeId, MountPointService mps, DataBroker db) {
 375         InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.create(Network.class)
 376                 .child(Nodes.class, new NodesKey(nodeId));
 377         ReadOnlyTransaction readTransaction = db.newReadOnlyTransaction();
 378         Optional<Nodes> nodeObject;
 379         try {
 380             nodeObject = readTransaction.read(LogicalDatastoreType.CONFIGURATION, nodesIID).get();
 381             if (nodeObject.isPresent()) {
 382                 LOG.info("Found Node in Portmapping for nodeId {}", nodeObject.get().getNodeId());
 383                 return nodeObject.get();
 384             } else {
 385                 LOG.info("Could not find Portmapping for nodeId {}", nodeId);
 386                 return null;
 387             }
 388         } catch (InterruptedException | ExecutionException ex) {
 389             LOG.info("Unable to read Portmapping for nodeId {}", nodeId, ex);
 390         }
 391         return null;
 392     }
 393
 394     /**
 395      * This method provides Transponder transmit power range.
 396      *
 397      * @param nodeId
 398      *            Unique identifier for the mounted netconf- node
 399      * @param circuitPackName
 400      *            Transponder circuitPack name
 401      * @param portName
 402      *            Transponder port name
 403      * @param deviceDb
 404      *            Databroker for the given device
 405      * @return HashMap holding Min and Max transmit power for given port
 406      */
 407     public Map<String, Double> getXponderPowerRange(String nodeId, String circuitPackName, String portName,
 408             DataBroker deviceDb) {
 409         InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
 410                 CircuitPacks.class, new CircuitPacksKey(circuitPackName)).child(Ports.class, new PortsKey(portName));
 411         ReadOnlyTransaction readTransaction = deviceDb.newReadOnlyTransaction();
 412         Map<String, Double> powerRangeMap = new HashMap<String, Double>();
 413         try {
 414             LOG.info("Fetching logical Connection Point value for port " + portName + " at circuit pack "
 415                 + circuitPackName);
 416             Optional<Ports> portObject = readTransaction.read(LogicalDatastoreType.OPERATIONAL, portIID).get();
 417             if (portObject.isPresent()) {
 418                 Ports port = portObject.get();
 419                 if (port.getTransponderPort() != null) {
 420                     powerRangeMap.put("MaxTx", port.getTransponderPort().getPortPowerCapabilityMaxTx()
 421                             .getValue().doubleValue());
 422                     powerRangeMap.put("MinTx", port.getTransponderPort().getPortPowerCapabilityMinTx()
 423                             .getValue().doubleValue());
 424                 } else {
 425                     LOG.warn("Logical Connection Point value missing for " + circuitPackName + " " + port
 426                         .getPortName());
 427                 }
 428             }
 429         } catch (InterruptedException | ExecutionException ex) {
 430             LOG.warn("Read failed for Logical Connection Point value missing for " + circuitPackName + " "
 431                 + portName,ex);
 432             return powerRangeMap;
 433         }
 434         return powerRangeMap;
 435     }
 436
 437     /**
 438      * This method provides Transponder transmit power range.
 439      *
 440      * @param nodeId
 441      *            Unique identifier for the mounted netconf- node
 442      * @param srgId
 443      *            SRG Id connected to transponder
 444      * @param deviceDb
 445      *            Databroker for the given device
 446      * @return HashMap holding Min and Max transmit power for given port
 447      */
 448     public Map<String, Double> getSRGRxPowerRange(String nodeId, String srgId, DataBroker deviceDb) {
 449         Map<String, Double> powerRangeMap = new HashMap<String, Double>();
 450         LOG.info("Coming inside Xpdr power range");
 451         java.util.Optional<Mapping> mappingSRGObject = getNode(nodeId, mps, db).getMapping()
 452                 .stream().filter(o -> o.getKey()
 453                 .equals(new MappingKey(srgId))).findFirst();
 454         if (mappingSRGObject.isPresent()) {
 455             LOG.info("Mapping object exists.");
 456             String circuitPackName = mappingSRGObject.get().getSupportingCircuitPackName();
 457             String portName = mappingSRGObject.get().getSupportingPort();
 458             InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 459                     .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
 460                     .child(Ports.class, new PortsKey(portName));
 461             try {
 462                 LOG.info("Fetching logical Connection Point value for port " + portName + " at circuit pack "
 463                     + circuitPackName + portIID);
 464                 ReadOnlyTransaction rtx = deviceDb.newReadOnlyTransaction();
 465                 Optional<Ports> portObject = rtx.read(LogicalDatastoreType.OPERATIONAL, portIID).get();
 466                 if (portObject.isPresent()) {
 467                     Ports port = portObject.get();
 468                     if (port.getRoadmPort() != null) {
 469                         LOG.info("Port found on the node ID");
 470                         powerRangeMap.put("MinRx", port.getRoadmPort()
 471                                 .getPortPowerCapabilityMinRx().getValue().doubleValue());
 472                         powerRangeMap.put("MaxRx", port.getRoadmPort()
 473                                 .getPortPowerCapabilityMaxRx().getValue().doubleValue());
 474                         return powerRangeMap;
 475                     } else {
 476                         LOG.warn("Roadm ports power value is missing for " + circuitPackName + " " + port
 477                             .getPortName());
 478                     }
 479                 } else {
 480                     LOG.info("Port not found");
 481                 }
 482             } catch (InterruptedException | ExecutionException ex) {
 483                 LOG.warn("Read failed for Logical Connection Point value missing for " + circuitPackName + " "
 484                     + portName,ex);
 485             }
 486         } else {
 487             LOG.info("Port mapping not found for nodeId: {} and srgId: {} ",
 488                     nodeId, srgId);
 489         }
 490         return powerRangeMap;
 491
 492     }
 493
 494     /**
 495      * This method retrieves transponder OCH interface and
 496      * sets power.
 497      *
 498      * @param nodeId
 499      *            Unique identifier for the mounted netconf- node
 500      * @param tpId
 501      *            Termination port for transponder connected to SRG
 502      * @param interfaceName
 503      *            OCH interface name carrying WL
 504      * @param txPower
 505      *            Calculated transmit power
 506      * @param deviceDb
 507      *            Databroker for the given device
 508      * @return true/false based on status of operation
 509      */
 510     public boolean setTransponderPower(String nodeId, String tpId, String interfaceName, BigDecimal txPower,
 511             DataBroker deviceDb) {
 512         LOG.info("Setting target-power for transponder nodeId: {} InterfaceName: {}",
 513                 nodeId, interfaceName);
 514         InterfaceBuilder ochInterfaceBuilder = new InterfaceBuilder(
 515                 new OpenRoadmInterfaces(db, mps, nodeId, tpId)
 516                    .getInterface(interfaceName));
 517         OchBuilder ochBuilder = new OchBuilder(ochInterfaceBuilder
 518                 .getAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.optical
 519                         .channel.interfaces.rev161014.Interface1.class).getOch());
 520         ochBuilder.setTransmitPower(new PowerDBm(txPower));
 521         ochInterfaceBuilder.addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.optical
 522                 .channel.interfaces.rev161014.Interface1.class,
 523                 new Interface1Builder().setOch(ochBuilder.build()).build());
 524         ReadWriteTransaction rwtx = deviceDb.newReadWriteTransaction();
 525         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 526                 .child(Interface.class, new InterfaceKey(interfaceName));
 527         rwtx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ochInterfaceBuilder.build());
 528         CheckedFuture<Void, TransactionCommitFailedException> submit = rwtx.submit();
 529         try {
 530             submit.checkedGet();
 531             LOG.info("Power update is submitted");
 532             return true;
 533         } catch (TransactionCommitFailedException e) {
 534             LOG.info("Setting transponder power failed {}" ,e);
 535         }
 536         return false;
 537     }
 538
 539 }