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

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  *  SPDX-License-Identifier: Apache-2.0
  18  *  ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.cps.utils;
  22
  23 import com.google.gson.JsonSyntaxException;
  24 import com.google.gson.stream.JsonReader;
  25 import java.io.IOException;
  26 import java.io.StringReader;
  27 import java.net.URISyntaxException;
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.Map;
  33 import javax.xml.parsers.ParserConfigurationException;
  34 import javax.xml.stream.XMLInputFactory;
  35 import javax.xml.stream.XMLStreamException;
  36 import javax.xml.stream.XMLStreamReader;
  37 import javax.xml.transform.TransformerException;
  38 import lombok.RequiredArgsConstructor;
  39 import org.onap.cps.cpspath.parser.CpsPathUtil;
  40 import org.onap.cps.cpspath.parser.PathParsingException;
  41 import org.onap.cps.spi.exceptions.DataValidationException;
  42 import org.opendaylight.yangtools.yang.common.QName;
  43 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  44 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  45 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  46 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  47 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  48 import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
  49 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  50 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
  51 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
  52 import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
  53 import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
  54 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  55 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  56 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  57 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  58 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  59 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  60 import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
  61 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  62 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
  63 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
  64 import org.springframework.stereotype.Service;
  65 import org.xml.sax.SAXException;
  66
  67 @Service
  68 @RequiredArgsConstructor
  69 public class YangParserHelper {
  70
  71     static final String DATA_ROOT_NODE_NAMESPACE = "urn:ietf:params:xml:ns:netconf:base:1.0";
  72     static final String DATA_ROOT_NODE_TAG_NAME = "data";
  73
  74     /**
  75      * Parses data into NormalizedNode according to given schema context.
  76      *
  77      * @param contentType     the type of the node data (json or xml)
  78      * @param nodeData        data string
  79      * @param schemaContext   schema context describing associated data model
  80      * @param parentNodeXpath the xpath referencing the parent node current data fragment belong to
  81      * @return the NormalizedNode object
  82      */
  83     public ContainerNode parseData(final ContentType contentType,
  84                                    final String nodeData,
  85                                    final SchemaContext schemaContext,
  86                                    final String parentNodeXpath) {
  87         if (contentType == ContentType.JSON) {
  88             return parseJsonData(nodeData, schemaContext, parentNodeXpath);
  89         }
  90         return parseXmlData(nodeData, schemaContext, parentNodeXpath);
  91     }
  92
  93     private ContainerNode parseJsonData(final String jsonData,
  94                                         final SchemaContext schemaContext,
  95                                         final String parentNodeXpath) {
  96         final JSONCodecFactory jsonCodecFactory = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
  97             .getShared((EffectiveModelContext) schemaContext);
  98         final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> dataContainerNodeBuilder =
  99                 Builders.containerBuilder()
 100                         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
 101                             QName.create(DATA_ROOT_NODE_NAMESPACE, DATA_ROOT_NODE_TAG_NAME)
 102                         ));
 103         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 104                 .from(dataContainerNodeBuilder);
 105         final JsonReader jsonReader = new JsonReader(new StringReader(jsonData));
 106         final JsonParserStream jsonParserStream;
 107
 108         if (parentNodeXpath.isEmpty()) {
 109             jsonParserStream = JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory);
 110         } else {
 111             final Collection<QName> dataSchemaNodeIdentifiers
 112                 = getDataSchemaNodeIdentifiers(schemaContext, parentNodeXpath);
 113             final EffectiveModelContext effectiveModelContext = ((EffectiveModelContext) schemaContext);
 114             final EffectiveStatementInference effectiveStatementInference =
 115                 SchemaInferenceStack.of(effectiveModelContext,
 116                     SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers)).toInference();
 117             jsonParserStream =
 118                 JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory, effectiveStatementInference);
 119         }
 120
 121         try (jsonParserStream) {
 122             jsonParserStream.parse(jsonReader);
 123         } catch (final IOException | JsonSyntaxException exception) {
 124             throw new DataValidationException(
 125                     "Failed to parse json data: " + jsonData, exception.getMessage(), exception);
 126         } catch (final IllegalStateException | IllegalArgumentException exception) {
 127             throw new DataValidationException(
 128                     "Failed to parse json data. Unsupported xpath or json data:" + jsonData, exception
 129                     .getMessage(), exception);
 130         }
 131         return dataContainerNodeBuilder.build();
 132     }
 133
 134     private ContainerNode parseXmlData(final String xmlData,
 135                                        final SchemaContext schemaContext,
 136                                        final String parentNodeXpath) {
 137         final XMLInputFactory factory = XMLInputFactory.newInstance();
 138         factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
 139         final NormalizedNodeResult normalizedNodeResult = new NormalizedNodeResult();
 140         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 141                 .from(normalizedNodeResult);
 142
 143         final EffectiveModelContext effectiveModelContext = (EffectiveModelContext) schemaContext;
 144         final XmlParserStream xmlParserStream;
 145         final String preparedXmlContent;
 146         try {
 147             if (parentNodeXpath.isEmpty()) {
 148                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, schemaContext);
 149                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveModelContext);
 150             } else {
 151                 final DataSchemaNode parentSchemaNode =
 152                     (DataSchemaNode) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
 153                         .get("dataSchemaNode");
 154                 final Collection<QName> dataSchemaNodeIdentifiers =
 155                     getDataSchemaNodeIdentifiers(schemaContext, parentNodeXpath);
 156                 final EffectiveStatementInference effectiveStatementInference =
 157                     SchemaInferenceStack.of(effectiveModelContext,
 158                         SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers)).toInference();
 159                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, parentSchemaNode, parentNodeXpath);
 160                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveStatementInference);
 161             }
 162
 163             try (xmlParserStream;
 164                  StringReader stringReader = new StringReader(preparedXmlContent)) {
 165                 final XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(stringReader);
 166                 xmlParserStream.parse(xmlStreamReader);
 167             }
 168         } catch (final XMLStreamException | URISyntaxException | IOException | SAXException | NullPointerException
 169                        | ParserConfigurationException | TransformerException exception) {
 170             throw new DataValidationException(
 171                 "Failed to parse xml data: " + xmlData, exception.getMessage(), exception);
 172         }
 173         final DataContainerChild dataContainerChild =
 174             (DataContainerChild) getFirstChildXmlRoot(normalizedNodeResult.getResult());
 175         final YangInstanceIdentifier.NodeIdentifier nodeIdentifier =
 176             new YangInstanceIdentifier.NodeIdentifier(dataContainerChild.getIdentifier().getNodeType());
 177         return Builders.containerBuilder().withChild(dataContainerChild).withNodeIdentifier(nodeIdentifier).build();
 178     }
 179
 180     private static Collection<QName> getDataSchemaNodeIdentifiers(final SchemaContext schemaContext,
 181                                                                   final String parentNodeXpath) {
 182         return (Collection<QName>) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
 183             .get("dataSchemaNodeIdentifiers");
 184     }
 185
 186     private static Map<String, Object> getDataSchemaNodeAndIdentifiersByXpath(final String parentNodeXpath,
 187                                                                               final SchemaContext schemaContext) {
 188         final String[] xpathNodeIdSequence = xpathToNodeIdSequence(parentNodeXpath);
 189         return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(xpathNodeIdSequence, schemaContext.getChildNodes(),
 190                 new ArrayList<>());
 191     }
 192
 193     private static String[] xpathToNodeIdSequence(final String xpath) {
 194         try {
 195             return CpsPathUtil.getXpathNodeIdSequence(xpath);
 196         } catch (final PathParsingException pathParsingException) {
 197             throw new DataValidationException(pathParsingException.getMessage(), pathParsingException.getDetails(),
 198                     pathParsingException);
 199         }
 200     }
 201
 202     private static Map<String, Object> findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 203             final String[] xpathNodeIdSequence,
 204             final Collection<? extends DataSchemaNode> dataSchemaNodes,
 205             final Collection<QName> dataSchemaNodeIdentifiers) {
 206         final String currentXpathNodeId = xpathNodeIdSequence[0];
 207         final DataSchemaNode currentDataSchemaNode = dataSchemaNodes.stream()
 208             .filter(dataSchemaNode -> currentXpathNodeId.equals(dataSchemaNode.getQName().getLocalName()))
 209             .findFirst().orElseThrow(() -> schemaNodeNotFoundException(currentXpathNodeId));
 210         dataSchemaNodeIdentifiers.add(currentDataSchemaNode.getQName());
 211         if (xpathNodeIdSequence.length <= 1) {
 212             final Map<String, Object> dataSchemaNodeAndIdentifiers =
 213                     new HashMap<>();
 214             dataSchemaNodeAndIdentifiers.put("dataSchemaNode", currentDataSchemaNode);
 215             dataSchemaNodeAndIdentifiers.put("dataSchemaNodeIdentifiers", dataSchemaNodeIdentifiers);
 216             return dataSchemaNodeAndIdentifiers;
 217         }
 218         if (currentDataSchemaNode instanceof DataNodeContainer) {
 219             return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 220                     getNextLevelXpathNodeIdSequence(xpathNodeIdSequence),
 221                     ((DataNodeContainer) currentDataSchemaNode).getChildNodes(),
 222                     dataSchemaNodeIdentifiers);
 223         }
 224         throw schemaNodeNotFoundException(xpathNodeIdSequence[1]);
 225     }
 226
 227     private static String[] getNextLevelXpathNodeIdSequence(final String[] xpathNodeIdSequence) {
 228         final String[] nextXpathNodeIdSequence = new String[xpathNodeIdSequence.length - 1];
 229         System.arraycopy(xpathNodeIdSequence, 1, nextXpathNodeIdSequence, 0, nextXpathNodeIdSequence.length);
 230         return nextXpathNodeIdSequence;
 231     }
 232
 233     private static DataValidationException schemaNodeNotFoundException(final String schemaNodeIdentifier) {
 234         return new DataValidationException("Invalid xpath.",
 235             String.format("No schema node was found for xpath identifier '%s'.", schemaNodeIdentifier));
 236     }
 237
 238     private static NormalizedNode getFirstChildXmlRoot(final NormalizedNode parent) {
 239         final String rootNodeType = parent.getIdentifier().getNodeType().getLocalName();
 240         final Collection<DataContainerChild> children = (Collection<DataContainerChild>) parent.body();
 241         final Iterator<DataContainerChild> iterator = children.iterator();
 242         NormalizedNode child = null;
 243         while (iterator.hasNext()) {
 244             child = iterator.next();
 245             if (!child.getIdentifier().getNodeType().getLocalName().equals(rootNodeType)
 246                     && !(child instanceof LeafNode)) {
 247                 return child;
 248             }
 249         }
 250         return getFirstChildXmlRoot(child);
 251     }
 252 }