From f72917963c51bbd63ed41f41ba43f199d29365e3 Mon Sep 17 00:00:00 2001 From: Shweta Vachhani Date: Thu, 14 Jan 2021 13:23:56 -0500 Subject: [PATCH] Updated OLM module to support 7.1 devices 1) PM retrieval added for 7.1.0 models 2) Added new power management class for 7.1.0 models 3) Updated power management code to support hybrid network 4) Fix interface creation issue in renderer 5) rename OlmUtils22 class to OlmUtils221 JIRA: TRNSPRTPCE-381 Signed-off-by: Shweta Vachhani Change-Id: I282825df61fe3f469ca5af507a67a96d0b3aedfb --- .../transportpce/olm/power/PowerMgmtImpl.java | 134 ++++++--- .../olm/power/PowerMgmtVersion710.java | 252 +++++++++++++++++ .../olm/service/OlmPowerServiceImpl.java | 37 ++- .../transportpce/olm/util/OlmUtils.java | 17 +- .../transportpce/olm/util/OlmUtils221.java | 262 ++++++++++++++++++ .../{OlmUtils22.java => OlmUtils710.java} | 134 ++++----- .../OlmPowerServiceImplSpanLossBaseTest.java | 2 +- .../olm/util/OlmPowerServiceRpcImplUtil.java | 1 - .../olm/util/OlmTransactionUtils.java | 120 ++++---- .../OpenRoadmInterface221.java | 13 +- 10 files changed, 791 insertions(+), 181 deletions(-) create mode 100644 olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtVersion710.java create mode 100644 olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils221.java rename olm/src/main/java/org/opendaylight/transportpce/olm/util/{OlmUtils22.java => OlmUtils710.java} (74%) diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtImpl.java b/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtImpl.java index d324bb067..f786b181a 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtImpl.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtImpl.java @@ -40,6 +40,9 @@ public class PowerMgmtImpl implements PowerMgmt { private final OpenRoadmInterfaces openRoadmInterfaces; private final CrossConnect crossConnect; private final DeviceTransactionManager deviceTransactionManager; + private static final BigDecimal DEFAULT_TPDR_PWR_100G = new BigDecimal(-5); + private static final BigDecimal DEFAULT_TPDR_PWR_400G = new BigDecimal(0); + public PowerMgmtImpl(DataBroker db, OpenRoadmInterfaces openRoadmInterfaces, CrossConnect crossConnect, DeviceTransactionManager deviceTransactionManager) { @@ -90,38 +93,66 @@ public class PowerMgmtImpl implements PowerMgmt { java.util.Optional mappingObject = inputNode.nonnullMapping() .values().stream().filter(o -> o.key() .equals(new MappingKey(destTpId))).findFirst(); + boolean setTpdrPowerResult; if (mappingObject.isPresent()) { String circuitPackName = mappingObject.get().getSupportingCircuitPackName(); String portName = mappingObject.get().getSupportingPort(); Map txPowerRangeMap = new HashMap<>(); - if (openroadmVersion.getIntValue() == 1) { - txPowerRangeMap = PowerMgmtVersion121.getXponderPowerRange(circuitPackName, portName, + switch (openroadmVersion.getIntValue()) { + case 1: + txPowerRangeMap = PowerMgmtVersion121.getXponderPowerRange(circuitPackName, portName, nodeId, deviceTransactionManager); - } else if (openroadmVersion.getIntValue() == 2) { - txPowerRangeMap = PowerMgmtVersion221.getXponderPowerRange(circuitPackName, portName, + break; + case 2: + txPowerRangeMap = PowerMgmtVersion221.getXponderPowerRange(circuitPackName, portName, + nodeId, deviceTransactionManager); + break; + case 3: + txPowerRangeMap = PowerMgmtVersion710.getXponderPowerRange(circuitPackName, portName, nodeId, deviceTransactionManager); + break; + default: + LOG.error("Unrecognized OpenRoadm version"); } if (!txPowerRangeMap.isEmpty()) { LOG.info("Transponder range exists for nodeId: {}", nodeId); + OpenroadmVersion rdmOpenroadmVersion = openroadmVersion; String srgId = input.getNodes().get(i + 1).getSrcTp(); String nextNodeId = input.getNodes().get(i + 1).getNodeId(); + Optional inputNextOptional = OlmUtils.getNode(nextNodeId, this.db); + if (inputNextOptional.isPresent()) { + rdmOpenroadmVersion = inputNextOptional.get() + .getNodeInfo().getOpenroadmVersion(); + } Map rxSRGPowerRangeMap = new HashMap<>(); Optional mappingObjectSRG = OlmUtils.getNode(nextNodeId, db) .flatMap(node -> node.nonnullMapping().values() .stream().filter(o -> o.key() .equals(new MappingKey(srgId))).findFirst()); - if (mappingObjectSRG.isPresent()) { - if (openroadmVersion.getIntValue() == 1) { - rxSRGPowerRangeMap = PowerMgmtVersion121.getSRGRxPowerRange(nextNodeId, srgId, - deviceTransactionManager, mappingObjectSRG.get() - .getSupportingCircuitPackName(), - mappingObjectSRG.get().getSupportingPort()); - } else if (openroadmVersion.getIntValue() == 2) { - rxSRGPowerRangeMap = PowerMgmtVersion221.getSRGRxPowerRange(nextNodeId, srgId, - deviceTransactionManager, mappingObjectSRG.get() - .getSupportingCircuitPackName(), - mappingObjectSRG.get().getSupportingPort()); + if (mappingObjectSRG.isPresent()) { + switch (rdmOpenroadmVersion.getIntValue()) { + case 1: + rxSRGPowerRangeMap = PowerMgmtVersion121.getSRGRxPowerRange(nextNodeId, srgId, + deviceTransactionManager, mappingObjectSRG.get() + .getSupportingCircuitPackName(), + mappingObjectSRG.get().getSupportingPort()); + break; + case 2: + rxSRGPowerRangeMap = PowerMgmtVersion221.getSRGRxPowerRange(nextNodeId, srgId, + deviceTransactionManager, mappingObjectSRG.get() + .getSupportingCircuitPackName(), + mappingObjectSRG.get().getSupportingPort()); + break; + case 3: + rxSRGPowerRangeMap = PowerMgmtVersion710.getSRGRxPowerRange(nextNodeId, srgId, + deviceTransactionManager, mappingObjectSRG.get() + .getSupportingCircuitPackName(), + mappingObjectSRG.get().getSupportingPort()); + break; + default: + LOG.error("Unrecognized OpenRoadm version"); + return false; } } double powerValue = 0; @@ -153,8 +184,14 @@ public class PowerMgmtImpl implements PowerMgmt { LOG.info("SRG Power Range not found, setting the Transponder range to default"); String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, destTpId, spectralSlotName); - if (callSetTransponderPower(nodeId, interfaceName, new BigDecimal(-5), - openroadmVersion)) { + if (openroadmVersion.getIntValue() == 3) { + setTpdrPowerResult = callSetTransponderPower(nodeId, interfaceName, + DEFAULT_TPDR_PWR_400G, openroadmVersion); + } else { + setTpdrPowerResult = callSetTransponderPower(nodeId, interfaceName, + DEFAULT_TPDR_PWR_100G, openroadmVersion); + } + if (setTpdrPowerResult) { LOG.info("Transponder OCH connection: {} power updated ", interfaceName); try { Thread.sleep(OlmUtils.OLM_TIMER_1); @@ -170,7 +207,14 @@ public class PowerMgmtImpl implements PowerMgmt { LOG.info("Tranponder range not available setting to default power for nodeId: {}", nodeId); String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, destTpId, spectralSlotName); - if (callSetTransponderPower(nodeId, interfaceName, new BigDecimal(-5),openroadmVersion)) { + if (openroadmVersion.getIntValue() == 3) { + setTpdrPowerResult = callSetTransponderPower(nodeId, interfaceName, + DEFAULT_TPDR_PWR_400G, openroadmVersion); + } else { + setTpdrPowerResult = callSetTransponderPower(nodeId, interfaceName, + DEFAULT_TPDR_PWR_100G, openroadmVersion); + } + if (setTpdrPowerResult) { LOG.info("Transponder OCH connection: {} power updated ", interfaceName); try { Thread.sleep(OlmUtils.OLM_TIMER_1); @@ -507,27 +551,42 @@ public class PowerMgmtImpl implements PowerMgmt { OpenroadmVersion openroadmVersion) { boolean powerSetupResult = false; try { - if (openroadmVersion.getIntValue() == 1) { - Optional interfaceOptional; - interfaceOptional = openRoadmInterfaces.getInterface(nodeId, interfaceName); - if (interfaceOptional.isPresent()) { + switch (openroadmVersion.getIntValue()) { + case 1: + Optional interfaceOptional121; + interfaceOptional121 = openRoadmInterfaces.getInterface(nodeId, interfaceName); + if (!interfaceOptional121.isPresent()) { + LOG.error("Interface {} on node {} is not present!", interfaceName, nodeId); + return false; + } powerSetupResult = PowerMgmtVersion121.setTransponderPower(nodeId, interfaceName, - txPower, deviceTransactionManager, interfaceOptional.get()); - } else { - LOG.error("Interface {} on node {} is not present!", interfaceName, nodeId); - return false; - } - } else if (openroadmVersion.getIntValue() == 2) { - Optional interfaceOptional; - interfaceOptional = openRoadmInterfaces.getInterface(nodeId, interfaceName); - if (interfaceOptional.isPresent()) { + txPower, deviceTransactionManager, interfaceOptional121.get()); + break; + case 2: + Optional interfaceOptional221; + interfaceOptional221 = openRoadmInterfaces.getInterface(nodeId, interfaceName); + if (!interfaceOptional221.isPresent()) { + LOG.error("Interface {} on node {} is not present!", interfaceName, nodeId); + return false; + } powerSetupResult = PowerMgmtVersion221.setTransponderPower(nodeId, interfaceName, - txPower, deviceTransactionManager, interfaceOptional.get()); - } else { - LOG.error("Interface {} on node {} is not present!", interfaceName, nodeId); + txPower, deviceTransactionManager, interfaceOptional221.get()); + break; + case 3: + Optional interfaceOptional710; + interfaceOptional710 = openRoadmInterfaces.getInterface(nodeId, interfaceName); + if (!interfaceOptional710.isPresent()) { + LOG.error("Interface {} on node {} is not present!", interfaceName, nodeId); + return false; + } + powerSetupResult = PowerMgmtVersion710.setTransponderPower(nodeId, interfaceName, + txPower, deviceTransactionManager, interfaceOptional710.get()); + break; + default: + LOG.error("Unrecognized OpenRoadm version"); return false; - } } } catch (OpenRoadmInterfaceException ex) { LOG.error("Failed to get interface {} from node {}!", interfaceName, nodeId, ex); @@ -536,12 +595,11 @@ public class PowerMgmtImpl implements PowerMgmt { if (powerSetupResult) { LOG.debug("Transponder power set up completed successfully for nodeId {} and interface {}", nodeId,interfaceName); - return powerSetupResult; } else { LOG.debug("Transponder power setup failed for nodeId {} on interface {}", nodeId, interfaceName); - return powerSetupResult; } + return powerSetupResult; } /* diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtVersion710.java b/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtVersion710.java new file mode 100644 index 000000000..97b3c3a2e --- /dev/null +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/power/PowerMgmtVersion710.java @@ -0,0 +1,252 @@ +/* + * Copyright © 2020 AT&T and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.power; + +import com.google.common.util.concurrent.FluentFuture; +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.crossconnect.CrossConnect; +import org.opendaylight.transportpce.common.device.DeviceTransaction; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev191129.OpticalControlMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev191129.PowerDBm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.Ports; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.PortsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacksKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.RoadmConnections; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.container.OtsiBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + + +public final class PowerMgmtVersion710 { + private static final Logger LOG = LoggerFactory.getLogger(PowerMgmtVersion710.class); + + private PowerMgmtVersion710() { + } + + /** + * This method provides Transponder transmit power range. + * + * @param circuitPackName + * Transponder circuitPack name + * @param portName + * Transponder port name + * @param deviceId + * Node Id of a device + * @param deviceTransactionManager + * Device transaction manager to read device data + * @return HashMap holding Min and Max transmit power for given port + */ + public static Map getXponderPowerRange(String circuitPackName, String portName, String deviceId, + DeviceTransactionManager deviceTransactionManager) { + InstanceIdentifier portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName)) + .child(Ports.class, new PortsKey(portName)); + LOG.debug("Fetching logical Connection Point value for port {} at circuit pack {}", portName, circuitPackName); + Optional portObject = + deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, portIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (!portObject.isPresent()) { + return new HashMap<>(); + } + Ports port = portObject.get(); + if (port.getTransponderPort() == null || port.getTransponderPort().getPortPowerCapabilityMaxTx() == null) { + LOG.warn("Logical Connection Point value missing for {} {}", circuitPackName, port.getPortName()); + return new HashMap<>(); + } + Map powerRangeMap = new HashMap<>(); + powerRangeMap.put("MaxTx", port.getTransponderPort().getPortPowerCapabilityMaxTx().getValue().doubleValue()); + powerRangeMap.put("MinTx", port.getTransponderPort().getPortPowerCapabilityMinTx().getValue().doubleValue()); + return powerRangeMap; + } + + /** + * This method provides Transponder transmit power range. + * + * @param nodeId + * Unique identifier for the mounted netconf- node + * @param srgId + * SRG Id connected to transponder + * @param deviceTransactionManager + * Device transaction manager to read device data + * @param circuitPackName + * SRG circuitpack name + * @param portName + * SRG port name + * @return HashMap holding Min and Max transmit power for given port + */ + public static Map getSRGRxPowerRange(String nodeId, String srgId, + DeviceTransactionManager deviceTransactionManager, + String circuitPackName, String portName) { + LOG.debug("Coming inside SRG power range"); + LOG.debug("Mapping object exists."); + InstanceIdentifier portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName)) + .child(Ports.class, new PortsKey(portName)); + LOG.debug("Fetching logical Connection Point value for port {} at circuit pack {}{}", portName, + circuitPackName, portIID); + Optional portObject = + deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, portIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (!portObject.isPresent()) { + LOG.info("Port not found"); + return new HashMap<>(); + } + Ports port = portObject.get(); + if (port.getRoadmPort() == null) { + LOG.warn("Roadm ports power value is missing for {} {}", circuitPackName, port.getPortName()); + return new HashMap<>(); + } + LOG.debug("Port found on the node ID"); + Map powerRangeMap = new HashMap<>(); + powerRangeMap.put("MinRx", port.getRoadmPort().getPortPowerCapabilityMinRx().getValue().doubleValue()); + powerRangeMap.put("MaxRx", port.getRoadmPort().getPortPowerCapabilityMaxRx().getValue().doubleValue()); + return powerRangeMap; + } + + /** + * This method retrieves transponder OCH interface and + * sets power. + * + * @param nodeId + * Unique identifier for the mounted netconf- node + * @param interfaceName + * OCH interface name carrying WL + * @param txPower + * Calculated transmit power + * @param deviceTransactionManager + * Device Transaction Manager + * @param interfaceObj + * Interface object + * + * @return true/false based on status of operation + */ + public static boolean setTransponderPower(String nodeId, String interfaceName, BigDecimal txPower, + DeviceTransactionManager deviceTransactionManager, + Interface interfaceObj) { + LOG.debug("Setting target-power for transponder nodeId: {} InterfaceName: {}", + nodeId, interfaceName); + InterfaceBuilder otsiInterfaceBuilder = new InterfaceBuilder(interfaceObj); + OtsiBuilder otsiBuilder = new OtsiBuilder(otsiInterfaceBuilder.augmentation(Interface1.class).getOtsi()); + otsiBuilder.setTransmitPower(new PowerDBm(txPower)); + otsiInterfaceBuilder.addAugmentation(new Interface1Builder().setOtsi(otsiBuilder.build()).build()); + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(nodeId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + LOG.error("Transaction for device {} was not found during transponder power setup for Node:", nodeId); + return false; + } + } catch (InterruptedException | ExecutionException e) { + LOG.error("Unable to get transaction for device {} during transponder power setup!", nodeId, e); + return false; + } + InstanceIdentifier interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey(interfaceName)); + deviceTx.merge(LogicalDatastoreType.CONFIGURATION, interfacesIID, otsiInterfaceBuilder.build()); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + commit.get(); + LOG.info("Transponder Power update is committed"); + return true; + } catch (InterruptedException | ExecutionException e) { + LOG.error("Setting transponder power failed: ", e); + } + return false; + } + + /** + * This method does an edit-config on roadm connection subtree for a given + * connection number in order to set power level for use by the optical + * power control. + * + * @param deviceId + * Device id. + * @param mode + * Optical control modelcan be off, power or gainLoss. + * @param powerValue + * Power value in DBm. + * @param connectionNumber + * Name of the cross connect. + * @param crossConnect + * cross connect. + * @param deviceTransactionManager + * Device Transaction Manager. + * + * @return true/false based on status of operation. + */ + public static boolean setPowerLevel(String deviceId, OpticalControlMode mode, BigDecimal powerValue, + String connectionNumber, CrossConnect crossConnect, + DeviceTransactionManager deviceTransactionManager) { + @SuppressWarnings("unchecked") Optional rdmConnOpt = + (Optional) crossConnect.getCrossConnect(deviceId, connectionNumber); + if (!rdmConnOpt.isPresent()) { + LOG.warn("Roadm-Connection is null in set power level ({})", connectionNumber); + return false; + } + RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder(rdmConnOpt.get()); + rdmConnBldr.setOpticalControlMode(mode); + if (powerValue != null) { + rdmConnBldr.setTargetOutputPower(new PowerDBm(powerValue)); + } + RoadmConnections newRdmConn = rdmConnBldr.build(); + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (!deviceTxOpt.isPresent()) { + LOG.error("Transaction for device {} was not found!", deviceId); + return false; + } + deviceTx = deviceTxOpt.get(); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Unable to get transaction for device {}!", deviceId, e); + return false; + } + // post the cross connect on the device + InstanceIdentifier roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber)); + deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + commit.get(); + LOG.info("Roadm connection power level successfully set "); + return true; + } catch (InterruptedException | ExecutionException ex) { + LOG.warn("Failed to post {}", newRdmConn, ex); + } + return false; + } + +} diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java b/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java index 22fc04d97..d726b8187 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java @@ -126,16 +126,23 @@ public class OlmPowerServiceImpl implements OlmPowerService { @Override public GetPmOutput getPm(GetPmInput pmInput) { OpenroadmVersion openroadmVersion; - if (mappingUtils.getOpenRoadmVersion(pmInput.getNodeId()) - .equals(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1)) { - LOG.info("Device version is 1.2.1"); - openroadmVersion = OpenroadmVersion._121; - } else { - openroadmVersion = OpenroadmVersion._221; - LOG.info("Device version is 2.2.1"); + GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder(); + switch (mappingUtils.getOpenRoadmVersion(pmInput.getNodeId())) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + openroadmVersion = OpenroadmVersion._121; + break; + case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: + openroadmVersion = OpenroadmVersion._221; + break; + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + openroadmVersion = OpenroadmVersion._710; + break; + default: + LOG.error("Unknown device version"); + return pmOutputBuilder.build(); } LOG.info("Now calling get pm data"); - GetPmOutputBuilder pmOutputBuilder = OlmUtils.pmFetch(pmInput, deviceTransactionManager, + pmOutputBuilder = OlmUtils.pmFetch(pmInput, deviceTransactionManager, openroadmVersion); return pmOutputBuilder.build(); } @@ -355,13 +362,13 @@ public class OlmPowerServiceImpl implements OlmPowerService { .build(); GetPmOutput otsPmOutput = getPm(getPmInput); - if (otsPmOutput == null) { + if (otsPmOutput == null || otsPmOutput.getMeasurements() == null) { LOG.info("OTS PM not found for NodeId: {} TP Id:{} PMName:{}", realNodeId, tpID, pmName); return null; } try { for (Measurements measurement : otsPmOutput.getMeasurements()) { - if (pmName.equals(measurement.getPmparameterName())) { + if (pmName.equalsIgnoreCase(measurement.getPmparameterName())) { return new OtsPmHolder(pmName, Double.parseDouble(measurement.getPmparameterValue()), mapping.getSupportingOts()); } @@ -521,7 +528,14 @@ public class OlmPowerServiceImpl implements OlmPowerService { String destNodeId = link.getDestNodeId(); String destTpId = link.getDestTpid(); OtsPmHolder srcOtsPmHoler = getPmMeasurements(sourceNodeId, sourceTpId, "OpticalPowerOutput"); + if (srcOtsPmHoler == null) { + srcOtsPmHoler = getPmMeasurements(sourceNodeId, sourceTpId, "OpticalPowerOutputOSC"); + } OtsPmHolder destOtsPmHoler = getPmMeasurements(destNodeId, destTpId, "OpticalPowerInput"); + if (destOtsPmHoler == null) { + destOtsPmHoler = getPmMeasurements(destNodeId, destTpId, "OpticalPowerInputOSC"); + } + if (srcOtsPmHoler.getOtsInterfaceName() == null || destOtsPmHoler.getOtsInterfaceName() == null) { LOG.warn("OTS is not present for the link {}", link); continue; @@ -533,6 +547,9 @@ public class OlmPowerServiceImpl implements OlmPowerService { if (spanLoss.doubleValue() > 28) { LOG.warn("Span Loss is out of range of OpenROADM specifications"); } + if (spanLoss.intValue() <= 0) { + spanLoss = BigDecimal.valueOf(0); + } if (!setSpanLoss(sourceNodeId, srcOtsPmHoler.getOtsInterfaceName(), spanLoss, "TX")) { LOG.info("Setting spanLoss failed for {}", sourceNodeId); return null; diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java index 87b7df9df..19dc86b69 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java @@ -76,10 +76,19 @@ public final class OlmUtils { LOG.info("Getting PM Data for NodeId: {} ResourceType: {} ResourceName: {}", input.getNodeId(), input.getResourceType(), input.getResourceIdentifier()); GetPmOutputBuilder pmOutputBuilder; - if (openRoadmVersion.getIntValue() == 1) { - pmOutputBuilder = OlmUtils121.pmFetch(input, deviceTransactionManager); - } else { - pmOutputBuilder = OlmUtils22.pmFetch(input, deviceTransactionManager); + switch (openRoadmVersion.getIntValue()) { + case 1: + pmOutputBuilder = OlmUtils121.pmFetch(input, deviceTransactionManager); + break; + case 2: + pmOutputBuilder = OlmUtils221.pmFetch(input, deviceTransactionManager); + break; + case 3: + pmOutputBuilder = OlmUtils710.pmFetch(input, deviceTransactionManager); + break; + default: + LOG.error("Unrecognized OpenRoadm version"); + pmOutputBuilder = new GetPmOutputBuilder(); } return pmOutputBuilder; } diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils221.java b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils221.java new file mode 100644 index 000000000..8927bad32 --- /dev/null +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils221.java @@ -0,0 +1,262 @@ +/* + * Copyright © 2017 AT&T and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.olm.util; + +import com.google.common.base.Strings; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.MeasurementsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.PortsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacks; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacksKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.internal.links.InternalLink; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.internal.links.InternalLinkKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Degree; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.DegreeKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.physical.links.PhysicalLink; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.physical.links.PhysicalLinkKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.shelves.Shelves; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.shelves.ShelvesKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.CurrentPmList; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.group.CurrentPm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntry; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntryKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.val.group.Measurement; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.Direction; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.Location; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.PmNamesEnum; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.olm.get.pm.input.ResourceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +final class OlmUtils221 { + + private static final Logger LOG = LoggerFactory.getLogger(OlmUtils221.class); + + /** + * This method retrieves list of current PMs for given nodeId, + * resourceType, resourceName and Granularity.Currently vendorExtentions + * are excluded but can be added back based on requirement + * + *

+ * 1. pmFetch This operation traverse through current PM list and gets PM for + * given NodeId and Resource name + * + * @param input + * Input parameter from the olm yang model get-pm rpc + * @param deviceTransactionManager + * Device tx manager + * + * @return Result of the request list of PM readings + */ + public static GetPmOutputBuilder pmFetch(GetPmInput input, DeviceTransactionManager deviceTransactionManager) { + LOG.info("Getting PM Data for 2.2.1 NodeId: {} ResourceType: {} ResourceName: {}", input.getNodeId(), + input.getResourceType(), input.getResourceIdentifier()); + + GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder(); + + InstanceIdentifier resourceKeyIID = + findClassKeyIdentifiers(input.getResourceType(), input.getResourceIdentifier()); + CurrentPmEntryKey resourceKey = new CurrentPmEntryKey(resourceKeyIID, + convertResourceTypeEnum(input.getResourceType()),""); + InstanceIdentifier iidCurrentPmList = InstanceIdentifier.create(CurrentPmList.class); + + Optional currentPmListOpt = deviceTransactionManager.getDataFromDevice(input.getNodeId(), + LogicalDatastoreType.OPERATIONAL, iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (currentPmListOpt.isPresent()) { + CurrentPmList currentPmList = currentPmListOpt.get(); + @NonNull + Map currentPmEntryList = currentPmList.nonnullCurrentPmEntry(); + LOG.info("Current PM list exists for node {} and contains {} entries.", input.getNodeId(), + currentPmEntryList.size()); + for (Map.Entry entry : currentPmEntryList.entrySet()) { + CurrentPmEntry cpe = entry.getValue(); + CurrentPmEntryKey cpek = new CurrentPmEntryKey(cpe.getPmResourceInstance(), cpe.getPmResourceType(), + ""); + if (resourceKey.equals(cpek)) { + List currentPMList = new ArrayList<>(cpe.nonnullCurrentPm().values()); + Stream currentPMStream = currentPMList.stream(); + if (input.getPmNameType() != null) { + currentPMStream = currentPMStream.filter(pm -> pm.getType().getIntValue() + == PmNamesEnum.forValue(input.getPmNameType().getIntValue()).getIntValue()); + } + if (input.getPmExtension() != null) { + currentPMStream = currentPMStream.filter(pm -> pm.getExtension() + .equals(input.getPmExtension())); + } + if (input.getLocation() != null) { + currentPMStream = currentPMStream.filter(pm -> Location.forValue(pm.getLocation() + .getIntValue()) + .equals(Location.forValue(input.getLocation().getIntValue()))); + } + if (input.getDirection() != null) { + currentPMStream = currentPMStream.filter(pm -> Direction.forValue(pm.getDirection() + .getIntValue()) + .equals(Direction.forValue((input.getDirection().getIntValue())))); + } + List filteredPMs = currentPMStream.collect(Collectors.toList()); + List measurements = extractWantedMeasurements(filteredPMs,input.getGranularity()); + if (measurements.isEmpty()) { + LOG.error( + "No Matching PM data found for node: {}, resource type: {}, resource name: {}, " + + "pm type: {}, extention: {}, location: {} and direction: {}", + input.getNodeId(), input.getResourceType(), + getResourceIdentifierAsString(input.getResourceIdentifier()), + input.getPmNameType(),input.getPmExtension(),input.getLocation(), + input.getDirection()); + } else { + pmOutputBuilder.setNodeId(input.getNodeId()).setResourceType(input.getResourceType()) + .setResourceIdentifier(input.getResourceIdentifier()).setGranularity(input + .getGranularity()) + .setMeasurements(measurements); + LOG.info( + "PM data found successfully for node: {}, resource type: {}, resource name: {}, " + + "pm type: {}, extention: {}, location: {} and direction: {}", + input.getNodeId(), input.getResourceType(), + getResourceIdentifierAsString(input.getResourceIdentifier()), + input.getPmNameType(),input.getPmExtension(),input.getLocation(), + input.getDirection()); + } + } + } + } else { + LOG.error("Unable to get CurrentPmList for node {}", input.getNodeId()); + } + return pmOutputBuilder; + } + + private static String getResourceIdentifierAsString(ResourceIdentifier resourceIdentifier) { + if (Strings.isNullOrEmpty(resourceIdentifier.getCircuitPackName())) { + return resourceIdentifier.getResourceName(); + } else { + return resourceIdentifier.getResourceName() + ", circuit pack name: " + + resourceIdentifier.getCircuitPackName(); + } + } + + private static List extractWantedMeasurements(List currentPmList, + org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity wantedGranularity) { + List olmMeasurements = new ArrayList<>(); + for (CurrentPm pm : currentPmList) { + for (Measurement measurements: pm.nonnullMeasurement().values()) { + if (measurements.getGranularity().getIntValue() + == org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmGranularity.forValue( + wantedGranularity.getIntValue()).getIntValue()) { + MeasurementsBuilder pmMeasureBuilder = new MeasurementsBuilder(); + pmMeasureBuilder.setPmparameterName(pm.getType().name()); + pmMeasureBuilder.setPmparameterValue(measurements.getPmParameterValue().stringValue()); + olmMeasurements.add(pmMeasureBuilder.build()); + } + } + } + return olmMeasurements; + } + + private static InstanceIdentifier findClassKeyIdentifiers(ResourceTypeEnum wantedResourceType, + ResourceIdentifier wantedResourceIdentifier) { + switch (wantedResourceType) { + case Device: + return InstanceIdentifier.create(OrgOpenroadmDevice.class); + case Degree: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Degree.class, new DegreeKey(Uint16.valueOf(wantedResourceIdentifier.getResourceName()))); + case SharedRiskGroup: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(SharedRiskGroup.class, + new SharedRiskGroupKey(Uint16.valueOf(wantedResourceIdentifier.getResourceName()))); + case Connection: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(RoadmConnections.class, new RoadmConnectionsKey(wantedResourceIdentifier + .getResourceName())); + case CircuitPack: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(wantedResourceIdentifier.getResourceName())); + case Port: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(wantedResourceIdentifier.getCircuitPackName())) + .child(Ports.class, new PortsKey(wantedResourceIdentifier.getResourceName())); + case Interface: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey(wantedResourceIdentifier.getResourceName())); + case InternalLink: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(InternalLink.class, new InternalLinkKey(wantedResourceIdentifier.getResourceName())); + case PhysicalLink: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(PhysicalLink.class, new PhysicalLinkKey(wantedResourceIdentifier.getResourceName())); + case Shelf: + return InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Shelves.class, new ShelvesKey(wantedResourceIdentifier.getResourceName())); + default: + LOG.error("Unknown resource type {}", wantedResourceType); + return null; + } + } + + private static org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum + convertResourceTypeEnum(ResourceTypeEnum wantedResourceType) { + switch (wantedResourceType) { + case Device: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Device; + case Degree: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Degree; + case SharedRiskGroup: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.SharedRiskGroup; + case Connection: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.Connection; + case CircuitPack: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.CircuitPack; + case Port: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Port; + case Interface: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.Interface; + case InternalLink: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.InternalLink; + case PhysicalLink: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.PhysicalLink; + case Shelf: + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Shelf; + default: + LOG.error("Unknown resource type {}", wantedResourceType); + return null; + } + } + + private OlmUtils221() { + } + +} diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils22.java b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils710.java similarity index 74% rename from olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils22.java rename to olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils710.java index a6289524b..02dac7345 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils22.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils710.java @@ -1,5 +1,5 @@ /* - * Copyright © 2017 AT&T and others. All rights reserved. + * Copyright © 2020 AT&T and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, @@ -22,30 +22,30 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev17 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.MeasurementsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.PortsKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacks; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacksKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.internal.links.InternalLink; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.internal.links.InternalLinkKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Degree; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.DegreeKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.physical.links.PhysicalLink; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.physical.links.PhysicalLinkKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.shelves.Shelves; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.shelves.ShelvesKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.CurrentPmList; -import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.group.CurrentPm; -import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntry; -import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntryKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.val.group.Measurement; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.Ports; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.PortsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacksKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.internal.links.InternalLink; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.internal.links.InternalLinkKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Degree; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.DegreeKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.RoadmConnections; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.physical.links.PhysicalLink; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.physical.links.PhysicalLinkKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.shelves.Shelves; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.shelves.ShelvesKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev200529.CurrentPmList; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev200529.current.pm.group.CurrentPm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev200529.current.pm.list.CurrentPmEntry; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev200529.current.pm.list.CurrentPmEntryKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev200529.current.pm.val.group.Measurement; import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum; import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.Direction; import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.Location; @@ -56,9 +56,9 @@ import org.opendaylight.yangtools.yang.common.Uint16; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -final class OlmUtils22 { +final class OlmUtils710 { - private static final Logger LOG = LoggerFactory.getLogger(OlmUtils22.class); + private static final Logger LOG = LoggerFactory.getLogger(OlmUtils710.class); /** * This method retrieves list of current PMs for given nodeId, @@ -76,73 +76,73 @@ final class OlmUtils22 { * * @return Result of the request list of PM readings */ - //LOG.info message length is >120 char and can be difficultly shortened - @SuppressWarnings("checkstyle:linelength") public static GetPmOutputBuilder pmFetch(GetPmInput input, DeviceTransactionManager deviceTransactionManager) { - LOG.info("Getting PM Data for 2.2.1 NodeId: {} ResourceType: {} ResourceName: {}", input.getNodeId(), - input.getResourceType(), input.getResourceIdentifier()); + LOG.info("Getting PM Data for 7.1.0 NodeId: {} ResourceType: {} ResourceName: {}", input.getNodeId(), + input.getResourceType(), input.getResourceIdentifier()); GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder(); InstanceIdentifier resourceKeyIID = - findClassKeyIdentifiers(input.getResourceType(), input.getResourceIdentifier()); + findClassKeyIdentifiers(input.getResourceType(), input.getResourceIdentifier()); CurrentPmEntryKey resourceKey = new CurrentPmEntryKey(resourceKeyIID, - convertResourceTypeEnum(input.getResourceType()), ""); + convertResourceTypeEnum(input.getResourceType()), ""); InstanceIdentifier iidCurrentPmList = InstanceIdentifier.create(CurrentPmList.class); Optional currentPmListOpt = deviceTransactionManager.getDataFromDevice(input.getNodeId(), - LogicalDatastoreType.OPERATIONAL, iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, - Timeouts.DEVICE_READ_TIMEOUT_UNIT); + LogicalDatastoreType.OPERATIONAL, iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); if (currentPmListOpt.isPresent()) { CurrentPmList currentPmList = currentPmListOpt.get(); - @NonNull Map currentPmEntryList = currentPmList.nonnullCurrentPmEntry(); LOG.info("Current PM list exists for node {} and contains {} entries.", input.getNodeId(), - currentPmEntryList.size()); + currentPmEntryList.size()); for (Map.Entry entry : currentPmEntryList.entrySet()) { CurrentPmEntry cpe = entry.getValue(); CurrentPmEntryKey cpek = new CurrentPmEntryKey(cpe.getPmResourceInstance(), cpe.getPmResourceType(), - cpe.getPmResourceTypeExtension()); + ""); if (resourceKey.equals(cpek)) { List currentPMList = new ArrayList<>(cpe.nonnullCurrentPm().values()); Stream currentPMStream = currentPMList.stream(); if (input.getPmNameType() != null) { currentPMStream = currentPMStream.filter(pm -> pm.getType().getIntValue() - == PmNamesEnum.forValue(input.getPmNameType().getIntValue()).getIntValue()); + == PmNamesEnum.forValue(input.getPmNameType().getIntValue()).getIntValue()); } if (input.getPmExtension() != null) { currentPMStream = currentPMStream.filter(pm -> pm.getExtension() - .equals(input.getPmExtension())); + .equals(input.getPmExtension())); } if (input.getLocation() != null) { currentPMStream = currentPMStream.filter(pm -> Location.forValue(pm.getLocation().getIntValue()) - .equals(Location.forValue(input.getLocation().getIntValue()))); + .equals(Location.forValue(input.getLocation().getIntValue()))); } if (input.getDirection() != null) { - currentPMStream = currentPMStream.filter(pm -> Direction.forValue(pm.getDirection().getIntValue()) - .equals(Direction.forValue((input.getDirection().getIntValue())))); + currentPMStream = currentPMStream.filter(pm -> Direction.forValue(pm.getDirection() + .getIntValue()) + .equals(Direction.forValue((input.getDirection().getIntValue())))); } List filteredPMs = currentPMStream.collect(Collectors.toList()); List measurements = extractWantedMeasurements(filteredPMs,input.getGranularity()); if (measurements.isEmpty()) { LOG.error( - "No Matching PM data found for node: {}, resource type: {}, resource name: {}, pm type: {}, extention: {}, location: {} and direction: {}", - input.getNodeId(), input.getResourceType(), - getResourceIdentifierAsString(input.getResourceIdentifier()), - input.getPmNameType(),input.getPmExtension(),input.getLocation(), - input.getDirection()); + "No Matching PM data found for node: {}, resource type: {}, resource name: {}, " + + "pm type: {}, extention: {}, location: {} and direction: {}", + input.getNodeId(), input.getResourceType(), + getResourceIdentifierAsString(input.getResourceIdentifier()), + input.getPmNameType(),input.getPmExtension(),input.getLocation(), + input.getDirection()); } else { pmOutputBuilder.setNodeId(input.getNodeId()).setResourceType(input.getResourceType()) - .setResourceIdentifier(input.getResourceIdentifier()).setGranularity(input.getGranularity()) - .setMeasurements(measurements); + .setResourceIdentifier(input.getResourceIdentifier()).setGranularity(input + .getGranularity()).setMeasurements(measurements); LOG.info( - "PM data found successfully for node: {}, resource type: {}, resource name: {}, pm type: {}, extention: {}, location: {} and direction: {}", - input.getNodeId(), input.getResourceType(), - getResourceIdentifierAsString(input.getResourceIdentifier()), - input.getPmNameType(),input.getPmExtension(),input.getLocation(), - input.getDirection()); + "PM data found successfully for node: {}, resource type: {}, resource name: {}, " + + "pm type: {}, extention: {}, location: {} and direction: {}", + input.getNodeId(), input.getResourceType(), + getResourceIdentifierAsString(input.getResourceIdentifier()), + input.getPmNameType(),input.getPmExtension(),input.getLocation(), + input.getDirection()); } } } @@ -218,42 +218,42 @@ final class OlmUtils22 { } } - private static org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum + private static org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129.ResourceTypeEnum convertResourceTypeEnum(ResourceTypeEnum wantedResourceType) { switch (wantedResourceType) { case Device: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Device; + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129.ResourceTypeEnum.Device; case Degree: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Degree; + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129.ResourceTypeEnum.Degree; case SharedRiskGroup: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.SharedRiskGroup; case Connection: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.Connection; case CircuitPack: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.CircuitPack; case Port: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Port; + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129.ResourceTypeEnum.Port; case Interface: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.Interface; case InternalLink: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.InternalLink; case PhysicalLink: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129 .ResourceTypeEnum.PhysicalLink; case Shelf: - return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Shelf; + return org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev191129.ResourceTypeEnum.Shelf; default: LOG.error("Unknown resource type {}", wantedResourceType); return null; } } - private OlmUtils22() { + private OlmUtils710() { } } diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java index 2083190ee..a52f944d5 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java @@ -179,4 +179,4 @@ public class OlmPowerServiceImplSpanLossBaseTest extends AbstractTest { Assert.assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue()); Assert.assertEquals("14.6", output.getSpans().get(0).getSpanloss()); } -} +} \ No newline at end of file diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java index 091181e1c..4f106606d 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java @@ -175,7 +175,6 @@ public final class OlmPowerServiceRpcImplUtil { public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInputAll() { CalculateSpanlossBaseInput input = new CalculateSpanlossBaseInputBuilder() - .setLinkId(new LinkId("ROADM-A1-to-ROADM-C1")) .setSrcType(CalculateSpanlossBaseInput.SrcType.All) .build(); return input; diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java index 9d092b79e..99b426bab 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java @@ -133,43 +133,49 @@ public final class OlmTransactionUtils { Map amplifiedLinkValues = new HashMap<>(); org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes.AmplifiedLink al = - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes - .AmplifiedLinkBuilder() - .setSectionElement(new SectionElementBuilder().setSectionElement( - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes - .amplified.link.section.element.section.element.SpanBuilder().setSpan( - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link - .attributes.amplified.link.section.element.section.element.span.SpanBuilder() - .setAdministrativeState(AdminStates.InService) - .setAutoSpanloss(true) - .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) - .setLinkConcatenation(linkConcentationValues) - .setSpanlossBase(new RatioDB(BigDecimal.ONE)) - .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes + .AmplifiedLinkBuilder() + .setSectionElement(new SectionElementBuilder().setSectionElement( + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified + .link.attributes + .amplified.link.section.element.section.element.SpanBuilder() + .setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529 + .amplified.link.attributes.amplified.link.section.element + .section.element + .span.SpanBuilder() + .setAdministrativeState(AdminStates.InService) + .setAutoSpanloss(true) + .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) + .setLinkConcatenation(linkConcentationValues) + .setSpanlossBase(new RatioDB(BigDecimal.ONE)) + .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + .build()) .build()) .build()) - .build()) - .setSectionEltNumber(Uint16.valueOf(1)) - .build(); + .setSectionEltNumber(Uint16.valueOf(1)) + .build(); org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes.AmplifiedLink al2 = - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes - .AmplifiedLinkBuilder() - .setSectionElement(new SectionElementBuilder().setSectionElement( - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes - .amplified.link.section.element.section.element.SpanBuilder().setSpan( - new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link - .attributes.amplified.link.section.element.section.element.span.SpanBuilder() - .setAdministrativeState(AdminStates.InService) - .setAutoSpanloss(true) - .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) - .setLinkConcatenation(linkConcentationValues) - .setSpanlossBase(new RatioDB(BigDecimal.ONE)) - .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified.link.attributes + .AmplifiedLinkBuilder() + .setSectionElement(new SectionElementBuilder().setSectionElement( + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.amplified + .link.attributes + .amplified.link.section.element.section.element.SpanBuilder() + .setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529 + .amplified.link.attributes.amplified.link.section.element + .section.element + .span.SpanBuilder() + .setAdministrativeState(AdminStates.InService) + .setAutoSpanloss(true) + .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) + .setLinkConcatenation(linkConcentationValues) + .setSpanlossBase(new RatioDB(BigDecimal.ONE)) + .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + .build()) .build()) .build()) - .build()) - .setSectionEltNumber(Uint16.valueOf(1)) - .build(); + .setSectionEltNumber(Uint16.valueOf(1)) + .build(); amplifiedLinkValues.put(al.key(),al); amplifiedLinkValues.put(al2.key(),al2); Map>, Augmentation> map = Collections.emptyMap(); @@ -181,8 +187,8 @@ public final class OlmTransactionUtils { .build()) .build(); org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1 aug12 = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder() - .setLinkType(OpenroadmLinkType.ROADMTOROADM).build(); + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder() + .setLinkType(OpenroadmLinkType.ROADMTOROADM).build(); Augmentation aug21 = new Link1Builder() .setAmplified(true) .setOMSAttributes(new OMSAttributesBuilder() @@ -190,18 +196,19 @@ public final class OlmTransactionUtils { .setSpan(new SpanBuilder().build()).build()) .build(); org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1 aug22 = - new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder() - .setLinkType(OpenroadmLinkType.ROADMTOROADM).build(); + new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder() + .setLinkType(OpenroadmLinkType.ROADMTOROADM).build(); // create the roadm-to-roadm link to be measured Link roadm2roadmLink = new LinkBuilder().setLinkId(new LinkId("ROADM-A1-to-ROADM-C1")) - .setSource(new SourceBuilder().setSourceNode(ietfNodeA.getNodeId()).setSourceTp("DEG2-TTP-TXRX").build()) - .setDestination( - new DestinationBuilder().setDestNode(ietfNodeC.getNodeId()).setDestTp("DEG1-TTP-TXRX").build()) - .addAugmentation(aug11) - .addAugmentation(aug12) - .addAugmentation(aug21) - .addAugmentation(aug22) - .build(); + .setSource(new SourceBuilder().setSourceNode(ietfNodeA.getNodeId()).setSourceTp("DEG2-TTP-TXRX") + .build()) + .setDestination( + new DestinationBuilder().setDestNode(ietfNodeC.getNodeId()).setDestTp("DEG1-TTP-TXRX").build()) + .addAugmentation(aug11) + .addAugmentation(aug12) + .addAugmentation(aug21) + .addAugmentation(aug22) + .build(); // create the ietf network Network1 openroadmAugmToIetfNetwork = new Network1Builder() .setLink(Map.of(roadm2roadmLink.key(),roadm2roadmLink)).build(); @@ -227,23 +234,26 @@ public final class OlmTransactionUtils { public static Optional getCurrentPmListA() { Measurement measurementA = new MeasurementBuilder() .withKey(new MeasurementKey(PmGranularity._15min)) - .setGranularity(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmGranularity._15min) + .setGranularity(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215 + .PmGranularity._15min) .setPmParameterValue(new PmDataType(new BigDecimal("-3.5"))) .setValidity(Validity.Complete) .build(); CurrentPm cpA = new CurrentPmBuilder() .withKey(new CurrentPmKey(Direction.Bidirectional, "", Location.NotApplicable, PmNamesEnum.OpticalPowerOutput)) - .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum.OpticalPowerOutput) - .setMeasurement(Map.of(measurementA.key(),measurementA)) - .build(); + .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum + .OpticalPowerOutput) + .setMeasurement(Map.of(measurementA.key(),measurementA)) + .build(); InstanceIdentifier interfaceIIDA = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(Interface.class, new InterfaceKey("OTS-DEG2-TTP-TXRX")); CurrentPmEntry currentPmEntryA = new CurrentPmEntryBuilder() .setCurrentPm(Map.of(cpA.key(),cpA)) .setPmResourceInstance(interfaceIIDA) .setPmResourceType( - org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Interface) + org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum + .Interface) .setPmResourceTypeExtension("") .setRetrievalTime(new DateAndTime("2018-06-07T13:22:58+00:00")) .build(); @@ -260,20 +270,22 @@ public final class OlmTransactionUtils { CurrentPm cpC = new CurrentPmBuilder() .withKey(new CurrentPmKey(Direction.Bidirectional, "", Location.NotApplicable, PmNamesEnum.OpticalPowerInput)) - .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum.OpticalPowerInput) - .setMeasurement(Map.of(measurementC.key(),measurementC)) - .build(); + .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum + .OpticalPowerInput) + .setMeasurement(Map.of(measurementC.key(),measurementC)) + .build(); InstanceIdentifier interfaceIIDC = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(Interface.class, new InterfaceKey("OTS-DEG1-TTP-TXRX")); CurrentPmEntry currentPmEntryC = new CurrentPmEntryBuilder() .setCurrentPm(Map.of(cpC.key(),cpC)) .setPmResourceInstance(interfaceIIDC) .setPmResourceType( - org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Interface) + org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019 + .ResourceTypeEnum.Interface) .setPmResourceTypeExtension("") .setRetrievalTime(new DateAndTime("2018-06-07T13:22:58+00:00")) .build(); return Optional.of(new CurrentPmListBuilder() .setCurrentPmEntry(Map.of(currentPmEntryC.key(),currentPmEntryC)).build()); } -} +} \ No newline at end of file diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java index e83e3333e..270ddfcdf 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java @@ -117,13 +117,14 @@ public class OpenRoadmInterface221 { } List interfacesCreated = new ArrayList<>(); - + String mcInterfaceCreated = ""; if (logicalConnPoint.contains("DEG")) { - String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation); + mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation); interfacesCreated.add(mcInterfaceCreated); } - String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation); - interfacesCreated.add(mcInterfaceCreated); + String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation, + mcInterfaceCreated); + interfacesCreated.add(nmcInterfaceCreated); return interfacesCreated; } @@ -162,7 +163,7 @@ public class OpenRoadmInterface221 { } public String createNMCInterface(String nodeId, String logicalConnPoint, - SpectrumInformation spectrumInformation) + SpectrumInformation spectrumInformation, String mcName) throws OpenRoadmInterfaceException { LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency()); LOG.info("This is the nmc width {}", spectrumInformation.getWidth()); @@ -177,7 +178,7 @@ public class OpenRoadmInterface221 { InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap, NetworkMediaChannelConnectionTerminationPoint.class, nmcName); if (logicalConnPoint.contains("DEG")) { - nmcInterfaceBldr.setSupportingInterface(nmcName); + nmcInterfaceBldr.setSupportingInterface(mcName); } NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder() -- 2.36.6