gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2021 highstreet technologies GmbH Intellectual Property.
   6  * All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  */
  22 package org.onap.ccsdk.features.sdnr.wt.devicemanager.oran.dataprovider;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.List;
  27 import java.util.Objects;
  28 import java.util.Optional;
  29 import org.eclipse.jdt.annotation.NonNull;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.types.NetconfTimeStampImpl;
  32 import org.onap.ccsdk.features.sdnr.wt.devicemanager.oran.util.ORanDMDOMUtility;
  33 import org.onap.ccsdk.features.sdnr.wt.devicemanager.oran.util.ORanDeviceManagerQNames;
  34 import org.onap.ccsdk.features.sdnr.wt.devicemanager.oran.yangspecs.ORANFM;
  35 import org.onap.ccsdk.features.sdnr.wt.devicemanager.oran.yangspecs.OnapSystem;
  36 import org.opendaylight.mdsal.dom.api.DOMNotification;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.FaultlogBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.FaultlogEntity;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.Guicutthrough;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.GuicutthroughBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.Inventory;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.InventoryBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.SeverityType;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.SourceType;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  47 import org.opendaylight.yangtools.yang.binding.CodeHelpers;
  48 import org.opendaylight.yangtools.yang.common.Uint32;
  49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  50 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  51 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  52 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  53 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  54 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 public class ORanDOMToInternalDataModel {
  59
  60     private static final Logger LOG = LoggerFactory.getLogger(ORanDOMToInternalDataModel.class);
  61
  62     public static List<Inventory> getInventoryList(NodeId nodeId, NormalizedNode hwData) {
  63
  64         List<Inventory> inventoryResultList = new ArrayList<Inventory>();
  65         ContainerNode hwContainer = (ContainerNode) hwData;
  66         MapNode componentMap =
  67                 (MapNode) hwContainer.getChildByArg(new NodeIdentifier(ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST));
  68         Collection<MapEntryNode> componentMapEntries = componentMap.body();
  69
  70         for (MapEntryNode componentMapEntryNode : getRootComponents(componentMapEntries)) {
  71             inventoryResultList =
  72                     recurseGetInventory(nodeId, componentMapEntryNode, componentMapEntries, 0, inventoryResultList);
  73         }
  74         // Verify if result is complete
  75         if (componentMapEntries.size() != inventoryResultList.size()) {
  76             LOG.warn(
  77                     "Not all data were written to the Inventory. Potential entries with missing "
  78                             + "contained-child. Node Id = {}, Components Found = {}, Entries written to Database = {}",
  79                     nodeId.getValue(), componentMapEntries.size(), inventoryResultList.size());
  80         }
  81         return inventoryResultList;
  82     }
  83
  84     private static List<Inventory> recurseGetInventory(NodeId nodeId, MapEntryNode component,
  85             Collection<MapEntryNode> componentList, int treeLevel, List<Inventory> inventoryResultList) {
  86         //Add element to list, if conversion successfull
  87         Optional<Inventory> oInventory = getInternalEquipment(nodeId, component, treeLevel);
  88         if (oInventory.isPresent()) {
  89             inventoryResultList.add(oInventory.get());
  90         }
  91         //Walk through list of child keys and add to list
  92         for (String childUuid : CodeHelpers.nonnull(new ArrayList<>(ORanDMDOMUtility.getLeafListValue(component,
  93                 ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_CONTAINS_CHILD)))) {
  94             for (MapEntryNode c : getComponentsByName(childUuid, componentList)) {
  95                 inventoryResultList = recurseGetInventory(nodeId, c, componentList, treeLevel + 1, inventoryResultList);
  96             }
  97         }
  98         return inventoryResultList;
  99     }
 100
 101     public static List<MapEntryNode> getRootComponents(Collection<MapEntryNode> componentMapEntries) {
 102         List<MapEntryNode> resultList = new ArrayList<>();
 103         for (MapEntryNode componentMapEntryNode : componentMapEntries) {
 104             if (ORanDMDOMUtility.getLeafValue(componentMapEntryNode,
 105                     ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_PARENT) == null) { // Root elements do not have a parent
 106                 resultList.add(componentMapEntryNode);
 107             }
 108         }
 109         return resultList;
 110     }
 111
 112     private static List<MapEntryNode> getComponentsByName(String name, Collection<MapEntryNode> componentList) {
 113         List<MapEntryNode> resultList = new ArrayList<>();
 114         for (MapEntryNode c : componentList) {
 115             if (name.equals(ORanDMDOMUtility.getKeyValue(c))) { // <-- Component list is flat search for child's of name
 116                 resultList.add(c);
 117             }
 118         }
 119         return resultList;
 120     }
 121
 122     public static Optional<Inventory> getInternalEquipment(NodeId nodeId, MapEntryNode component, int treeLevel) {
 123
 124         // Make sure that expected data are not null
 125         Objects.requireNonNull(nodeId);
 126         Objects.requireNonNull(component);
 127
 128         // Read mandatory data
 129
 130         @Nullable
 131         String nodeIdString = nodeId.getValue();
 132         @Nullable
 133         String uuid = ORanDMDOMUtility.getKeyValue(component);
 134         @Nullable
 135         String idParent =
 136                 ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_PARENT);
 137         @Nullable
 138         String uuidParent = idParent != null ? idParent : uuid; //<- Passt nicht
 139
 140         // do consistency check if all mandatory parameters are there
 141         if (treeLevel >= 0 && nodeIdString != null && uuid != null && uuidParent != null) {
 142             // Build output data
 143
 144             InventoryBuilder inventoryBuilder = new InventoryBuilder();
 145
 146             // General assumed as mandatory
 147             inventoryBuilder.setNodeId(nodeIdString);
 148             inventoryBuilder.setUuid(uuid);
 149             inventoryBuilder.setParentUuid(uuidParent);
 150             inventoryBuilder.setTreeLevel(Uint32.valueOf(treeLevel));
 151
 152             // -- String list with ids of holders (optional)
 153             inventoryBuilder.setContainedHolder(ORanDMDOMUtility.getLeafListValue(component,
 154                     ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_CONTAINS_CHILD));
 155
 156             // -- Manufacturer related things (optional)
 157             @Nullable
 158             String mfgName =
 159                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_MFG_NAME);
 160             inventoryBuilder.setManufacturerName(mfgName);
 161             inventoryBuilder.setManufacturerIdentifier(mfgName);
 162
 163             // Equipment type (optional)
 164             inventoryBuilder.setDescription(
 165                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_DESC));
 166             inventoryBuilder.setModelIdentifier(ORanDMDOMUtility.getLeafValue(component,
 167                     ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_MODEL_NAME));
 168
 169             inventoryBuilder.setPartTypeId(
 170                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_CLASS));
 171
 172             inventoryBuilder.setTypeName(ORanDMDOMUtility.getKeyValue(component));
 173             inventoryBuilder.setVersion(
 174                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_HW_REV));
 175
 176             // Equipment instance (optional)
 177             @Nullable
 178             String mfgDate =
 179                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_MFG_DATE);
 180             if (mfgDate != null) {
 181                 inventoryBuilder.setDate(mfgDate);
 182             }
 183             inventoryBuilder.setSerial(
 184                     ORanDMDOMUtility.getLeafValue(component, ORanDeviceManagerQNames.IETF_HW_COMPONENT_LIST_SER_NUM));
 185
 186             return Optional.of(inventoryBuilder.build());
 187         }
 188         return Optional.empty();
 189     }
 190
 191     /**
 192      * If system data is available convert
 193      *
 194      * @param sys
 195      * @return
 196      */
 197     public static Optional<Guicutthrough> getGuicutthrough(@Nullable ContainerNode sysData,
 198             @NonNull OnapSystem onapSys) {
 199
 200         if (sysData != null) {
 201             String name = ORanDMDOMUtility.getLeafValue(sysData, onapSys.getName());
 202             @Nullable
 203             Uri uri = new Uri(ORanDMDOMUtility.getLeafValue(sysData, onapSys.getWebUi()));
 204             if (uri.getValue() != null) {
 205                 GuicutthroughBuilder gcBuilder = new GuicutthroughBuilder();
 206                 if (name != null) {
 207                     gcBuilder.setName(name);
 208                 }
 209                 gcBuilder.setWeburi(uri.getValue());
 210                 return Optional.of(gcBuilder.build());
 211             }
 212             LOG.warn("Uri not set to invoke a Gui cut through session to the device. Please set the Uri in the device");
 213         }
 214         return Optional.empty();
 215     }
 216
 217     /**
 218      * Convert fault notification into data-provider FaultLogEntity
 219      *
 220      * @param notification with O-RAN notification
 221      * @param oranfm
 222      * @param nodeId of node to handle
 223      * @param counter to be integrated into data
 224      * @return FaultlogEntity with data
 225      */
 226     public static FaultlogEntity getFaultLog(DOMNotification notification, @NonNull ORANFM oranfm, NodeId nodeId) {
 227         ContainerNode cn = notification.getBody();
 228         FaultlogBuilder faultAlarm = new FaultlogBuilder();
 229         faultAlarm.setNodeId(nodeId.getValue());
 230         faultAlarm.setObjectId(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultSourceQName()));
 231         faultAlarm.setProblem(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultTextQName()));
 232         faultAlarm.setSeverity(getSeverityType(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultSeverityQName()),
 233                 ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultIsClearedQName()).equals("true")));
 234         faultAlarm.setCounter(Integer.parseInt(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultIdQName())));
 235         faultAlarm.setId(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultIdQName()));
 236         faultAlarm.setSourceType(SourceType.Netconf);
 237         faultAlarm.setTimestamp(NetconfTimeStampImpl.getConverter()
 238                 .getTimeStamp(ORanDMDOMUtility.getLeafValue(cn, oranfm.getFaultEventTimeQName())));
 239         return faultAlarm.build();
 240     }
 241
 242     public static FaultlogEntity getFaultLog(UnkeyedListEntryNode activeAlarmEntry, ORANFM oranfm, NodeId nodeId) {
 243         FaultlogBuilder faultAlarm = new FaultlogBuilder();
 244         faultAlarm.setNodeId(nodeId.getValue());
 245         faultAlarm.setObjectId(ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultSourceQName()));
 246         faultAlarm.setProblem(ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultTextQName()));
 247         faultAlarm.setSeverity(getSeverityType(
 248                 ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultSeverityQName()),
 249                 ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultIsClearedQName()).equals("true")));
 250         faultAlarm.setCounter(
 251                 Integer.parseInt(ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultIdQName())));
 252         faultAlarm.setId(ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultIdQName()));
 253         faultAlarm.setSourceType(SourceType.Netconf);
 254         faultAlarm.setTimestamp(NetconfTimeStampImpl.getConverter()
 255                 .getTimeStamp(ORanDMDOMUtility.getLeafValue(activeAlarmEntry, oranfm.getFaultEventTimeQName())));
 256         return faultAlarm.build();
 257     }
 258
 259     /**
 260      * Convert O-RAN specific severity into data-provider severity
 261      *
 262      * @param faultSeverity O-RAN severity
 263      * @param isCleared clear indicator
 264      * @return data-provider severity type
 265      * @throws IllegalArgumentException if conversion not possible.
 266      */
 267     private static SeverityType getSeverityType(@Nullable String faultSeverity, @Nullable Boolean isCleared)
 268             throws IllegalArgumentException {
 269         if (isCleared != null && isCleared) {
 270             return SeverityType.NonAlarmed;
 271         }
 272         if (faultSeverity != null) {
 273             switch (faultSeverity) {
 274                 case "CRITICAL":
 275                     return SeverityType.Critical;
 276                 case "MAJOR":
 277                     return SeverityType.Major;
 278                 case "MINOR":
 279                     return SeverityType.Minor;
 280                 case "WARNING":
 281                     return SeverityType.Warning;
 282             }
 283         }
 284         throw new IllegalArgumentException("Unknown Alarm state represent as Critical. isCleared=" + isCleared
 285                 + " faultSeverity=" + faultSeverity);
 286     }
 287
 288 }