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
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * SPDX-License-Identifier: Apache-2.0
22 * ============LICENSE_END=========================================================
25 package org.onap.cps.utils;
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;
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;
77 @NoArgsConstructor(access = AccessLevel.PRIVATE)
78 public class YangUtils {
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";
84 * Parses data into Collection of NormalizedNode according to given schema context.
86 * @param nodeData data string
87 * @param schemaContext schema context describing associated data model
88 * @return the NormalizedNode object
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());
96 return parseXmlDataWithOptionalParent(nodeData, schemaContext, Optional.empty());
100 * Parses data into NormalizedNode according to given schema context.
102 * @param nodeData data string
103 * @param schemaContext schema context describing associated data model
104 * @return the NormalizedNode object
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));
113 return parseXmlDataWithOptionalParent(nodeData, schemaContext, Optional.of(parentNodeXpath));
117 * Parses data into Collection of NormalizedNode according to given schema context.
119 * @param jsonData json data as string
120 * @param schemaContext schema context describing associated data model
121 * @return the Collection of NormalizedNode object
123 public static ContainerNode parseJsonData(final String jsonData, final SchemaContext schemaContext) {
124 return parseJsonDataWithOptionalParent(jsonData, schemaContext, Optional.empty());
128 * Parses jsonData into Collection of NormalizedNode according to given schema context.
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
135 public static ContainerNode parseJsonData(final String jsonData,
136 final SchemaContext schemaContext,
137 final String parentNodeXpath) {
138 return parseJsonDataWithOptionalParent(jsonData, schemaContext, Optional.of(parentNodeXpath));
142 * Create an xpath form a Yang Tools NodeIdentifier (i.e. PathArgument).
144 * @param nodeIdentifier the NodeIdentifier
147 public static String buildXpath(final YangInstanceIdentifier.PathArgument nodeIdentifier) {
148 final StringBuilder xpathBuilder = new StringBuilder();
149 xpathBuilder.append("/").append(nodeIdentifier.getNodeType().getLocalName());
151 if (nodeIdentifier instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
152 xpathBuilder.append(getKeyAttributesStatement(
153 (YangInstanceIdentifier.NodeIdentifierWithPredicates) nodeIdentifier));
155 return xpathBuilder.toString();
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)
168 final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
169 .from(dataContainerNodeBuilder);
170 final JsonReader jsonReader = new JsonReader(new StringReader(jsonData));
171 final JsonParserStream jsonParserStream;
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();
181 JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory, effectiveStatementInference);
183 jsonParserStream = JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory);
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);
196 return dataContainerNodeBuilder.build();
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);
208 final EffectiveModelContext effectiveModelContext = (EffectiveModelContext) schemaContext;
209 final XmlParserStream xmlParserStream;
210 final String preparedXmlContent;
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);
224 preparedXmlContent = XmlFileUtils.prepareXmlContent(xmlData, schemaContext);
225 xmlParserStream = XmlParserStream.create(normalizedNodeStreamWriter, effectiveModelContext);
228 try (xmlParserStream;
229 StringReader stringReader = new StringReader(preparedXmlContent)) {
230 final XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(stringReader);
231 xmlParserStream.parse(xmlStreamReader);
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);
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();
245 private static Collection<QName> getDataSchemaNodeIdentifiers(final SchemaContext schemaContext,
246 final String parentNodeXpath) {
247 return (Collection<QName>) getDataSchemaNodeAndIdentifiersByXpath(parentNodeXpath, schemaContext)
248 .get("dataSchemaNodeIdentifiers");
251 private static String getKeyAttributesStatement(
252 final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier) {
253 final List<String> keyAttributes = nodeIdentifier.entrySet().stream().map(
255 final String name = entry.getKey().getLocalName();
256 final String value = String.valueOf(entry.getValue()).replace("'", "''");
257 return String.format("@%s='%s'", name, value);
259 ).collect(Collectors.toList());
261 if (keyAttributes.isEmpty()) {
264 Collections.sort(keyAttributes);
265 return "[" + String.join(" and ", keyAttributes) + "]";
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(),
276 private static String[] xpathToNodeIdSequence(final String xpath) {
278 return CpsPathUtil.getXpathNodeIdSequence(xpath);
279 } catch (final PathParsingException pathParsingException) {
280 throw new DataValidationException(pathParsingException.getMessage(), pathParsingException.getDetails(),
281 pathParsingException);
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 =
297 dataSchemaNodeAndIdentifiers.put("dataSchemaNode", currentDataSchemaNode);
298 dataSchemaNodeAndIdentifiers.put("dataSchemaNodeIdentifiers", dataSchemaNodeIdentifiers);
299 return dataSchemaNodeAndIdentifiers;
301 if (currentDataSchemaNode instanceof DataNodeContainer) {
302 return findDataSchemaNodeAndIdentifiersByXpathNodeIdSequence(
303 getNextLevelXpathNodeIdSequence(xpathNodeIdSequence),
304 ((DataNodeContainer) currentDataSchemaNode).getChildNodes(),
305 dataSchemaNodeIdentifiers);
307 throw schemaNodeNotFoundException(xpathNodeIdSequence[1]);
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;
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));
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)) {
333 return getFirstChildXmlRoot(child);