olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils121.java

   1 /*
   2  * Copyright © 2017 AT&T and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.olm.util;
   9
  10 import com.google.common.base.Strings;
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Optional;
  14 import java.util.stream.Collectors;
  15 import java.util.stream.Stream;
  16 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  17 import org.opendaylight.transportpce.common.Timeouts;
  18 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  19 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
  20 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.MeasurementsBuilder;
  22 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.CurrentPmlist;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.Measurements;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.currentpmlist.CurrentPm;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmNamesEnum;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.Resource;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.CircuitPack;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Connection;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Degree;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Interface;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.InternalLink;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.PhysicalLink;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Port;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Service;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Shelf;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.Srg;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
  39 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.olm.get.pm.input.ResourceIdentifier;
  40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 final class OlmUtils121 {
  45
  46     private static final Logger LOG = LoggerFactory.getLogger(OlmUtils121.class);
  47
  48     /**
  49      * This method retrieves list of current PMs for given nodeId,
  50      * resourceType, resourceName and Granularity.Currently vendorExtentions
  51      * are excluded but can be added back based on requirement
  52      *
  53      * <p>
  54      * 1. pmFetch This operation traverse through current PM list and gets PM for
  55      * given NodeId and Resource name
  56      *
  57      * @param input
  58      *            Input parameter from the olm yang model get-pm rpc
  59      * @param deviceTransactionManager
  60      *            Device tx manager
  61      *
  62      * @return Result of the request list of PM readings
  63      */
  64     public static GetPmOutputBuilder pmFetch(GetPmInput input, DeviceTransactionManager deviceTransactionManager) {
  65         LOG.info("Getting PM Data for 1.2.1 NodeId: {} ResourceType: {} ResourceName: {}", input.getNodeId(),
  66                 input.getResourceType(), input.getResourceIdentifier());
  67         GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder();
  68         InstanceIdentifier<CurrentPmlist> currentPmsIID = InstanceIdentifier.create(CurrentPmlist.class);
  69         Optional<CurrentPmlist> currentPmList;
  70         currentPmList = deviceTransactionManager
  71                 .getDataFromDevice(input.getNodeId(), LogicalDatastoreType.OPERATIONAL, currentPmsIID,
  72                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  73         if (currentPmList.isPresent()) {
  74             String pmExtension = null;
  75             org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Location location = null;
  76             org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Direction direction = null;
  77             if (input.getPmExtension() != null) {
  78                 pmExtension = input.getPmExtension();
  79             }
  80             if (input.getLocation() != null) {
  81                 location = input.getLocation();
  82             }
  83             if (input.getDirection() != null) {
  84                 direction = input.getDirection();
  85             }
  86             PmNamesEnum pmName = null;
  87             List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm
  88                 .rev170418.get.pm.output.Measurements>
  89                 measurements = extractWantedMeasurements(currentPmList.get(),
  90                 ResourceTypeEnum.forValue(input.getResourceType().getIntValue()),
  91                 input.getResourceIdentifier(),
  92                 PmGranularity.forValue(input.getGranularity().getIntValue()),
  93                 pmName, pmExtension, location, direction);
  94             if (measurements.isEmpty()) {
  95                 LOG.error("No Matching PM data found for node: {}, resource type: {}, resource name: {}",
  96                         input.getNodeId(), input.getResourceType(),
  97                         getResourceIdentifierAsString(input.getResourceIdentifier()));
  98             } else {
  99                 pmOutputBuilder.setNodeId(input.getNodeId()).setResourceType(input.getResourceType())
 100                         .setResourceIdentifier(input.getResourceIdentifier()).setGranularity(input.getGranularity())
 101                         .setMeasurements(measurements);
 102                 LOG.info("PM Data found successfully for node: {}, resource type: {}, resource name {}",
 103                         input.getNodeId(), input.getResourceType(),
 104                         getResourceIdentifierAsString(input.getResourceIdentifier()));
 105             }
 106
 107         } else {
 108             LOG.info("Device PM Data for node: {} is not available", input.getNodeId());
 109         }
 110
 111         return pmOutputBuilder;
 112     }
 113
 114     private static String getResourceIdentifierAsString(ResourceIdentifier resourceIdentifier) {
 115         if (Strings.isNullOrEmpty(resourceIdentifier.getCircuitPackName())) {
 116             return resourceIdentifier.getResourceName();
 117         } else {
 118             return resourceIdentifier.getResourceName() + ", circuit pack name: "
 119                     + resourceIdentifier.getCircuitPackName();
 120         }
 121     }
 122
 123     private static
 124         List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements>
 125             extractWantedMeasurements(CurrentPmlist currentPmList, ResourceTypeEnum resourceTypeEnum,
 126             ResourceIdentifier wantedResourceIdentifier,PmGranularity pmGranularity, PmNamesEnum pmNamesEnum,
 127             String extension, org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Location
 128             location, org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Direction direction) {
 129         List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements>
 130             measurements = new ArrayList<>();
 131         for (CurrentPm pm : currentPmList.getCurrentPm()) {
 132             ResourceTypeEnum currentResourceType = pm.getResource().getResourceType().getType();
 133             if (currentResourceType.equals(resourceTypeEnum)) {
 134                 Resource currentResource = pm.getResource().getResource().getResource();
 135                 PmGranularity currentGranularity = pm.getGranularity();
 136                 boolean isWantedPowerMeasure = isWantedPowerMeasure(currentResource, currentGranularity,
 137                         resourceTypeEnum, wantedResourceIdentifier, pmGranularity);
 138                 if (isWantedPowerMeasure) {
 139                     measurements.addAll(extractMeasurements(pm.getMeasurements(),pmNamesEnum,
 140                             extension,location,direction));
 141                 }
 142             }
 143         }
 144         return measurements;
 145     }
 146
 147     private static
 148          List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements>
 149             extractMeasurements(List<Measurements> measurementsFromDevice, PmNamesEnum pmNamesEnum, String extension,
 150             org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Location location,
 151             org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.Direction direction) {
 152         List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements>
 153             extractedMeasurements = new ArrayList<>();
 154         List<Measurements> pmMeasurements = measurementsFromDevice;
 155         Stream<Measurements> measurementStream = pmMeasurements.stream();
 156         if (pmNamesEnum != null) {
 157             LOG.info("pm name is not null {} {} {}",pmNamesEnum,pmNamesEnum.getName(),pmMeasurements.get(0)
 158                 .getMeasurement().getPmParameterName().getType());
 159             measurementStream = measurementStream.filter(measure -> measure.getMeasurement().getPmParameterName()
 160                 .getType().getName().equals(pmNamesEnum.getName()));
 161         }
 162         if (extension != null) {
 163             LOG.info("extension is not null {}",extension);
 164             measurementStream = measurementStream.filter(measure -> measure.getMeasurement()
 165                     .getPmParameterName().getType().equals("vendorExtension")
 166                     && measure.getMeasurement().getPmParameterName().getExtension().equals(extension));
 167         }
 168         if (location != null) {
 169             LOG.info("location is not null {}",location);
 170             measurementStream = measurementStream.filter(measure -> measure.getMeasurement().getLocation().getName()
 171                 .equals(location.getName()));
 172         }
 173         if (direction != null) {
 174             LOG.info("direction is not null {}",direction);
 175             measurementStream = measurementStream.filter(measure -> measure.getMeasurement().getDirection().getName()
 176                 .equals(direction.getName()));
 177         }
 178         List<Measurements> filteredMeasurements = measurementStream.collect(Collectors.toList());
 179         for (Measurements measure : filteredMeasurements) {
 180             MeasurementsBuilder measurement = new MeasurementsBuilder();
 181             measurement.setPmparameterName(measure.getMeasurement().getPmParameterName().getType().toString());
 182             if (measure.getMeasurement().getPmParameterValue().getDecimal64() != null) {
 183                 measurement.setPmparameterValue(measure.getMeasurement().getPmParameterValue().getDecimal64()
 184                     .toPlainString());
 185             } else if (measure.getMeasurement().getPmParameterValue().getUint64() != null) {
 186                 measurement.setPmparameterValue(measure.getMeasurement().getPmParameterValue().getUint64().toString());
 187             }
 188             extractedMeasurements.add(measurement.build());
 189         }
 190         return extractedMeasurements;
 191     }
 192
 193     private static boolean isWantedPowerMeasure(Resource resource, PmGranularity granularity,
 194             ResourceTypeEnum resourceTypeEnum, ResourceIdentifier wantedResourceIdentifier,
 195             PmGranularity pmGranularity) {
 196         boolean identifiersAreEqual = compareResourceIdentifiers(resource, resourceTypeEnum,
 197                 wantedResourceIdentifier);
 198         return identifiersAreEqual && granularity != null && granularity.equals(pmGranularity);
 199     }
 200
 201     private static boolean compareResourceIdentifiers(Resource resource, ResourceTypeEnum resourceTypeEnum,
 202             ResourceIdentifier wantedResourceIdentifier) {
 203         switch (resourceTypeEnum) {
 204             case CircuitPack:
 205                 Optional<CircuitPack> circuitPackOptional = tryCastToParticularResource(CircuitPack.class, resource);
 206                 return circuitPackOptional.flatMap(
 207                     circuitPack -> Optional.ofNullable(circuitPack.getCircuitPackName()))
 208                         .map(circuitPackName -> circuitPackName.equals(wantedResourceIdentifier.getResourceName()))
 209                         .orElse(false);
 210             case Connection:
 211                 Optional<Connection> connectionOptional = tryCastToParticularResource(Connection.class, resource);
 212                 return connectionOptional.flatMap(
 213                     connection -> Optional.ofNullable(connection.getConnectionNumber()))
 214                         .map(connectionNumber -> connectionNumber.equals(wantedResourceIdentifier.getResourceName()))
 215                         .orElse(false);
 216             case Degree:
 217                 Optional<Degree> degreeOptional = tryCastToParticularResource(Degree.class, resource);
 218                 return degreeOptional.flatMap(
 219                     degree -> Optional.ofNullable(degree.getDegreeNumber()))
 220                         .flatMap(degreeInteger -> Optional.of(degreeInteger.toString()))
 221                         .map(degreeNumberAsString ->
 222                                 degreeNumberAsString.equals(wantedResourceIdentifier.getResourceName()))
 223                         .orElse(false);
 224             case Interface:
 225                 Optional<Interface> interfaceOptional = tryCastToParticularResource(Interface.class, resource);
 226                 return interfaceOptional.flatMap(
 227                     interfaceResource -> Optional.ofNullable(interfaceResource.getInterfaceName()))
 228                         .map(interfaceName -> interfaceName.equals(wantedResourceIdentifier.getResourceName()))
 229                         .orElse(false);
 230             case InternalLink:
 231                 Optional<InternalLink> internalLinkOptional = tryCastToParticularResource(InternalLink.class, resource);
 232                 return internalLinkOptional.flatMap(
 233                     internalLink -> Optional.ofNullable(internalLink.getInternalLinkName()))
 234                         .map(internalLinkName -> internalLinkName.equals(wantedResourceIdentifier.getResourceName()))
 235                         .orElse(false);
 236             case PhysicalLink:
 237                 Optional<PhysicalLink> physicalLinkOptional = tryCastToParticularResource(PhysicalLink.class, resource);
 238                 return physicalLinkOptional.flatMap(
 239                     physicalLink -> Optional.ofNullable(physicalLink.getPhysicalLinkName()))
 240                         .map(physicalLinkName -> physicalLinkName.equals(wantedResourceIdentifier.getResourceName()))
 241                         .orElse(false);
 242             case Service:
 243                 Optional<Service> serviceOptional = tryCastToParticularResource(Service.class, resource);
 244                 return serviceOptional.flatMap(
 245                     service -> Optional.ofNullable(service.getServiceName()))
 246                         .map(serviceName -> serviceName.equals(wantedResourceIdentifier.getResourceName()))
 247                     .orElse(false);
 248             case Shelf:
 249                 Optional<Shelf> shelfOptional = tryCastToParticularResource(Shelf.class, resource);
 250                 return shelfOptional.flatMap(
 251                     shelf -> Optional.ofNullable(shelf.getShelfName()))
 252                         .map(shelfName -> shelfName.equals(wantedResourceIdentifier.getResourceName()))
 253                         .orElse(false);
 254             case SharedRiskGroup:
 255                 Optional<Srg> sharedRiskGroupOptional = tryCastToParticularResource(Srg.class, resource);
 256                 return sharedRiskGroupOptional.flatMap(
 257                     sharedRiskGroup -> Optional.ofNullable(sharedRiskGroup.getSrgNumber()))
 258                         .flatMap(sharedRiskGroupNumberInteger -> Optional.of(sharedRiskGroupNumberInteger.toString()))
 259                         .map(srgNumberAsString -> srgNumberAsString.equals(wantedResourceIdentifier.getResourceName()))
 260                         .orElse(false);
 261             case Port:
 262                 Optional<Port> portContainerOptional = tryCastToParticularResource(Port.class, resource);
 263                 return portContainerOptional.flatMap(
 264                     portContainer -> Optional.ofNullable(portContainer.getPort()))
 265                         .map(port -> {
 266                             String portName = port.getPortName();
 267                             String circuitPackName = port.getCircuitPackName();
 268                             return portName != null && circuitPackName != null
 269                                     && portName.equals(wantedResourceIdentifier.getResourceName())
 270                                     && circuitPackName.equals(wantedResourceIdentifier.getCircuitPackName());
 271                         })
 272                         .orElse(false);
 273             default:
 274                 LOG.warn("Unknown resource type {}", resourceTypeEnum);
 275                 return false;
 276         }
 277     }
 278
 279     @SuppressWarnings("unchecked")
 280     public static <T extends Resource> Optional<T> tryCastToParticularResource(Class<T> resourceClass,
 281             Resource resource) {
 282         if (resource == null) {
 283             LOG.warn("Resource is null.");
 284         } else if (! resourceClass.isInstance(resource)) {
 285             LOG.warn("Resource implement different type than expected. Expected {}, actual {}.",
 286                     resourceClass.getSimpleName(), resource.getClass().getSimpleName());
 287         } else {
 288             return Optional.of((T) resource);
 289         }
 290         return Optional.empty();
 291     }
 292
 293     private OlmUtils121() {
 294     }
 295
 296 }