cps-service/src/main/java/org/onap/cps/utils/YangUtils.java

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020-2023 Nordix Foundation
   4  *  Modifications Copyright (C) 2021 Bell Canada.
   5  *  Modifications Copyright (C) 2021 Pantheon.tech
   6  *  Modifications Copyright (C) 2022 TechMahindra Ltd.
   7  *  Modifications Copyright (C) 2022 Deutsche Telekom AG
   8  *  ================================================================================
   9  *  Licensed under the Apache License, Version 2.0 (the "License");
  10  *  you may not use this file except in compliance with the License.
  11  *  You may obtain a copy of the License at
  12  *
  13  *        http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  *  Unless required by applicable law or agreed to in writing, software
  16  *  distributed under the License is distributed on an "AS IS" BASIS,
  17  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  *  See the License for the specific language governing permissions and
  19  *  limitations under the License.
  20  *
  21  *  SPDX-License-Identifier: Apache-2.0
  22  *  ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.cps.utils;
  26
  27 import com.google.gson.JsonSyntaxException;
  28 import com.google.gson.stream.JsonReader;
  29 import java.io.IOException;
  30 import java.io.StringReader;
  31 import java.net.URISyntaxException;
  32 import java.util.ArrayList;
  33 import java.util.Collection;
  34 import java.util.Collections;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Optional;
  40 import java.util.stream.Collectors;
  41 import javax.xml.parsers.ParserConfigurationException;
  42 import javax.xml.stream.XMLInputFactory;
  43 import javax.xml.stream.XMLStreamException;
  44 import javax.xml.stream.XMLStreamReader;
  45 import javax.xml.transform.TransformerException;
  46 import lombok.AccessLevel;
  47 import lombok.NoArgsConstructor;
  48 import lombok.extern.slf4j.Slf4j;
  49 import org.onap.cps.cpspath.parser.CpsPathUtil;
  50 import org.onap.cps.cpspath.parser.PathParsingException;
  51 import org.onap.cps.spi.exceptions.DataValidationException;
  52 import org.opendaylight.yangtools.yang.common.QName;
  53 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  54 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  55 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  56 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  57 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  58 import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
  59 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  60 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
  61 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
  62 import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
  63 import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
  64 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  65 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  66 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  67 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  68 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  69 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  70 import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
  71 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  72 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  73 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
  74 import org.xml.sax.SAXException;
  75
  76 @Slf4j
  77 @NoArgsConstructor(access = AccessLevel.PRIVATE)
  78 public class YangUtils {
  79
  80     public static final String DATA_ROOT_NODE_NAMESPACE = "urn:ietf:params:xml:ns:netconf:base:1.0";
  81     public static final String DATA_ROOT_NODE_TAG_NAME = "data";
  82
  83     /**
  84      * Parses data into Collection of NormalizedNode according to given schema context.
  85      *
  86      * @param nodeData      data string
  87      * @param schemaContext schema context describing associated data model
  88      * @return the NormalizedNode object
  89      */
  90     static ContainerNode parseData(final ContentType contentType,
  91                                           final String nodeData,
  92                                           final SchemaContext schemaContext) {
  93         if (contentType == ContentType.JSON) {
  94             return parseJsonDataWithOptionalParent(nodeData, schemaContext, Optional.empty());
  95         }
  96         return parseXmlDataWithOptionalParent(nodeData, schemaContext, Optional.empty());
  97     }
  98
  99     /**
 100      * Parses data into NormalizedNode according to given schema context.
 101      *
 102      * @param nodeData      data string
 103      * @param schemaContext schema context describing associated data model
 104      * @return the NormalizedNode object
 105      */
 106     static ContainerNode parseData(final ContentType contentType,
 107                                           final String nodeData,
 108                                           final SchemaContext schemaContext,
 109                                           final String parentNodeXpath) {
 110         if (contentType == ContentType.JSON) {
 111             return parseJsonDataWithOptionalParent(nodeData, schemaContext, Optional.of(parentNodeXpath));
 112         }
 113         return parseXmlDataWithOptionalParent(nodeData, schemaContext, Optional.of(parentNodeXpath));
 114     }
 115
 116     /**
 117      * Parses data into Collection of NormalizedNode according to given schema context.
 118      *
 119      * @param jsonData      json data as string
 120      * @param schemaContext schema context describing associated data model
 121      * @return the Collection of NormalizedNode object
 122      */
 123     public static ContainerNode parseJsonData(final String jsonData, final SchemaContext schemaContext) {
 124         return parseJsonDataWithOptionalParent(jsonData, schemaContext, Optional.empty());
 125     }
 126
 127     /**
 128      * Parses jsonData into Collection of NormalizedNode according to given schema context.
 129      *
 130      * @param jsonData        json data fragment as string
 131      * @param schemaContext   schema context describing associated data model
 132      * @param parentNodeXpath the xpath referencing the parent node current data fragment belong to
 133      * @return the NormalizedNode object
 134      */
 135     public static ContainerNode parseJsonData(final String jsonData,
 136                                               final SchemaContext schemaContext,
 137                                               final String parentNodeXpath) {
 138         return parseJsonDataWithOptionalParent(jsonData, schemaContext, Optional.of(parentNodeXpath));
 139     }
 140
 141     /**
 142      * Create an xpath form a Yang Tools NodeIdentifier (i.e. PathArgument).
 143      *
 144      * @param nodeIdentifier the NodeIdentifier
 145      * @return a xpath
 146      */
 147     public static String buildXpath(final YangInstanceIdentifier.PathArgument nodeIdentifier) {
 148         final StringBuilder xpathBuilder = new StringBuilder();
 149         xpathBuilder.append("/").append(nodeIdentifier.getNodeType().getLocalName());
 150
 151         if (nodeIdentifier instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
 152             xpathBuilder.append(getKeyAttributesStatement(
 153                 (YangInstanceIdentifier.NodeIdentifierWithPredicates) nodeIdentifier));
 154         }
 155         return xpathBuilder.toString();
 156     }
 157
 158     private static ContainerNode parseJsonDataWithOptionalParent(final String jsonData,
 159                                                                  final SchemaContext schemaContext,
 160                                                                  final Optional<String> parentNodeXpath) {
 161         final JSONCodecFactory jsonCodecFactory = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
 162             .getShared((EffectiveModelContext) schemaContext);
 163         final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> dataContainerNodeBuilder =
 164                 Builders.containerBuilder()
 165                         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
 166                             QName.create(DATA_ROOT_NODE_NAMESPACE, DATA_ROOT_NODE_TAG_NAME)
 167                         ));
 168         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 169                 .from(dataContainerNodeBuilder);
 170         final JsonReader jsonReader = new JsonReader(new StringReader(jsonData));
 171         final JsonParserStream jsonParserStream;
 172
 173         if (parentNodeXpath.isPresent()) {
 174             final Collection<QName> dataSchemaNodeIdentifiers
 175                 = getDataSchemaNodeIdentifiers(schemaContext, parentNodeXpath.get());
 176             final EffectiveModelContext effectiveModelContext = ((EffectiveModelContext) schemaContext);
 177             final EffectiveStatementInference effectiveStatementInference =
 178                     SchemaInferenceStack.of(effectiveModelContext,
 179                             SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers)).toInference();
 180             jsonParserStream =
 181                     JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory, effectiveStatementInference);
 182         } else {
 183             jsonParserStream = JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory);
 184         }
 185
 186         try (jsonParserStream) {
 187             jsonParserStream.parse(jsonReader);
 188         } catch (final IOException | JsonSyntaxException exception) {
 189             throw new DataValidationException(
 190                     "Failed to parse json data: " + jsonData, exception.getMessage(), exception);
 191         } catch (final IllegalStateException | IllegalArgumentException exception) {
 192             throw new DataValidationException(
 193                     "Failed to parse json data. Unsupported xpath or json data:" + jsonData, exception
 194                     .getMessage(), exception);
 195         }
 196         return dataContainerNodeBuilder.build();
 197     }
 198
 199     private static ContainerNode parseXmlDataWithOptionalParent(final String xmlData,
 200                                                                 final SchemaContext schemaContext,
 201                                                                 final Optional<String> parentNodeXpath) {
 202         final XMLInputFactory factory = XMLInputFactory.newInstance();
 203         factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
 204         final NormalizedNodeResult normalizedNodeResult = new NormalizedNodeResult();
 205         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 206                 .from(normalizedNodeResult);
 207
 208         final EffectiveModelContext effectiveModelContext = (EffectiveModelContext) schemaContext;
 209         final XmlParserStream xmlParserStream;
 210         final String preparedXmlContent;
 211         try {
 212             if (parentNodeXpath.isPresent()) {
 213                 final DataSchemaNode parentSchemaNode =
 214                     (DataSchemaNode) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath.get(), schemaContext)
 215                         .get("dataSchemaNode");
 216                 final Collection<QName> dataSchemaNodeIdentifiers =
 217                     getDataSchemaNodeIdentifiers(schemaContext, parentNodeXpath.get());
 218                 final EffectiveStatementInference effectiveStatementInference =
 219                     SchemaInferenceStack.of(effectiveModelContext,
 220                         SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers)).toInference();
 221                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, parentSchemaNode, parentNodeXpath.get());
 222                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveStatementInference);
 223             } else {
 224                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, schemaContext);
 225                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveModelContext);
 226             }
 227
 228             try (xmlParserStream;
 229                  StringReader stringReader = new StringReader(preparedXmlContent)) {
 230                 final XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(stringReader);
 231                 xmlParserStream.parse(xmlStreamReader);
 232             }
 233         } catch (final XMLStreamException | URISyntaxException | IOException | SAXException | NullPointerException
 234                        | ParserConfigurationException | TransformerException exception) {
 235             throw new DataValidationException(
 236                 "Failed to parse xml data: " + xmlData, exception.getMessage(), exception);
 237         }
 238         final DataContainerChild dataContainerChild =
 239             (DataContainerChild) getFirstChildXmlRoot(normalizedNodeResult.getResult());
 240         final YangInstanceIdentifier.NodeIdentifier nodeIdentifier =
 241             new YangInstanceIdentifier.NodeIdentifier(dataContainerChild.getIdentifier().getNodeType());
 242         return Builders.containerBuilder().withChild(dataContainerChild).withNodeIdentifier(nodeIdentifier).build();
 243     }
 244
 245     private static Collection<QName> getDataSchemaNodeIdentifiers(final SchemaContext schemaContext,
 246                                                                   final String parentNodeXpath) {
 247         return (Collection<QName>) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
 248             .get("dataSchemaNodeIdentifiers");
 249     }
 250
 251     private static String getKeyAttributesStatement(
 252             final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier) {
 253         final List<String> keyAttributes = nodeIdentifier.entrySet().stream().map(
 254                 entry -> {
 255                     final String name = entry.getKey().getLocalName();
 256                     final String value = String.valueOf(entry.getValue()).replace("'", "''");
 257                     return String.format("@%s='%s'", name, value);
 258                 }
 259         ).collect(Collectors.toList());
 260
 261         if (keyAttributes.isEmpty()) {
 262             return "";
 263         } else {
 264             Collections.sort(keyAttributes);
 265             return "[" + String.join(" and ", keyAttributes) + "]";
 266         }
 267     }
 268
 269     private static Map<String, Object> getDataSchemaNodeAndIdentifiersByXpath(final String parentNodeXpath,
 270                                                                               final SchemaContext schemaContext) {
 271         final String[] xpathNodeIdSequence = xpathToNodeIdSequence(parentNodeXpath);
 272         return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(xpathNodeIdSequence, schemaContext.getChildNodes(),
 273                 new ArrayList<>());
 274     }
 275
 276     private static String[] xpathToNodeIdSequence(final String xpath) {
 277         try {
 278             return CpsPathUtil.getXpathNodeIdSequence(xpath);
 279         } catch (final PathParsingException pathParsingException) {
 280             throw new DataValidationException(pathParsingException.getMessage(), pathParsingException.getDetails(),
 281                     pathParsingException);
 282         }
 283     }
 284
 285     private static Map<String, Object> findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 286             final String[] xpathNodeIdSequence,
 287             final Collection<? extends DataSchemaNode> dataSchemaNodes,
 288             final Collection<QName> dataSchemaNodeIdentifiers) {
 289         final String currentXpathNodeId = xpathNodeIdSequence[0];
 290         final DataSchemaNode currentDataSchemaNode = dataSchemaNodes.stream()
 291             .filter(dataSchemaNode -> currentXpathNodeId.equals(dataSchemaNode.getQName().getLocalName()))
 292             .findFirst().orElseThrow(() -> schemaNodeNotFoundException(currentXpathNodeId));
 293         dataSchemaNodeIdentifiers.add(currentDataSchemaNode.getQName());
 294         if (xpathNodeIdSequence.length <= 1) {
 295             final Map<String, Object> dataSchemaNodeAndIdentifiers =
 296                     new HashMap<>();
 297             dataSchemaNodeAndIdentifiers.put("dataSchemaNode", currentDataSchemaNode);
 298             dataSchemaNodeAndIdentifiers.put("dataSchemaNodeIdentifiers", dataSchemaNodeIdentifiers);
 299             return dataSchemaNodeAndIdentifiers;
 300         }
 301         if (currentDataSchemaNode instanceof DataNodeContainer) {
 302             return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 303                     getNextLevelXpathNodeIdSequence(xpathNodeIdSequence),
 304                     ((DataNodeContainer) currentDataSchemaNode).getChildNodes(),
 305                     dataSchemaNodeIdentifiers);
 306         }
 307         throw schemaNodeNotFoundException(xpathNodeIdSequence[1]);
 308     }
 309
 310     private static String[] getNextLevelXpathNodeIdSequence(final String[] xpathNodeIdSequence) {
 311         final String[] nextXpathNodeIdSequence = new String[xpathNodeIdSequence.length - 1];
 312         System.arraycopy(xpathNodeIdSequence, 1, nextXpathNodeIdSequence, 0, nextXpathNodeIdSequence.length);
 313         return nextXpathNodeIdSequence;
 314     }
 315
 316     private static DataValidationException schemaNodeNotFoundException(final String schemaNodeIdentifier) {
 317         return new DataValidationException("Invalid xpath.",
 318             String.format("No schema node was found for xpath identifier '%s'.", schemaNodeIdentifier));
 319     }
 320
 321     private static NormalizedNode getFirstChildXmlRoot(final NormalizedNode parent) {
 322         final String rootNodeType = parent.getIdentifier().getNodeType().getLocalName();
 323         final Collection<DataContainerChild> children = (Collection<DataContainerChild>) parent.body();
 324         final Iterator<DataContainerChild> iterator = children.iterator();
 325         NormalizedNode child = null;
 326         while (iterator.hasNext()) {
 327             child = iterator.next();
 328             if (!child.getIdentifier().getNodeType().getLocalName().equals(rootNodeType)
 329                     && !(child instanceof LeafNode)) {
 330                 return child;
 331             }
 332         }
 333         return getFirstChildXmlRoot(child);
 334     }
 335 }