2 * Copyright © 2017 AT&T and others. All rights reserved.
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
9 package org.opendaylight.transportpce.olm.service;
11 import com.google.common.base.Strings;
12 import java.math.BigDecimal;
13 import java.math.RoundingMode;
14 import java.util.ArrayList;
15 import java.util.Collections;
16 import java.util.List;
17 import java.util.Optional;
18 import java.util.concurrent.ExecutionException;
19 import java.util.concurrent.TimeUnit;
20 import java.util.concurrent.TimeoutException;
21 import java.util.stream.Collectors;
22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
24 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
25 import org.opendaylight.transportpce.common.InstanceIdentifiers;
26 import org.opendaylight.transportpce.common.NetworkUtils;
27 import org.opendaylight.transportpce.common.ResponseCodes;
28 import org.opendaylight.transportpce.common.StringConstants;
29 import org.opendaylight.transportpce.common.Timeouts;
30 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
31 import org.opendaylight.transportpce.common.mapping.MappingUtils;
32 import org.opendaylight.transportpce.common.mapping.PortMapping;
33 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
34 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
35 import org.opendaylight.transportpce.olm.power.PowerMgmt;
36 import org.opendaylight.transportpce.olm.util.OlmUtils;
37 import org.opendaylight.transportpce.olm.util.OtsPmHolder;
38 import org.opendaylight.transportpce.olm.util.RoadmLinks;
39 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput;
40 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutput;
41 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutputBuilder;
42 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput;
43 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutput;
44 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutputBuilder;
45 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
46 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInputBuilder;
47 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput;
48 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder;
49 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput;
50 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetOutput;
51 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput;
52 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutput;
53 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutputBuilder;
54 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput;
55 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput;
56 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder;
57 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements;
58 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping;
59 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.RatioDB;
60 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
61 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
62 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
63 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
64 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1;
65 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType;
66 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1;
67 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1Builder;
68 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.Ots;
69 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder;
70 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
72 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
73 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.PmNamesEnum;
74 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.get.pm.input.ResourceIdentifierBuilder;
75 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
78 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
79 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
82 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkKey;
88 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
89 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
90 import org.slf4j.Logger;
91 import org.slf4j.LoggerFactory;
93 public class OlmPowerServiceImpl implements OlmPowerService {
94 private static final Logger LOG = LoggerFactory.getLogger(OlmPowerServiceImpl.class);
95 private final MappingUtils mappingUtils;
96 private final OpenRoadmInterfaces openRoadmInterfaces;
97 private final DataBroker dataBroker;
98 private final PowerMgmt powerMgmt;
99 private final DeviceTransactionManager deviceTransactionManager;
100 private final PortMapping portMapping;
102 public OlmPowerServiceImpl(DataBroker dataBroker, PowerMgmt powerMgmt,
103 DeviceTransactionManager deviceTransactionManager, PortMapping portMapping,
104 MappingUtils mappingUtils, OpenRoadmInterfaces openRoadmInterfaces) {
105 this.dataBroker = dataBroker;
106 this.powerMgmt = powerMgmt;
107 this.portMapping = portMapping;
108 this.deviceTransactionManager = deviceTransactionManager;
109 this.mappingUtils = mappingUtils;
110 this.openRoadmInterfaces = openRoadmInterfaces;
114 LOG.info("init ...");
117 public void close() {
118 LOG.info("close ...");
123 public GetPmOutput getPm(GetPmInput pmInput) {
124 org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping
125 .rev170228.network.Nodes.OpenroadmVersion openroadmVersion;
126 //LOG.info("Version returbed by mapping util is "+ mappingUtils.getOpenROADMVersion(pmInput.getNodeId()));
127 if (mappingUtils.getOpenRoadmVersion(pmInput.getNodeId())
128 .equals(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1)) {
129 LOG.info("Device version is 1.2.1");
130 openroadmVersion = org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping
131 .rev170228.network.Nodes.OpenroadmVersion._121;
133 openroadmVersion = org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping
134 .rev170228.network.Nodes.OpenroadmVersion._221;
135 LOG.info("Device version is 2.2");
137 LOG.info("Now calling get pm data");
138 GetPmOutputBuilder pmOutputBuilder = OlmUtils.pmFetch(pmInput, deviceTransactionManager,
141 return pmOutputBuilder.build();
145 public ServicePowerSetupOutput servicePowerSetup(ServicePowerSetupInput powerSetupInput) {
146 ServicePowerSetupOutputBuilder powerSetupOutput = new ServicePowerSetupOutputBuilder();
147 boolean successValPowerCalculation = powerMgmt.setPower(powerSetupInput);
149 if (successValPowerCalculation) {
150 powerSetupOutput.setResult(ResponseCodes.SUCCESS_RESULT);
152 powerSetupOutput.setResult(ResponseCodes.FAILED_RESULT);
154 return powerSetupOutput.build();
158 public ServicePowerTurndownOutput servicePowerTurndown(
159 ServicePowerTurndownInput powerTurndownInput) {
161 ServicePowerTurndownOutputBuilder powerTurnDownOutput = new ServicePowerTurndownOutputBuilder();
162 // TODO add flag or return failure instead of string
163 if (powerMgmt.powerTurnDown(powerTurndownInput)) {
164 powerTurnDownOutput.setResult(ResponseCodes.SUCCESS_RESULT);
166 powerTurnDownOutput.setResult(ResponseCodes.FAILED_RESULT);
168 return powerTurnDownOutput.build();
172 public CalculateSpanlossBaseOutput calculateSpanlossBase(CalculateSpanlossBaseInput spanlossBaseInput) {
173 LOG.info("CalculateSpanlossBase Request received for source type {}", spanlossBaseInput.getSrcType());
174 List<RoadmLinks> roadmLinks = new ArrayList<>();
175 CalculateSpanlossBaseOutputBuilder spanLossBaseBuilder = new CalculateSpanlossBaseOutputBuilder();
176 boolean spanLossResult = false;
177 //Depending on the source type do the calculation
178 switch (spanlossBaseInput.getSrcType()) {
180 LOG.debug("Calculate SpanLossBase for a linkId: {}",spanlossBaseInput.getLinkId());
181 Link inputLink = getNetworkLinkById(spanlossBaseInput.getLinkId());
182 if (inputLink != null) {
183 RoadmLinks roadmLink = new RoadmLinks();
184 roadmLink.setSrcNodeId(inputLink.getSource().getSourceNode().getValue());
185 roadmLink.setSrcTpId(inputLink.getSource().getSourceTp().toString());
186 roadmLink.setDestNodeId(inputLink.getDestination().getDestNode().getValue());
187 roadmLink.setDestTpid(inputLink.getDestination().getDestTp().toString());
188 roadmLink.setLinkId(inputLink.getLinkId());
189 roadmLinks.add(roadmLink);
190 spanLossResult = getLinkSpanloss(roadmLinks);
194 LOG.info("Do something for all");
195 List<Link> networkLinks = getNetworkLinks();
196 if (networkLinks.isEmpty()) {
197 LOG.warn("Failed to get links form {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
198 return new CalculateSpanlossBaseOutputBuilder().setResult(ResponseCodes.FAILED_RESULT).build();
200 //else for all other links
201 for (Link link : networkLinks) {
202 Link1 roadmLinkAugmentation = link.augmentation(Link1.class);
203 if (roadmLinkAugmentation == null) {
204 LOG.debug("Missing OpenRoadm link augmentation in link {} from {} topology.",
205 link.getLinkId().getValue(), NetworkUtils.OVERLAY_NETWORK_ID);
208 if (OpenroadmLinkType.ROADMTOROADM.equals(roadmLinkAugmentation.getLinkType())) {
209 // Only calculate spanloss for Roadm-to-Roadm links
210 RoadmLinks roadmLink = new RoadmLinks();
211 roadmLink.setSrcNodeId(link.getSource().getSourceNode().getValue());
212 roadmLink.setSrcTpId(link.getSource().getSourceTp().toString());
213 roadmLink.setDestNodeId(link.getDestination().getDestNode().getValue());
214 roadmLink.setDestTpid(link.getDestination().getDestTp().toString());
215 roadmLink.setLinkId(link.getLinkId());
216 roadmLinks.add(roadmLink);
219 if (roadmLinks.isEmpty()) {
220 LOG.warn("Topology {} does not have any Roadm-to-Roadm links.", NetworkUtils.OVERLAY_NETWORK_ID);
221 return new CalculateSpanlossBaseOutputBuilder().setResult(ResponseCodes.FAILED_RESULT).build();
223 spanLossResult = getLinkSpanloss(roadmLinks);
227 if (spanLossResult) {
228 spanLossBaseBuilder.setResult(ResponseCodes.SUCCESS_RESULT);
229 return spanLossBaseBuilder.build();
231 LOG.warn("Spanloss calculation failed");
232 spanLossBaseBuilder.setResult(ResponseCodes.FAILED_RESULT);
233 return spanLossBaseBuilder.build();
240 public CalculateSpanlossCurrentOutput calculateSpanlossCurrent(CalculateSpanlossCurrentInput input) {
241 LOG.info("calculateSpanlossCurrent Request received for all links in network model.");
242 List<Link> networkLinks = getNetworkLinks();
243 if (networkLinks.isEmpty()) {
244 LOG.warn("Failed to get links form {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
247 List<RoadmLinks> roadmLinks = new ArrayList<>();
248 for (Link link : networkLinks) {
249 Link1 roadmLinkAugmentation = link.augmentation(Link1.class);
250 if (roadmLinkAugmentation == null) {
251 LOG.debug("Missing OpenRoadm link augmentation in link {} from {} topology.",
252 link.getLinkId().getValue(), NetworkUtils.OVERLAY_NETWORK_ID);
255 if (OpenroadmLinkType.ROADMTOROADM.equals(roadmLinkAugmentation.getLinkType())) {
256 // Only calculate spanloss for Roadm-to-Roadm links
257 RoadmLinks roadmLink = new RoadmLinks();
258 roadmLink.setSrcNodeId(link.getSource().getSourceNode().toString());
259 roadmLink.setSrcTpId(link.getSource().getSourceTp().toString());
260 roadmLink.setDestNodeId(link.getDestination().getDestNode().toString());
261 roadmLink.setDestTpid(link.getDestination().getDestTp().toString());
262 roadmLinks.add(roadmLink);
266 if (roadmLinks.isEmpty()) {
267 LOG.warn("Topology {} does not have any Roadm-to-Roadm links.", NetworkUtils.OVERLAY_NETWORK_ID);
271 boolean spanLossResult = getLinkSpanloss(roadmLinks);
272 CalculateSpanlossCurrentOutputBuilder spanLossCurrentBuilder = new CalculateSpanlossCurrentOutputBuilder();
273 if (spanLossResult) {
274 spanLossCurrentBuilder.setResult(ResponseCodes.SUCCESS_RESULT);
275 return spanLossCurrentBuilder.build();
277 LOG.error("Spanloss Current calculation failed");
278 spanLossCurrentBuilder.setResult(ResponseCodes.FAILED_RESULT);
279 return spanLossCurrentBuilder.build();
284 public ServicePowerResetOutput servicePowerReset(ServicePowerResetInput input) {
289 private List<Link> getNetworkLinks() {
290 NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID));
292 InstanceIdentifier<Network1> networkIID = InstanceIdentifier.builder(Networks.class)
293 .child(Network.class, overlayTopologyKey)
294 .augmentation(Network1.class)
296 Optional<Network1> networkOptional;
297 try (ReadOnlyTransaction rtx = this.dataBroker.newReadOnlyTransaction()) {
298 //TODO change to constant from Timeouts class when it will be merged.
299 networkOptional = rtx.read(LogicalDatastoreType.CONFIGURATION, networkIID).get(Timeouts.DATASTORE_READ,
300 TimeUnit.MILLISECONDS).toJavaUtil();
302 } catch (InterruptedException | ExecutionException | TimeoutException e) {
303 LOG.warn("Read of {} topology failed", NetworkUtils.OVERLAY_NETWORK_ID);
304 return Collections.emptyList();
307 if (! networkOptional.isPresent()) {
308 LOG.warn("Network augmentation with links data is not present in {} topology.",
309 NetworkUtils.OVERLAY_NETWORK_ID);
311 return Collections.emptyList();
314 List<Link> networkLinks = networkOptional.get().getLink();
315 if ((networkLinks == null) || networkLinks.isEmpty()) {
316 LOG.warn("Links are not present in {} topology.", NetworkUtils.OVERLAY_NETWORK_ID);
317 return Collections.emptyList();
323 * This method retrieves OTS PM from current PM list by nodeId and TPId: Steps:
326 * 1. Get OTS interface name from port mapping by TPId 2. Call getPm RPC to get OTS PM
330 * @param nodeId Node-id of the NE.
331 * @param tpID Termination point Name.
332 * @param pmName PM name which need to be retrieved
333 * @return reference to OtsPmHolder
335 private OtsPmHolder getPmMeasurements(String nodeId, String tpID, String pmName) {
336 String realNodeId = getRealNodeId(nodeId);
337 Mapping mapping = portMapping.getMapping(realNodeId, tpID);
338 if (mapping == null) {
341 GetPmInput getPmInput = new GetPmInputBuilder().setNodeId(realNodeId)
342 .setResourceType(ResourceTypeEnum.Interface)
343 .setResourceIdentifier(
344 new ResourceIdentifierBuilder().setResourceName(mapping.getSupportingOts()).build())
345 .setPmNameType(PmNamesEnum.valueOf(pmName))
346 .setGranularity(PmGranularity._15min)
348 GetPmOutput otsPmOutput = getPm(getPmInput);
350 if (otsPmOutput == null) {
351 LOG.info("OTS PM not found for NodeId: {} TP Id:{} PMName:{}", realNodeId, tpID, pmName);
355 for (Measurements measurement : otsPmOutput.getMeasurements()) {
356 if (pmName.equals(measurement.getPmparameterName())) {
357 return new OtsPmHolder(pmName, Double.parseDouble(measurement.getPmparameterValue()),
358 mapping.getSupportingOts());
361 } catch (NumberFormatException e) {
362 LOG.warn("Unable to get PM for NodeId: {} TP Id:{} PMName:{}", realNodeId, tpID, pmName, e);
368 * This method Sets Spanloss on A-End and Z-End OTS interface: Steps:
371 * 1. Read existing interface details
376 * @param nodeId nodeId of NE on which spanloss need to be updated
377 * @param interfaceName OTS interface for NE on which spanloss is cacluated
378 * @param spanLoss calculated spanloss value
379 * @param direction for which spanloss is calculated.It can be either Tx or Rx
382 private boolean setSpanLoss(String nodeId, String interfaceName, BigDecimal spanLoss, String direction,
384 String realNodeId = getRealNodeId(nodeId);
385 BigDecimal initialSpanloss = new BigDecimal(0);
387 LOG.info("Setting Spanloss in device for {}, InterfaceName: {}", realNodeId, interfaceName);
388 if (mappingUtils.getOpenRoadmVersion(realNodeId)
389 .equals(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1)) {
393 Optional<Interface> interfaceObject;
394 interfaceObject = openRoadmInterfaces.getInterface(realNodeId, interfaceName);
395 if (interfaceObject.isPresent()) {
396 InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
397 .child(Interface.class, new InterfaceKey(interfaceName));
398 InterfaceBuilder interfaceBuilder = new InterfaceBuilder(interfaceObject.get());
399 OtsBuilder otsBuilder = new OtsBuilder();
400 Interface intf = interfaceObject.get();
401 if (intf.augmentation(Interface1.class) != null
402 && intf.augmentation(Interface1.class).getOts() != null) {
403 Ots ots = intf.augmentation(Interface1.class).getOts();
404 otsBuilder.setFiberType(ots.getFiberType());
405 spanLossRx = ots.getSpanLossReceive();
406 spanLossTx = ots.getSpanLossTransmit();
408 spanLossRx = new RatioDB(spanLoss);
409 spanLossTx = new RatioDB(spanLoss);
411 Interface1Builder intf1Builder = new Interface1Builder();
412 if (direction.equals("TX")) {
413 otsBuilder.setSpanLossTransmit(new RatioDB(spanLoss));
414 otsBuilder.setSpanLossReceive(spanLossRx);
416 otsBuilder.setSpanLossTransmit(spanLossTx).setSpanLossReceive(new RatioDB(spanLoss));
418 interfaceBuilder.addAugmentation(Interface1.class, intf1Builder.setOts(otsBuilder.build()).build());
419 openRoadmInterfaces.postInterface(realNodeId,interfaceBuilder);
420 LOG.info("Spanloss Value update completed successfully");
423 LOG.error("Interface not found for nodeId: {} and interfaceName: {}",
424 nodeId,interfaceName);
427 } else if (mappingUtils.getOpenRoadmVersion(realNodeId)
428 .equals(StringConstants.OPENROADM_DEVICE_VERSION_2_2_1)) {
430 org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.RatioDB spanLossRx;
431 org.opendaylight.yang.gen.v1.http.org.openroadm.common.types
432 .rev181019.RatioDB spanLossTx;
433 Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
434 .interfaces.grp.Interface> interfaceObject =
435 openRoadmInterfaces.getInterface(nodeId, interfaceName);
436 if (interfaceObject.isPresent()) {
437 InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
438 .interfaces.grp.Interface> interfacesIID =
439 InstanceIdentifier.create(org.opendaylight.yang.gen.v1.http.org.openroadm
440 .device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice.class)
441 .child(org.opendaylight.yang.gen.v1.http.org.openroadm
442 .device.rev181019.interfaces.grp.Interface.class, new org.opendaylight.yang.gen
443 .v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey(interfaceName));
444 org.opendaylight.yang.gen.v1.http.org.openroadm.device
445 .rev181019.interfaces.grp.InterfaceBuilder interfaceBuilder =
446 new org.opendaylight.yang.gen.v1.http.org.openroadm.device
447 .rev181019.interfaces.grp.InterfaceBuilder(interfaceObject.get());
448 org.opendaylight.yang.gen.v1.http.org.openroadm.optical
449 .transport.interfaces.rev181019.ots.container.OtsBuilder otsBuilder =
450 new org.opendaylight.yang.gen.v1.http.org.openroadm
451 .optical.transport.interfaces.rev181019.ots.container.OtsBuilder();
452 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface intf =
453 interfaceObject.get();
454 if (intf.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.optical
455 .transport.interfaces.rev181019.Interface1.class) != null
456 && intf.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport
457 .interfaces.rev181019.Interface1.class).getOts() != null) {
458 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
459 .rev181019.ots.container.Ots ots =
460 intf.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.optical
461 .transport.interfaces.rev181019.Interface1.class).getOts();
463 otsBuilder.setFiberType(ots.getFiberType());
464 spanLossRx = ots.getSpanLossReceive();
465 spanLossTx = ots.getSpanLossTransmit();
467 spanLossRx = new org.opendaylight.yang.gen.v1.http.org
468 .openroadm.common.types.rev181019.RatioDB(spanLoss);
469 spanLossTx = new org.opendaylight.yang.gen.v1.http.org
470 .openroadm.common.types.rev181019.RatioDB(spanLoss);
472 org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
473 .rev181019.Interface1Builder intf1Builder =
474 new org.opendaylight.yang.gen.v1.http.org.openroadm.optical
475 .transport.interfaces.rev181019.Interface1Builder();
476 if (direction.equals("TX")) {
477 otsBuilder.setSpanLossTransmit(new org.opendaylight.yang.gen.v1.http.org
478 .openroadm.common.types.rev181019.RatioDB(spanLoss));
479 otsBuilder.setSpanLossReceive(spanLossRx);
481 otsBuilder.setSpanLossTransmit(spanLossTx).setSpanLossReceive(
482 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.RatioDB(spanLoss)
485 interfaceBuilder.addAugmentation(org.opendaylight.yang.gen.v1.http
486 .org.openroadm.optical.transport.interfaces.rev181019.Interface1.class,
487 intf1Builder.setOts(otsBuilder.build()).build());
488 openRoadmInterfaces.postInterface(realNodeId,interfaceBuilder);
489 LOG.info("Spanloss Value update completed successfully");
492 LOG.error("Interface not found for nodeId: {} and interfaceName: {}",
493 nodeId,interfaceName);
497 } catch (OpenRoadmInterfaceException e) {
498 // TODO Auto-generated catch block
500 } /**catch (InterruptedException e) {
501 // TODO Auto-generated catch block
503 } catch (ExecutionException e) {
504 // TODO Auto-generated catch block
511 * This method calculates Spanloss by TranmistPower - Receive Power Steps:
514 * 1. Read PM measurement
517 * 2. Set Spanloss value for interface
520 * reference to list of RoadmLinks
521 * @return map with list of spans with their spanloss value
523 private boolean getLinkSpanloss(List<RoadmLinks> roadmLinks) {
524 LOG.info("Executing GetLinkSpanLoss");
525 BigDecimal spanLoss = new BigDecimal(0);
527 for (int i = 0; i < roadmLinks.size(); i++) {
528 //TODO Add logic to check PM measurement for 3 times
529 OtsPmHolder srcOtsPmHoler = getPmMeasurements(roadmLinks.get(i).getSrcNodeId(),
530 roadmLinks.get(i).getSrcTpId(), "OpticalPowerOutput");
531 OtsPmHolder destOtsPmHoler = getPmMeasurements(roadmLinks.get(i).getDestNodeId(),
532 roadmLinks.get(i).getDestTpid(), "OpticalPowerInput");
533 spanLoss = new BigDecimal(srcOtsPmHoler.getOtsParameterVal() - destOtsPmHoler.getOtsParameterVal())
534 .setScale(0, RoundingMode.HALF_UP);
535 LOG.info("Spanloss Calculated as :" + spanLoss + "=" + srcOtsPmHoler.getOtsParameterVal() + "-"
536 + destOtsPmHoler.getOtsParameterVal());
537 //TODO make it 3 times in here
538 if (spanLoss.doubleValue() < 28 && spanLoss.doubleValue() > 0) {
539 if (!setSpanLoss(roadmLinks.get(i).getSrcNodeId(), srcOtsPmHoler.getOtsInterfaceName(), spanLoss,
540 "TX", roadmLinks.get(i).getLinkId())) {
541 LOG.info("Setting spanLoss failed for " + roadmLinks.get(i).getSrcNodeId());
544 if (!setSpanLoss(roadmLinks.get(i).getDestNodeId(), destOtsPmHoler.getOtsInterfaceName(), spanLoss,
545 "RX",roadmLinks.get(i).getLinkId())) {
546 LOG.info("Setting spanLoss failed for " + roadmLinks.get(i).getDestNodeId());
554 private String getRealNodeId(String mappedNodeId) {
555 KeyedInstanceIdentifier<Node, NodeKey> mappedNodeII =
556 InstanceIdentifiers.OVERLAY_NETWORK_II.child(Node.class, new NodeKey(new NodeId(mappedNodeId)));
557 com.google.common.base.Optional<Node> realNode;
558 try (ReadOnlyTransaction readOnlyTransaction = this.dataBroker.newReadOnlyTransaction()) {
559 realNode = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION, mappedNodeII).get();
560 } catch (InterruptedException | ExecutionException e) {
561 LOG.error(e.getMessage(), e);
562 throw new IllegalStateException(e);
564 if (!realNode.isPresent() || (realNode.get().getSupportingNode() == null)) {
565 throw new IllegalArgumentException(
566 String.format("Could not find node %s, or supporting node is not present", mappedNodeId));
568 List<SupportingNode> collect = realNode.get().getSupportingNode().stream()
569 .filter(node -> (node.getNetworkRef() != null)
570 && NetworkUtils.UNDERLAY_NETWORK_ID.equals(node.getNetworkRef().getValue())
571 && (node.getNodeRef() != null) && !Strings.isNullOrEmpty(node.getNodeRef().getValue()))
572 .collect(Collectors.toList());
573 if (collect.isEmpty() || (collect.size() > 1)) {
574 throw new IllegalArgumentException(String.format("Invalid support node count [%d] was found for node %s",
575 collect.size(), mappedNodeId));
578 return collect.iterator().next().getNodeRef().getValue();
581 private Link getNetworkLinkById(LinkId linkId) {
582 NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID));
583 InstanceIdentifier<Link> linkIID = InstanceIdentifier.builder(Networks.class)
584 .child(Network.class, overlayTopologyKey)
585 .augmentation(Network1.class).child(Link.class, new LinkKey(linkId))
587 Optional<Link> linkOptional;
588 try (ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction()) {
589 //TODO change to constant from Timeouts class when it will be merged.
590 linkOptional = rtx.read(LogicalDatastoreType.CONFIGURATION, linkIID).get(Timeouts.DATASTORE_READ,
591 TimeUnit.MILLISECONDS).toJavaUtil();
592 return linkOptional.get();
593 } catch (InterruptedException | ExecutionException | TimeoutException e) {
594 LOG.warn("Read of {} topology failed", NetworkUtils.OVERLAY_NETWORK_ID);