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