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