/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2020-2021 Nordix Foundation
+ * Copyright (C) 2020-2022 Nordix Foundation
* Modifications Copyright (C) 2021 Bell Canada.
* Modifications Copyright (C) 2021 Pantheon.tech
* ================================================================================
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.onap.cps.spi.exceptions.DataValidationException;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class YangUtils {
private static final String XPATH_DELIMITER_REGEX = "\\/";
- private static final String XPATH_NODE_KEY_ATTRIBUTES_REGEX = "\\[.+";
+ private static final String XPATH_NODE_KEY_ATTRIBUTES_REGEX = "\\[.*?\\]";
/**
* Parses jsonData into NormalizedNode according to given schema context.
* @param schemaContext schema context describing associated data model
* @return the NormalizedNode object
*/
- @SuppressWarnings("squid:S1452") // Generic type <? ,?> is returned by external librray, opendaylight.yangtools
- public static NormalizedNode<?, ?> parseJsonData(final String jsonData, final SchemaContext schemaContext) {
+ public static NormalizedNode parseJsonData(final String jsonData, final SchemaContext schemaContext) {
return parseJsonData(jsonData, schemaContext, Optional.empty());
}
* @param parentNodeXpath the xpath referencing the parent node current data fragment belong to
* @return the NormalizedNode object
*/
- @SuppressWarnings("squid:S1452") // Generic type <? ,?> is returned by external librray, opendaylight.yangtools
- public static NormalizedNode<?, ?> parseJsonData(final String jsonData, final SchemaContext schemaContext,
+ public static NormalizedNode parseJsonData(final String jsonData, final SchemaContext schemaContext,
final String parentNodeXpath) {
- final var parentSchemaNode = getDataSchemaNodeByXpath(parentNodeXpath, schemaContext);
- return parseJsonData(jsonData, schemaContext, Optional.of(parentSchemaNode));
+ final Collection<QName> dataSchemaNodeIdentifiers =
+ getDataSchemaNodeIdentifiersByXpath(parentNodeXpath, schemaContext);
+ return parseJsonData(jsonData, schemaContext, Optional.of(dataSchemaNodeIdentifiers));
}
- private static NormalizedNode<?, ?> parseJsonData(final String jsonData, final SchemaContext schemaContext,
- final Optional<DataSchemaNode> optionalParentSchemaNode) {
- final var jsonCodecFactory = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
- .getShared(schemaContext);
- final var normalizedNodeResult = new NormalizedNodeResult();
- final var normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
+ private static NormalizedNode parseJsonData(final String jsonData, final SchemaContext schemaContext,
+ final Optional<Collection<QName>> dataSchemaNodeIdentifiers) {
+ final JSONCodecFactory jsonCodecFactory = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
+ .getShared((EffectiveModelContext) schemaContext);
+ final NormalizedNodeResult normalizedNodeResult = new NormalizedNodeResult();
+ final NormalizedNodeStreamWriter normalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter
.from(normalizedNodeResult);
+ final JsonReader jsonReader = new JsonReader(new StringReader(jsonData));
+ final JsonParserStream jsonParserStream;
+
+ if (dataSchemaNodeIdentifiers.isPresent()) {
+ final EffectiveModelContext effectiveModelContext = ((EffectiveModelContext) schemaContext);
+ final EffectiveStatementInference effectiveStatementInference =
+ SchemaInferenceStack.of(effectiveModelContext,
+ SchemaNodeIdentifier.Absolute.of(dataSchemaNodeIdentifiers.get())).toInference();
+ jsonParserStream =
+ JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory, effectiveStatementInference);
+ } else {
+ jsonParserStream = JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory);
+ }
- try (final JsonParserStream jsonParserStream = optionalParentSchemaNode.isPresent()
- ? JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory, optionalParentSchemaNode.get())
- : JsonParserStream.create(normalizedNodeStreamWriter, jsonCodecFactory)
- ) {
- final var jsonReader = new JsonReader(new StringReader(jsonData));
+ try {
jsonParserStream.parse(jsonReader);
-
- } catch (final IOException | JsonSyntaxException exception) {
+ jsonParserStream.close();
+ } catch (final JsonSyntaxException exception) {
throw new DataValidationException(
"Failed to parse json data: " + jsonData, exception.getMessage(), exception);
- } catch (final IllegalStateException illegalStateException) {
+ } catch (final IOException | IllegalStateException illegalStateException) {
throw new DataValidationException(
"Failed to parse json data. Unsupported xpath or json data:" + jsonData, illegalStateException
.getMessage(), illegalStateException);
* @return an xpath
*/
public static String buildXpath(final YangInstanceIdentifier.PathArgument nodeIdentifier) {
- final var xpathBuilder = new StringBuilder();
+ final StringBuilder xpathBuilder = new StringBuilder();
xpathBuilder.append("/").append(nodeIdentifier.getNodeType().getLocalName());
if (nodeIdentifier instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
return xpathBuilder.toString();
}
+
private static String getKeyAttributesStatement(
final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier) {
final List<String> keyAttributes = nodeIdentifier.entrySet().stream().map(
}
}
- private static DataSchemaNode getDataSchemaNodeByXpath(final String parentNodeXpath,
- final SchemaContext schemaContext) {
+ private static Collection<QName> getDataSchemaNodeIdentifiersByXpath(final String parentNodeXpath,
+ final SchemaContext schemaContext) {
final String[] xpathNodeIdSequence = xpathToNodeIdSequence(parentNodeXpath);
- return findDataSchemaNodeByXpathNodeIdSequence(xpathNodeIdSequence, schemaContext.getChildNodes());
+ return findDataSchemaNodeIdentifiersByXpathNodeIdSequence(xpathNodeIdSequence, schemaContext.getChildNodes(),
+ new ArrayList<>());
}
private static String[] xpathToNodeIdSequence(final String xpath) {
- final String[] xpathNodeIdSequence = Arrays.stream(xpath.split(XPATH_DELIMITER_REGEX))
- .map(identifier -> identifier.replaceFirst(XPATH_NODE_KEY_ATTRIBUTES_REGEX, ""))
- .filter(identifier -> !identifier.isEmpty())
- .toArray(String[]::new);
+ final String[] xpathNodeIdSequence = Arrays.stream(xpath
+ .replaceAll(XPATH_NODE_KEY_ATTRIBUTES_REGEX, "")
+ .split(XPATH_DELIMITER_REGEX))
+ .filter(identifier -> !identifier.isEmpty())
+ .toArray(String[]::new);
if (xpathNodeIdSequence.length < 1) {
throw new DataValidationException("Invalid xpath.", "Xpath contains no node identifiers.");
}
return xpathNodeIdSequence;
}
- private static DataSchemaNode findDataSchemaNodeByXpathNodeIdSequence(final String[] xpathNodeIdSequence,
- final Collection<? extends DataSchemaNode> dataSchemaNodes) {
+ private static Collection<QName> findDataSchemaNodeIdentifiersByXpathNodeIdSequence(
+ final String[] xpathNodeIdSequence,
+ final Collection<? extends DataSchemaNode> dataSchemaNodes,
+ final Collection<QName> dataSchemaNodeIdentifiers) {
final String currentXpathNodeId = xpathNodeIdSequence[0];
final DataSchemaNode currentDataSchemaNode = dataSchemaNodes.stream()
.filter(dataSchemaNode -> currentXpathNodeId.equals(dataSchemaNode.getQName().getLocalName()))
.findFirst().orElseThrow(() -> schemaNodeNotFoundException(currentXpathNodeId));
+ dataSchemaNodeIdentifiers.add(currentDataSchemaNode.getQName());
if (xpathNodeIdSequence.length <= 1) {
- return currentDataSchemaNode;
+ return dataSchemaNodeIdentifiers;
}
if (currentDataSchemaNode instanceof DataNodeContainer) {
- return findDataSchemaNodeByXpathNodeIdSequence(
+ return findDataSchemaNodeIdentifiersByXpathNodeIdSequence(
getNextLevelXpathNodeIdSequence(xpathNodeIdSequence),
- ((DataNodeContainer) currentDataSchemaNode).getChildNodes());
+ ((DataNodeContainer) currentDataSchemaNode).getChildNodes(),
+ dataSchemaNodeIdentifiers);
}
throw schemaNodeNotFoundException(xpathNodeIdSequence[1]);
}
private static String[] getNextLevelXpathNodeIdSequence(final String[] xpathNodeIdSequence) {
- final var nextXpathNodeIdSequence = new String[xpathNodeIdSequence.length - 1];
+ final String[] nextXpathNodeIdSequence = new String[xpathNodeIdSequence.length - 1];
System.arraycopy(xpathNodeIdSequence, 1, nextXpathNodeIdSequence, 0, nextXpathNodeIdSequence.length);
return nextXpathNodeIdSequence;
}
Code Review / cps.git / blobdiff