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 | IllegalStateException | IllegalArgumentException exception) {
 124             throw new DataValidationException(
 125                     "Data Validation Failed", "Failed to parse json data. " + exception.getMessage(), exception);
 126         }
 127         return dataContainerNodeBuilder.build();
 128     }
 129
 130     private ContainerNode parseXmlData(final String xmlData,
 131                                        final SchemaContext schemaContext,
 132                                        final String parentNodeXpath) {
 133         final XMLInputFactory factory = XMLInputFactory.newInstance();
 134         factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
 135         final NormalizedNodeResult normalizedNodeResult = new NormalizedNodeResult();
 136         final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
 137                 .from(normalizedNodeResult);
 138
 139         final EffectiveModelContext effectiveModelContext = (EffectiveModelContext) schemaContext;
 140         final XmlParserStream xmlParserStream;
 141         final String preparedXmlContent;
 142         try {
 143             if (parentNodeXpath.isEmpty()) {
 144                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, schemaContext);
 145                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveModelContext);
 146             } else {
 147                 final DataSchemaNode parentSchemaNode =
 148                     (DataSchemaNode) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
 149                         .get("dataSchemaNode");
 150                 final Collection<QName> dataSchemaNodeIdentifiers =
 151                     getDataSchemaNodeIdentifiers(schemaContext, parentNodeXpath);
 152                 final EffectiveStatementInference effectiveStatementInference =
 153                     SchemaInferenceStack.of(effectiveModelContext,
 154                         SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers)).toInference();
 155                 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, parentSchemaNode, parentNodeXpath);
 156                 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveStatementInference);
 157             }
 158
 159             try (xmlParserStream;
 160                  StringReader stringReader = new StringReader(preparedXmlContent)) {
 161                 final XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(stringReader);
 162                 xmlParserStream.parse(xmlStreamReader);
 163             }
 164         } catch (final XMLStreamException | URISyntaxException | IOException | SAXException | NullPointerException
 165                        | ParserConfigurationException | TransformerException exception) {
 166             throw new DataValidationException(
 167                 "Data Validation Failed", "Failed to parse xml data: " + exception.getMessage(), exception);
 168         }
 169         final DataContainerChild dataContainerChild =
 170             (DataContainerChild) getFirstChildXmlRoot(normalizedNodeResult.getResult());
 171         final YangInstanceIdentifier.NodeIdentifier nodeIdentifier =
 172             new YangInstanceIdentifier.NodeIdentifier(dataContainerChild.getIdentifier().getNodeType());
 173         return Builders.containerBuilder().withChild(dataContainerChild).withNodeIdentifier(nodeIdentifier).build();
 174     }
 175
 176     private static Collection<QName> getDataSchemaNodeIdentifiers(final SchemaContext schemaContext,
 177                                                                   final String parentNodeXpath) {
 178         return (Collection<QName>) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
 179             .get("dataSchemaNodeIdentifiers");
 180     }
 181
 182     private static Map<String, Object> getDataSchemaNodeAndIdentifiersByXpath(final String parentNodeXpath,
 183                                                                               final SchemaContext schemaContext) {
 184         final String[] xpathNodeIdSequence = xpathToNodeIdSequence(parentNodeXpath);
 185         return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(xpathNodeIdSequence, schemaContext.getChildNodes(),
 186                 new ArrayList<>());
 187     }
 188
 189     private static String[] xpathToNodeIdSequence(final String xpath) {
 190         try {
 191             return CpsPathUtil.getXpathNodeIdSequence(xpath);
 192         } catch (final PathParsingException pathParsingException) {
 193             throw new DataValidationException(pathParsingException.getMessage(), pathParsingException.getDetails(),
 194                     pathParsingException);
 195         }
 196     }
 197
 198     private static Map<String, Object> findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 199             final String[] xpathNodeIdSequence,
 200             final Collection<? extends DataSchemaNode> dataSchemaNodes,
 201             final Collection<QName> dataSchemaNodeIdentifiers) {
 202         final String currentXpathNodeId = xpathNodeIdSequence[0];
 203         final DataSchemaNode currentDataSchemaNode = dataSchemaNodes.stream()
 204             .filter(dataSchemaNode -> currentXpathNodeId.equals(dataSchemaNode.getQName().getLocalName()))
 205             .findFirst().orElseThrow(() -> schemaNodeNotFoundException(currentXpathNodeId));
 206         dataSchemaNodeIdentifiers.add(currentDataSchemaNode.getQName());
 207         if (xpathNodeIdSequence.length <= 1) {
 208             final Map<String, Object> dataSchemaNodeAndIdentifiers =
 209                     new HashMap<>();
 210             dataSchemaNodeAndIdentifiers.put("dataSchemaNode", currentDataSchemaNode);
 211             dataSchemaNodeAndIdentifiers.put("dataSchemaNodeIdentifiers", dataSchemaNodeIdentifiers);
 212             return dataSchemaNodeAndIdentifiers;
 213         }
 214         if (currentDataSchemaNode instanceof DataNodeContainer) {
 215             return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
 216                     getNextLevelXpathNodeIdSequence(xpathNodeIdSequence),
 217                     ((DataNodeContainer) currentDataSchemaNode).getChildNodes(),
 218                     dataSchemaNodeIdentifiers);
 219         }
 220         throw schemaNodeNotFoundException(xpathNodeIdSequence[1]);
 221     }
 222
 223     private static String[] getNextLevelXpathNodeIdSequence(final String[] xpathNodeIdSequence) {
 224         final String[] nextXpathNodeIdSequence = new String[xpathNodeIdSequence.length - 1];
 225         System.arraycopy(xpathNodeIdSequence, 1, nextXpathNodeIdSequence, 0, nextXpathNodeIdSequence.length);
 226         return nextXpathNodeIdSequence;
 227     }
 228
 229     private static DataValidationException schemaNodeNotFoundException(final String schemaNodeIdentifier) {
 230         return new DataValidationException("Invalid xpath.",
 231             String.format("No schema node was found for xpath identifier '%s'.", schemaNodeIdentifier));
 232     }
 233
 234     private static NormalizedNode getFirstChildXmlRoot(final NormalizedNode parent) {
 235         final String rootNodeType = parent.getIdentifier().getNodeType().getLocalName();
 236         final Collection<DataContainerChild> children = (Collection<DataContainerChild>) parent.body();
 237         final Iterator<DataContainerChild> iterator = children.iterator();
 238         NormalizedNode child = null;
 239         while (iterator.hasNext()) {
 240             child = iterator.next();
 241             if (!child.getIdentifier().getNodeType().getLocalName().equals(rootNodeType)
 242                     && !(child instanceof LeafNode)) {
 243                 return child;
 244             }
 245         }
 246         return getFirstChildXmlRoot(child);
 247     }
 248 }