olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtImpl.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 import java.math.BigDecimal;
  11 import java.math.MathContext;
  12 import java.math.RoundingMode;
  13 import java.util.HashMap;
  14 import java.util.Locale;
  15 import java.util.Map;
  16 import java.util.Optional;
  17 import org.opendaylight.mdsal.binding.api.DataBroker;
  18 import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
  19 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  20 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  21 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  22 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  23 import org.opendaylight.transportpce.olm.util.OlmUtils;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.ServicePowerSetupInput;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.ServicePowerTurndownInput;
  26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.OpenroadmNodeVersion;
  27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.Mapping;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.MappingKey;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.Nodes;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 public class PowerMgmtImpl implements PowerMgmt {
  37     private static final Logger LOG = LoggerFactory.getLogger(PowerMgmtImpl.class);
  38     private final DataBroker db;
  39     private final OpenRoadmInterfaces openRoadmInterfaces;
  40     private final CrossConnect crossConnect;
  41     private final DeviceTransactionManager deviceTransactionManager;
  42     private static final BigDecimal DEFAULT_TPDR_PWR_100G = new BigDecimal(-5);
  43     private static final BigDecimal DEFAULT_TPDR_PWR_400G = new BigDecimal(0);
  44     private static final String INTERFACE_NOT_PRESENT = "Interface {} on node {} is not present!";
  45     private static final double MC_WIDTH_GRAN = 2 * GridConstant.GRANULARITY;
  46
  47     private long timer1 = 120000;
  48     // openroadm spec value is 120000, functest value is 3000
  49     private long timer2 = 20000;
  50     // openroadm spec value is 20000, functest value is 2000
  51
  52     public PowerMgmtImpl(DataBroker db, OpenRoadmInterfaces openRoadmInterfaces,
  53                          CrossConnect crossConnect, DeviceTransactionManager deviceTransactionManager) {
  54         this.db = db;
  55         this.openRoadmInterfaces = openRoadmInterfaces;
  56         this.crossConnect = crossConnect;
  57         this.deviceTransactionManager = deviceTransactionManager;
  58     }
  59
  60     public PowerMgmtImpl(DataBroker db, OpenRoadmInterfaces openRoadmInterfaces,
  61                          CrossConnect crossConnect, DeviceTransactionManager deviceTransactionManager,
  62                          String timer1, String timer2) {
  63         this.db = db;
  64         this.openRoadmInterfaces = openRoadmInterfaces;
  65         this.crossConnect = crossConnect;
  66         this.deviceTransactionManager = deviceTransactionManager;
  67         try {
  68             this.timer1 = Long.parseLong(timer1);
  69         } catch (NumberFormatException e) {
  70             this.timer1 = 120000;
  71             LOG.warn("Failed to retrieve Olm timer1 value from configuration - using default value {}",
  72                 this.timer1, e);
  73         }
  74         try {
  75             this.timer2 = Long.parseLong(timer2);
  76         } catch (NumberFormatException e) {
  77             this.timer2 = 20000;
  78             LOG.warn("Failed to retrieve Olm timer2 value from configuration - using default value {}",
  79                 this.timer2, e);
  80         }
  81     }
  82
  83     /**
  84      * This methods measures power requirement for turning up a WL
  85      * from the Spanloss at OTS transmit direction and update
  86      * roadm-connection target-output-power.
  87      *
  88      * @param input
  89      *            Input parameter from the olm servicePowerSetup rpc
  90      *
  91      * @return true/false based on status of operation.
  92      */
  93     //TODO Need to Case Optical Power mode/NodeType in case of 2.2 devices
  94     public Boolean setPower(ServicePowerSetupInput input) {
  95         LOG.info("Olm-setPower initiated for input {}", input);
  96         String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
  97                 input.getLowerSpectralSlotNumber().toString(),
  98                 input.getHigherSpectralSlotNumber().toString());
  99         for (int i = 0; i < input.getNodes().size(); i++) {
 100             String nodeId = input.getNodes().get(i).getNodeId();
 101             String destTpId = input.getNodes().get(i).getDestTp();
 102             Optional<Nodes> inputNodeOptional = OlmUtils.getNode(nodeId, this.db);
 103             if (inputNodeOptional.isEmpty()
 104                     || inputNodeOptional.get().getNodeInfo().getNodeType() == null) {
 105                 LOG.error("OLM-PowerMgmtImpl : Error node type cannot be retrieved for node {}", nodeId);
 106                 continue;
 107             }
 108             Nodes inputNode = inputNodeOptional.get();
 109             OpenroadmNodeVersion openroadmVersion = inputNode.getNodeInfo().getOpenroadmVersion();
 110
 111             switch (inputNode.getNodeInfo().getNodeType()) {
 112                 case Xpdr:
 113                     if (destTpId == null) {
 114                         continue;
 115                     }
 116                     LOG.info("Getting data from input node {}", inputNode.getNodeInfo().getNodeType());
 117                     LOG.info("Getting mapping data for node is {}",
 118                         inputNode.nonnullMapping().values().stream().filter(o -> o.key()
 119                          .equals(new MappingKey(destTpId))).findFirst().toString());
 120                     // If its not A-End transponder
 121                     if (!destTpId.toUpperCase(Locale.getDefault()).contains("NETWORK")) {
 122                         LOG.info("{} is a drop node. Net power settings needed", nodeId);
 123                         continue;
 124                     }
 125
 126                     BigDecimal powerVal = getXpdrPowerValue(
 127                             inputNode, destTpId, nodeId, openroadmVersion.getIntValue(),
 128                             input.getNodes().get(i + 1).getSrcTp(), input.getNodes().get(i + 1).getNodeId());
 129                     if (powerVal == null) {
 130                         return false;
 131                     }
 132
 133                     String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
 134                         destTpId, spectralSlotName);
 135                     if (!callSetTransponderPower(nodeId, interfaceName, powerVal, openroadmVersion)) {
 136                         LOG.info("Transponder OCH connection: {} power update failed ", interfaceName);
 137                         continue;
 138                     }
 139                     LOG.info("Transponder OCH connection: {} power updated ", interfaceName);
 140                     try {
 141                         LOG.info("Now going in sleep mode");
 142                         Thread.sleep(timer1);
 143                     } catch (InterruptedException e) {
 144                         LOG.info("Transponder warmup failed for OCH connection: {}", interfaceName, e);
 145                         // FIXME shouldn't it be LOG.warn  or LOG.error?
 146                         // or maybe this try/catch block can simply be removed
 147                     }
 148                     break;
 149                 case Rdm:
 150                     LOG.info("This is a roadm {} device", openroadmVersion.getName());
 151                     String connectionNumber = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
 152                             input.getNodes().get(i).getSrcTp(), destTpId, spectralSlotName);
 153                     LOG.info("Connection number is {}", connectionNumber);
 154
 155                     // If Drop node leave node is power mode
 156                     if (destTpId.toUpperCase(Locale.getDefault()).contains("SRG")) {
 157                         LOG.info("Setting power at drop node");
 158                         crossConnect.setPowerLevel(nodeId, OpticalControlMode.Power.getName(), null, connectionNumber);
 159                         continue;
 160                     }
 161                     if (!destTpId.toUpperCase(Locale.getDefault()).contains("DEG")) {
 162                         continue;
 163                     }
 164                     // If Degree is transmitting end then set power
 165                     Optional<Mapping> mappingObjectOptional = inputNode.nonnullMapping()
 166                             .values().stream().filter(o -> o.key()
 167                             .equals(new MappingKey(destTpId))).findFirst();
 168                     if (mappingObjectOptional.isEmpty()) {
 169                         continue;
 170                     }
 171                     // TODO can it be return false rather than continue?
 172                     // in that case, mappingObjectOptional could be moved inside method getSpanLossTx()
 173                     LOG.info("Dest point is Degree {}", mappingObjectOptional.get());
 174                     BigDecimal spanLossTx = getSpanLossTx(mappingObjectOptional.get().getSupportingOts(),
 175                         destTpId, nodeId, openroadmVersion.getIntValue());
 176
 177                     LOG.info("Spanloss TX is {}", spanLossTx);
 178                     // TODO: The span-loss limits should be obtained from optical specifications
 179                     if (spanLossTx == null || spanLossTx.intValue() <= 0 || spanLossTx.intValue() > 27) {
 180                         LOG.error("Power Value is null: spanLossTx null or out of openROADM range ]0,27] {}",
 181                             spanLossTx);
 182                         return false;
 183                     }
 184                     BigDecimal powerValue = getRdmPowerValue(spanLossTx, input);
 185                     try {
 186                         if (!crossConnect.setPowerLevel(nodeId, OpticalControlMode.Power.getName(), powerValue,
 187                                 connectionNumber)) {
 188                             LOG.info("Set Power failed for Roadm-connection: {} on Node: {}",
 189                                     connectionNumber, nodeId);
 190                             // FIXME shouldn't it be LOG.error
 191                             return false;
 192                         }
 193                         LOG.info("Roadm-connection: {} updated ", connectionNumber);
 194                         Thread.sleep(timer2);
 195                         // TODO make this timer value configurable via OSGi blueprint
 196                         // although the value recommended by the white paper is 20 seconds.
 197                         // At least one vendor product needs 60 seconds
 198                         // because it is not supporting GainLoss with target-output-power.
 199
 200                         if (!crossConnect.setPowerLevel(nodeId, OpticalControlMode.GainLoss.getName(), powerValue,
 201                                 connectionNumber)) {
 202                             LOG.warn("Setting power-control mode off failed for Roadm-connection: {}",
 203                                 connectionNumber);
 204                             // FIXME no return false in that case?
 205                         }
 206                     } catch (InterruptedException e) {
 207                         LOG.error("Olm-setPower wait failed :", e);
 208                         return false;
 209                     }
 210                     break;
 211                 default :
 212                     LOG.error("OLM-PowerMgmtImpl : Error with node type for node {}", nodeId);
 213                     break;
 214             }
 215         }
 216         return true;
 217     }
 218
 219     private Map<String, Double> getTxPowerRangeMap(Nodes inputNode, String destTpId, String nodeId,
 220             Integer openroadmVersion) {
 221
 222         Optional<Mapping> mappingObject = inputNode.nonnullMapping().values().stream()
 223                 .filter(o -> o.key().equals(new MappingKey(destTpId))).findFirst();
 224         if (mappingObject.isEmpty()) {
 225             LOG.info("Mapping object not found for nodeId: {}", nodeId);
 226             // FIXME shouldn't it be LOG.error ?
 227             return null;
 228             // return null here means return false in setPower()
 229             // TODO Align protections with getSRGRxPowerRangeMap
 230         }
 231
 232         String circuitPackName = mappingObject.get().getSupportingCircuitPackName();
 233         String portName = mappingObject.get().getSupportingPort();
 234         switch (openroadmVersion) {
 235             case 1:
 236                 return PowerMgmtVersion121.getXponderPowerRange(circuitPackName, portName,
 237                     nodeId, deviceTransactionManager);
 238             case 2:
 239                 return PowerMgmtVersion221.getXponderPowerRange(circuitPackName, portName,
 240                     nodeId, deviceTransactionManager);
 241             case 3:
 242                 return PowerMgmtVersion710.getXponderPowerRange(circuitPackName, portName,
 243                     nodeId, deviceTransactionManager);
 244             default:
 245                 LOG.error("Unrecognized OpenRoadm version");
 246                 return new HashMap<>();
 247                 // FIXME shouldn't it lead to a return false in setPower()?
 248         }
 249     }
 250
 251
 252     private Map<String, Double> getSRGRxPowerRangeMap(String srgId, String nodeId, Integer openroadmVersion) {
 253
 254         Optional<Nodes> inputNode = OlmUtils.getNode(nodeId, this.db);
 255         int rdmOpenroadmVersion =
 256                 inputNode.isPresent()
 257                     ? inputNode.get().getNodeInfo().getOpenroadmVersion().getIntValue()
 258                     : openroadmVersion;
 259         Optional<Mapping> mappingObject = inputNode
 260                 .flatMap(node -> node.nonnullMapping().values().stream()
 261                     .filter(o -> o.key().equals(new MappingKey(srgId))).findFirst());
 262
 263         if (mappingObject.isEmpty()) {
 264             return new HashMap<>();
 265             // FIXME shouldn't it lead to a return false in setPower() ?
 266         }
 267
 268         String circuitPackName = mappingObject.get().getSupportingCircuitPackName();
 269         String portName = mappingObject.get().getSupportingPort();
 270         switch (rdmOpenroadmVersion) {
 271             case 1:
 272                 return PowerMgmtVersion121.getSRGRxPowerRange(nodeId, srgId,
 273                         deviceTransactionManager, circuitPackName, portName);
 274             case 2:
 275                 return PowerMgmtVersion221.getSRGRxPowerRange(nodeId, srgId,
 276                         deviceTransactionManager, circuitPackName, portName);
 277             case 3:
 278                 return PowerMgmtVersion710.getSRGRxPowerRange(nodeId, srgId,
 279                         deviceTransactionManager, circuitPackName, portName);
 280             default:
 281                 LOG.error("Unrecognized OpenRoadm version");
 282                 return null;
 283                 //return null here means return false in setPower()
 284                 // TODO Align protections with getTxPowerRangeMap
 285         }
 286     }
 287
 288     private BigDecimal getSpanLossTx(String supportingOts, String destTpId, String nodeId, Integer openroadmVersion) {
 289         try {
 290             switch (openroadmVersion) {
 291                 case 1:
 292                     Optional<Interface> interfaceOpt =
 293                         this.openRoadmInterfaces.getInterface(nodeId, supportingOts);
 294                     if (interfaceOpt.isEmpty()) {
 295                         LOG.error(INTERFACE_NOT_PRESENT, supportingOts, nodeId);
 296                         return null;
 297                     }
 298                     if (interfaceOpt.get().augmentation(Interface1.class).getOts()
 299                             .getSpanLossTransmit() == null) {
 300                         LOG.error("interface {} has no spanloss value", interfaceOpt.get().getName());
 301                         return null;
 302                     }
 303                     return interfaceOpt.get()
 304                             .augmentation(Interface1.class)
 305                             .getOts().getSpanLossTransmit().getValue();
 306                 case 2:
 307                     Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
 308                             .interfaces.grp.Interface> interfaceOpt1 =
 309                         this.openRoadmInterfaces.getInterface(nodeId, supportingOts);
 310                     if (interfaceOpt1.isEmpty()) {
 311                         LOG.error(INTERFACE_NOT_PRESENT, supportingOts, nodeId);
 312                         return null;
 313                     }
 314                     if (interfaceOpt1.get().augmentation(org.opendaylight.yang.gen.v1.http.org
 315                             .openroadm.optical.transport.interfaces.rev181019.Interface1.class).getOts()
 316                                 .getSpanLossTransmit() == null) {
 317                         LOG.error("interface {} has no spanloss value", interfaceOpt1.get().getName());
 318                         return null;
 319                     }
 320                     return interfaceOpt1.get()
 321                             .augmentation(org.opendaylight.yang.gen.v1.http.org
 322                                 .openroadm.optical.transport.interfaces.rev181019.Interface1.class)
 323                             .getOts().getSpanLossTransmit().getValue();
 324                 // TODO no case 3 ?
 325                 default:
 326                     return null;
 327             }
 328         } catch (OpenRoadmInterfaceException ex) {
 329             LOG.error("Failed to get interface {} from node {}!",
 330                 supportingOts, nodeId, ex);
 331             return null;
 332         } catch (IllegalArgumentException ex) {
 333             LOG.error("Failed to get non existing interface {} from node {}!",
 334                 supportingOts, nodeId);
 335             return null;
 336         }
 337     }
 338
 339     private BigDecimal getXpdrPowerValue(Nodes inputNode, String destTpId, String nodeId, Integer openroadmVersion,
 340             String srgId, String nextNodeId) {
 341
 342         Map<String, Double> txPowerRangeMap = getTxPowerRangeMap(inputNode, destTpId, nodeId, openroadmVersion);
 343         if (txPowerRangeMap == null) {
 344             return null;
 345             // return null here means return false in setPower()
 346         }
 347         BigDecimal powerVal =
 348             openroadmVersion == 3 ? DEFAULT_TPDR_PWR_400G : DEFAULT_TPDR_PWR_100G;
 349         if (txPowerRangeMap.isEmpty()) {
 350             LOG.info("Tranponder range not available setting to default power for nodeId: {}", nodeId);
 351             return powerVal;
 352         }
 353
 354         Map<String, Double> rxSRGPowerRangeMap = getSRGRxPowerRangeMap(srgId, nextNodeId, openroadmVersion);
 355         if (rxSRGPowerRangeMap == null) {
 356             return null;
 357             // return null here means return false in setPower()
 358             // TODO empty txPowerRangeMap + null rxSRGPowerRangeMap is allowed
 359             // => confirm this behavior is OK
 360         }
 361         if (rxSRGPowerRangeMap.isEmpty()) {
 362             LOG.info("SRG Power Range not found, setting the Transponder range to default");
 363             return powerVal;
 364         }
 365
 366         powerVal = new BigDecimal(txPowerRangeMap.get("MaxTx"))
 367             .min(new BigDecimal(rxSRGPowerRangeMap.get("MaxRx")));
 368         LOG.info("Calculated Transponder Power value is {}" , powerVal);
 369         return powerVal;
 370     }
 371
 372
 373     private BigDecimal getRdmPowerValue(BigDecimal spanLossTx, ServicePowerSetupInput input) {
 374         // TODO: These values will be obtained from the specifications
 375         // power-value here refers to the Pin[50GHz]
 376         BigDecimal powerValue;
 377         if (spanLossTx.doubleValue()  >= 23.0) {
 378             powerValue = BigDecimal.valueOf(2.0);
 379         } else if (spanLossTx.doubleValue()  >= 8.0) {
 380             powerValue = BigDecimal.valueOf(- (8.0 - spanLossTx.doubleValue()) / 3.0 - 3.0);
 381         } else if (spanLossTx.doubleValue() >= 6.0) {
 382             powerValue = BigDecimal.valueOf(-3.0);
 383         } else {
 384             powerValue = spanLossTx.subtract(BigDecimal.valueOf(9));
 385         }
 386         BigDecimal mcWidth = new BigDecimal(50);
 387         // we work at constant power spectral density (50 GHz channel width @-20dBm=37.5GHz)
 388         // 87.5 GHz channel width @-20dBm=75GHz
 389         if (input.getMcWidth() != null) {
 390             // Units of MC-width are in GHz, meaning it should be 40/50/87.5GHz
 391             // TODO: Should we validate this units before proceeding?
 392             LOG.debug("Input Grid size is {}", input.getMcWidth().getValue());
 393
 394             // We round-off the mc-width to the nearest grid-value based on the granularity of 12.5 GHz
 395             double nbrMcSlots = Math.ceil(input.getMcWidth().getValue().doubleValue() / MC_WIDTH_GRAN);
 396             LOG.debug("Nearest (ceil) number of slots {}", nbrMcSlots);
 397             mcWidth = new BigDecimal(MC_WIDTH_GRAN * nbrMcSlots);
 398             LOG.debug("Given mc-width={}, Rounded mc-width={}", input.getMcWidth().getValue(), mcWidth);
 399
 400             BigDecimal logVal = mcWidth.divide(new BigDecimal(50));
 401             double pdsVal = 10 * Math.log10(logVal.doubleValue());
 402             // Addition of PSD value will give Pin[87.5 GHz]
 403             powerValue = powerValue.add(new BigDecimal(pdsVal, new MathContext(3, RoundingMode.HALF_EVEN)));
 404         }
 405         // FIXME compliancy with OpenROADM MSA and approximations used -- should be addressed with powermask update
 406         // cf JIRA ticket https://jira.opendaylight.org/browse/TRNSPRTPCE-494
 407         powerValue = powerValue.setScale(2, RoundingMode.CEILING);
 408         // target-output-power yang precision is 2, so we limit here to 2
 409         LOG.info("The power value is P1[{}GHz]={} dB for spanloss {}", mcWidth, powerValue, spanLossTx);
 410         return powerValue;
 411     }
 412
 413     /**
 414      * This methods turns down power a WL by performing
 415      * following steps:
 416      *
 417      * <p>
 418      * 1. Pull interfaces used in service and change
 419      * status to outOfService
 420      *
 421      * <p>
 422      * 2. For each of the ROADM node set target-output-power
 423      * to -60dbm, wait for 20 seconds, turn power mode to off
 424      *
 425      * <p>
 426      * 3. Turn down power in Z to A direction and A to Z
 427      *
 428      * @param input
 429      *            Input parameter from the olm servicePowerTurndown rpc
 430      *
 431      * @return true/false based on status of operation
 432      */
 433     public Boolean powerTurnDown(ServicePowerTurndownInput input) {
 434         LOG.info("Olm-powerTurnDown initiated for input {}", input);
 435         /*Starting with last element into the list Z -> A for
 436           turning down A -> Z */
 437         String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
 438                 input.getLowerSpectralSlotNumber().toString(),
 439                 input.getHigherSpectralSlotNumber().toString());
 440         for (int i = input.getNodes().size() - 1; i >= 0; i--) {
 441             String nodeId = input.getNodes().get(i).getNodeId();
 442             String destTpId = input.getNodes().get(i).getDestTp();
 443             String connectionNumber =  String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
 444                     input.getNodes().get(i).getSrcTp(), destTpId, spectralSlotName);
 445             try {
 446                 if (destTpId.toUpperCase(Locale.getDefault()).contains("DEG")) {
 447                     if (!crossConnect.setPowerLevel(nodeId, OpticalControlMode.Power.getName(), new BigDecimal(-60),
 448                             connectionNumber)) {
 449                         LOG.warn("Power down failed for Roadm-connection: {}", connectionNumber);
 450                         return false;
 451                     }
 452                     Thread.sleep(timer2);
 453                     if (!crossConnect.setPowerLevel(nodeId, OpticalControlMode.Off.getName(), null, connectionNumber)) {
 454                         LOG.warn("Setting power-control mode off failed for Roadm-connection: {}", connectionNumber);
 455                         return false;
 456                     }
 457                 } else if (destTpId.toUpperCase(Locale.getDefault()).contains("SRG")) {
 458                     if (!crossConnect.setPowerLevel(nodeId, OpticalControlMode.Off.getName(), null, connectionNumber)) {
 459                         LOG.warn("Setting power-control mode off failed for Roadm-connection: {}", connectionNumber);
 460                         // FIXME a return false would allow sync with DEG case but makes current Unit tests fail
 461                     }
 462                 }
 463             } catch (InterruptedException e) {
 464                 // TODO Auto-generated catch block
 465                 LOG.error("Olm-powerTurnDown wait failed: ",e);
 466                 return false;
 467             }
 468         }
 469         return true;
 470     }
 471
 472     /**
 473      * This method retrieves transponder OCH interface and
 474      * sets power.
 475      *
 476      * @param nodeId
 477      *            Unique identifier for the mounted netconf- node
 478      * @param interfaceName
 479      *            OCH interface name carrying WL
 480      * @param txPower
 481      *            Calculated transmit power
 482      * @param openroadmVersion
 483      *            Version of openRoadm device software
 484      * @return true/false based on status of operation
 485      */
 486     private boolean callSetTransponderPower(String nodeId, String interfaceName, BigDecimal txPower,
 487                                             OpenroadmNodeVersion openroadmVersion) {
 488
 489         boolean powerSetupResult = false;
 490         try {
 491             switch (openroadmVersion.getIntValue()) {
 492                 case 1:
 493                     Optional<Interface> interfaceOptional121 =
 494                         openRoadmInterfaces.getInterface(nodeId, interfaceName);
 495                     if (interfaceOptional121.isEmpty()) {
 496                         LOG.error(INTERFACE_NOT_PRESENT, interfaceName, nodeId);
 497                         return false;
 498                     }
 499                     powerSetupResult = PowerMgmtVersion121.setTransponderPower(nodeId, interfaceName,
 500                             txPower, deviceTransactionManager, interfaceOptional121.get());
 501                     break;
 502                 case 2:
 503                     Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp
 504                             .Interface> interfaceOptional221 =
 505                         openRoadmInterfaces.getInterface(nodeId, interfaceName);
 506                     if (interfaceOptional221.isEmpty()) {
 507                         LOG.error(INTERFACE_NOT_PRESENT, interfaceName, nodeId);
 508                         return false;
 509                     }
 510                     powerSetupResult = PowerMgmtVersion221.setTransponderPower(nodeId, interfaceName,
 511                             txPower, deviceTransactionManager, interfaceOptional221.get());
 512                     break;
 513                 case 3:
 514                     Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp
 515                             .Interface> interfaceOptional710 =
 516                         openRoadmInterfaces.getInterface(nodeId, interfaceName);
 517                     if (interfaceOptional710.isEmpty()) {
 518                         LOG.error(INTERFACE_NOT_PRESENT, interfaceName, nodeId);
 519                         return false;
 520                     }
 521                     powerSetupResult = PowerMgmtVersion710.setTransponderPower(nodeId, interfaceName,
 522                             txPower, deviceTransactionManager, interfaceOptional710.get());
 523                     break;
 524                 default:
 525                     LOG.error("Unrecognized OpenRoadm version");
 526                     return false;
 527             }
 528         } catch (OpenRoadmInterfaceException ex) {
 529             LOG.error("Failed to get interface {} from node {}!", interfaceName, nodeId, ex);
 530             return false;
 531         }
 532         if (!powerSetupResult) {
 533             LOG.debug("Transponder power setup failed for nodeId {} on interface {}",
 534                     nodeId, interfaceName);
 535             return false;
 536         }
 537         LOG.debug("Transponder power set up completed successfully for nodeId {} and interface {}",
 538                 nodeId,interfaceName);
 539         return true;
 540     }
 541
 542 }