X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-model-util%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FSchemaContextUtil.java;h=2dffbdd4c45a6e294d0cf461fdfee1a3b9dcf278;hb=8cc9d514dbb369fea21c31c78f66b1fed68805e9;hp=3b36c2cf138a7a54d0e735a27bb3100e74c2f2f7;hpb=eb415692c0324fd36e2573483e3a5fd03c89f1c4;p=yangtools.git diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java index 3b36c2cf13..2dffbdd4c4 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java @@ -13,18 +13,26 @@ import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.CharMatcher; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; +import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Deque; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Optional; import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.yang.common.AbstractQName; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.UnqualifiedQName; import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer; import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; @@ -33,7 +41,6 @@ import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; -import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; @@ -41,15 +48,26 @@ import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer; import org.opendaylight.yangtools.yang.model.api.OperationDefinition; import org.opendaylight.yangtools.yang.model.api.PathExpression; +import org.opendaylight.yangtools.yang.model.api.PathExpression.DerefSteps; +import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps; +import org.opendaylight.yangtools.yang.model.api.PathExpression.Steps; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.AxisStep; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.QNameStep; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.ResolvedQNameStep; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.Step; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.UnresolvedQNameStep; +import org.opendaylight.yangtools.yang.xpath.api.YangXPathAxis; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,25 +80,24 @@ public final class SchemaContextUtil { private static final Logger LOG = LoggerFactory.getLogger(SchemaContextUtil.class); private static final Splitter COLON_SPLITTER = Splitter.on(':'); private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings(); + private static final CharMatcher SPACE = CharMatcher.is(' '); private SchemaContextUtil() { + // Hidden on purpose } /** - * Method attempts to find DataSchemaNode in Schema Context via specified - * Schema Path. The returned DataSchemaNode from method will be the node at - * the end of the SchemaPath. If the DataSchemaNode is not present in the - * Schema Context the method will return null.
- * In case that Schema Context or Schema Path are not specified correctly - * (i.e. contains null values) the method will throw - * IllegalArgumentException. + * Method attempts to find DataSchemaNode in Schema Context via specified Schema Path. The returned DataSchemaNode + * from method will be the node at the end of the SchemaPath. If the DataSchemaNode is not present in the Schema + * Context the method will return {@code null}. * - * @param context - * Schema Context - * @param schemaPath - * Schema Path to search for - * @return SchemaNode from the end of the Schema Path or null - * if the Node is not present. + *

+ * In case that Schema Context or Schema Path are not specified correctly (i.e. contains {@code null} values) the + * method will throw IllegalArgumentException. + * + * @param context Schema Context + * @param schemaPath Schema Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. * @throws NullPointerException if context or schemaPath is null */ public static SchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) { @@ -94,6 +111,35 @@ public final class SchemaContextUtil { return findNodeInSchemaContext(context, prefixedPath); } + /** + * Attempt to find a DataSchemaNode based on its path from root, similar to + * {@link #findDataSchemaNode(SchemaContext, Module, PathExpression)} without requiring an expression. + * + * @param context Schema Context + * @param path Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. + * @throws NullPointerException if a any argument is null or if the path contains a null element + */ + @Beta + public static SchemaNode findDataSchemaNode(final SchemaContext context, final List path) { + return findTargetNode(context, null, YangLocationPath.absolute( + path.stream().map(YangXPathAxis.CHILD::asStep).collect(Collectors.toList()))); + } + + /** + * Attempt to find a DataSchemaNode based on its path from root, similar to + * {@link #findDataSchemaNode(SchemaContext, Module, PathExpression)} without requiring an expression. + * + * @param context Schema Context + * @param path Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. + * @throws NullPointerException if a any argument is null or if the path contains a null element + */ + @Beta + public static SchemaNode findDataSchemaNode(final SchemaContext context, final QName... path) { + return findDataSchemaNode(context, Arrays.asList(path)); + } + /** * Method attempts to find DataSchemaNode inside of provided Schema Context * and Yang Module accordingly to Non-conditional Revision Aware XPath. The @@ -119,6 +165,8 @@ public final class SchemaContextUtil { * Non-conditional Revision Aware XPath, or null if the * DataSchemaNode is not present in Schema Context. * @throws NullPointerException if any of the arguments is null + * @deprecated Use {@link #findDataTreeSchemaNode(SchemaContext, QNameModule, YangLocationPath)} or + * {@link #findDataTreeSchemaNode(SchemaContext, QNameModule, PathExpression)} instead. */ // FIXME: This entire method is ill-defined, as the resolution process depends on where the XPath is defined -- // notably RPCs, actions and notifications modify the data tree temporarily. See sections 6.4.1 and 9.9.2 @@ -132,6 +180,7 @@ public final class SchemaContextUtil { // // which would then be passed in to a method similar to this one. In static contexts, like MD-SAL codegen, // that feels like an overkill. + @Deprecated public static SchemaNode findDataSchemaNode(final SchemaContext context, final Module module, final PathExpression nonCondXPath) { requireNonNull(context, "context"); @@ -140,16 +189,33 @@ public final class SchemaContextUtil { final String strXPath = nonCondXPath.getOriginalString(); checkArgument(strXPath.indexOf('[') == -1, "Revision Aware XPath may not contain a condition"); if (nonCondXPath.isAbsolute()) { - final List path = xpathToQNamePath(context, module, strXPath); - - // We do not have enough information about resolution context, hence cannot account for actions, RPCs - // and notifications. We therefore attempt to make a best estimate, but this can still fail. - final Optional pureData = context.findDataTreeChild(path); - return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, path); + return findTargetNode(context, xpathToQNamePath(context, module, strXPath)); } return null; } + @Beta + public static SchemaNode findDataTreeSchemaNode(final SchemaContext ctx, final QNameModule localModule, + final YangLocationPath absPath) { + checkArgument(absPath.isAbsolute(), "Unsupported relative path %s", absPath); + return findTargetNode(ctx, localModule, absPath); + } + + @Beta + public static SchemaNode findDataTreeSchemaNode(final SchemaContext ctx, final QNameModule localModule, + final PathExpression absPath) { + final Steps pathSteps = absPath.getSteps(); + if (pathSteps instanceof LocationPathSteps) { + return findDataTreeSchemaNode(ctx, localModule, ((LocationPathSteps) pathSteps).getLocationPath()); + } + + // We would need a reference schema node and no, we do not want to use SchemaContext in its SchemaNode capacity + checkArgument(!(pathSteps instanceof DerefSteps), "No reference node for steps %s", pathSteps); + + // We are missing proper API alignment, if this ever triggers + throw new IllegalStateException("Unsupported path " + pathSteps); + } + /** * Method attempts to find DataSchemaNode inside of provided Schema Context * and Yang Module accordingly to Non-conditional relative Revision Aware @@ -197,17 +263,12 @@ public final class SchemaContextUtil { // // which would then be passed in to a method similar to this one. In static contexts, like MD-SAL codegen, // that feels like an overkill. + // FIXME: YANGTOOLS-1052: this is a static analysis util, move it to a dedicated class public static SchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context, final Module module, final SchemaNode actualSchemaNode, final PathExpression relativeXPath) { checkState(!relativeXPath.isAbsolute(), "Revision Aware XPath MUST be relative i.e. MUST contains ../, " + "for non relative Revision Aware XPath use findDataSchemaNode method"); - - final Iterable qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode); - - // We do not have enough information about resolution context, hence cannot account for actions, RPCs - // and notifications. We therefore attempt to make a best estimate, but this can still fail. - final Optional pureData = context.findDataTreeChild(qnamePath); - return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, qnamePath); + return resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode); } /** @@ -590,26 +651,27 @@ public final class SchemaContextUtil { * Non conditional Revision Aware Relative XPath * @param actualSchemaNode * actual schema node - * @return list of QName + * @return target schema node * @throws IllegalArgumentException if any arguments are null */ - private static Iterable resolveRelativeXPath(final SchemaContext context, final Module module, + private static @Nullable SchemaNode resolveRelativeXPath(final SchemaContext context, final Module module, final PathExpression relativeXPath, final SchemaNode actualSchemaNode) { checkState(!relativeXPath.isAbsolute(), "Revision Aware XPath MUST be relative i.e. MUST contains ../, " + "for non relative Revision Aware XPath use findDataSchemaNode method"); checkState(actualSchemaNode.getPath() != null, "Schema Path reference for Leafref cannot be NULL"); - List xpaths = new ArrayList<>(); - splitXPath(relativeXPath.getOriginalString(), xpaths); + final String orig = relativeXPath.getOriginalString(); + return orig.startsWith("deref(") ? resolveDerefPath(context, module, actualSchemaNode, orig) + : findTargetNode(context, resolveRelativePath(context, module, actualSchemaNode, doSplitXPath(orig))); + } + private static Iterable resolveRelativePath(final SchemaContext context, final Module module, + final SchemaNode actualSchemaNode, final List steps) { // Find out how many "parent" components there are and trim them - final int colCount = normalizeXPath(xpaths); - if (colCount != 0) { - xpaths = xpaths.subList(colCount, xpaths.size()); - } + final int colCount = normalizeXPath(steps); + final List xpaths = colCount == 0 ? steps : steps.subList(colCount, steps.size()); final Iterable schemaNodePath = actualSchemaNode.getPath().getPathFromRoot(); - if (Iterables.size(schemaNodePath) - colCount >= 0) { return Iterables.concat(Iterables.limit(schemaNodePath, Iterables.size(schemaNodePath) - colCount), Iterables.transform(xpaths, input -> stringPathPartToQName(context, module, input))); @@ -618,6 +680,88 @@ public final class SchemaContextUtil { Iterables.transform(xpaths, input -> stringPathPartToQName(context, module, input))); } + private static SchemaNode resolveDerefPath(final SchemaContext context, final Module module, + final SchemaNode actualSchemaNode, final String xpath) { + final int paren = xpath.indexOf(')', 6); + checkArgument(paren != -1, "Cannot find matching parentheses in %s", xpath); + + final String derefArg = SPACE.trimFrom(xpath.substring(6, paren)); + // Look up the node which we need to reference + final SchemaNode derefTarget = findTargetNode(context, resolveRelativePath(context, module, actualSchemaNode, + doSplitXPath(derefArg))); + checkArgument(derefTarget != null, "Cannot find deref(%s) target node %s in context of %s", derefArg, + actualSchemaNode); + checkArgument(derefTarget instanceof TypedDataSchemaNode, "deref(%s) resolved to non-typed %s", derefArg, + derefTarget); + + // We have a deref() target, decide what to do about it + final TypeDefinition targetType = ((TypedDataSchemaNode) derefTarget).getType(); + if (targetType instanceof InstanceIdentifierTypeDefinition) { + // Static inference breaks down, we cannot determine where this points to + // FIXME: dedicated exception, users can recover from it, derive from IAE + throw new UnsupportedOperationException("Cannot infer instance-identifier reference " + targetType); + } + + // deref() is define only for instance-identifier and leafref types, handle the latter + checkArgument(targetType instanceof LeafrefTypeDefinition, "Illegal target type %s", targetType); + + final PathExpression targetPath = ((LeafrefTypeDefinition) targetType).getPathStatement(); + LOG.debug("Derefencing path {}", targetPath); + + final SchemaNode deref = targetPath.isAbsolute() + ? findTargetNode(context, actualSchemaNode.getQName().getModule(), + ((LocationPathSteps) targetPath.getSteps()).getLocationPath()) + : findDataSchemaNodeForRelativeXPath(context, module, actualSchemaNode, targetPath); + if (deref == null) { + LOG.debug("Path {} could not be derefenced", targetPath); + return null; + } + + checkArgument(deref instanceof LeafSchemaNode, "Unexpected %s reference in %s", deref, targetPath); + + final List qnames = doSplitXPath(SPACE.trimLeadingFrom(xpath.substring(paren + 1))); + return findTargetNode(context, resolveRelativePath(context, module, deref, qnames)); + } + + private static @Nullable SchemaNode findTargetNode(final SchemaContext context, final QNameModule defaultModule, + final YangLocationPath path) { + final Deque ret = new ArrayDeque<>(); + for (Step step : path.getSteps()) { + if (step instanceof AxisStep) { + // We only support parent axis steps + final YangXPathAxis axis = ((AxisStep) step).getAxis(); + checkState(axis == YangXPathAxis.PARENT, "Unexpected axis %s", axis); + ret.removeLast(); + continue; + } + + // This has to be a QNameStep + checkState(step instanceof QNameStep, "Unhandled step %s in %s", step, path); + final QName qname; + if (step instanceof ResolvedQNameStep) { + qname = ((ResolvedQNameStep) step).getQName(); + } else if (step instanceof UnresolvedQNameStep) { + final AbstractQName toResolve = ((UnresolvedQNameStep) step).getQName(); + // TODO: should handle qualified QNames, too? parser should have resolved them when we get here... + checkState(toResolve instanceof UnqualifiedQName, "Unhandled qname %s in %s", toResolve, path); + qname = QName.create(defaultModule, toResolve.getLocalName()); + } else { + throw new IllegalStateException("Unhandled step " + step); + } + + ret.addLast(qname); + } + + return findTargetNode(context, ret); + } + + private static @Nullable SchemaNode findTargetNode(final SchemaContext context, final Iterable qnamePath) { + // We do not have enough information about resolution context, hence cannot account for actions, RPCs + // and notifications. We therefore attempt to make a best estimate, but this can still fail. + final Optional pureData = context.findDataTreeChild(qnamePath); + return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, qnamePath); + } + @VisibleForTesting static int normalizeXPath(final List xpath) { LOG.trace("Normalize {}", xpath); @@ -660,31 +804,8 @@ public final class SchemaContextUtil { return -1; } - private static void splitXPath(final String xpath, final List output) { - // This is a major hack, but should do the trick for now. - final int deref = xpath.indexOf("deref("); - if (deref == -1) { - doSplitXPath(xpath, output); - return; - } - - // Interpret leading part - doSplitXPath(xpath.substring(0, deref), output); - - // Find matching parentheses - final int start = deref + 6; - final int paren = xpath.indexOf(')', start); - checkArgument(paren != -1, "Cannot find matching parentheses in %s", xpath); - - // Interpret the argument - doSplitXPath(xpath.substring(start, paren), output); - - // And now the last bit - splitXPath(xpath.substring(paren + 1), output); - } - - private static void doSplitXPath(final String xpath, final List output) { - SLASH_SPLITTER.split(xpath).forEach(output::add); + private static List doSplitXPath(final String xpath) { + return SLASH_SPLITTER.splitToList(xpath); } /** @@ -719,12 +840,11 @@ public final class SchemaContextUtil { } Module parentModule = findParentModuleOfReferencingType(schemaContext, baseSchema); - dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, parentModule, - pathStatement); + dataSchemaNode = (DataSchemaNode) findDataSchemaNode(schemaContext, parentModule, pathStatement); } else { Module parentModule = findParentModule(schemaContext, schema); - dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, - parentModule, schema, pathStatement); + dataSchemaNode = (DataSchemaNode) findDataSchemaNodeForRelativeXPath(schemaContext, parentModule, schema, + pathStatement); } // FIXME this is just to preserve backwards compatibility since yangtools do not mind wrong leafref xpaths @@ -754,17 +874,18 @@ public final class SchemaContextUtil { public static TypeDefinition getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition, final SchemaContext schemaContext, final QName qname) { final PathExpression pathStatement = typeDefinition.getPathStatement(); - final PathExpression strippedPathStatement = new PathExpressionImpl( - stripConditionsFromXPathString(pathStatement), pathStatement.isAbsolute()); - if (!strippedPathStatement.isAbsolute()) { + if (!pathStatement.isAbsolute()) { return null; } + final PathExpression strippedPathStatement = new PathExpressionImpl( + stripConditionsFromXPathString(pathStatement), true); + final Optional parentModule = schemaContext.findModule(qname.getModule()); checkArgument(parentModule.isPresent(), "Failed to find parent module for %s", qname); - final DataSchemaNode dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, - parentModule.get(), strippedPathStatement); + final DataSchemaNode dataSchemaNode = (DataSchemaNode) findDataSchemaNode(schemaContext, parentModule.get(), + strippedPathStatement); final TypeDefinition targetTypeDefinition = typeDefinition(dataSchemaNode); if (targetTypeDefinition instanceof LeafrefTypeDefinition) { return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode); @@ -787,7 +908,7 @@ public final class SchemaContextUtil { return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null); } - return SchemaContextUtil.findParentModule(schemaContext, schemaNode); + return findParentModule(schemaContext, schemaNode); } private static final Pattern STRIP_PATTERN = Pattern.compile("\\[[^\\[\\]]*\\]"); @@ -804,36 +925,6 @@ public final class SchemaContextUtil { return STRIP_PATTERN.matcher(pathStatement.getOriginalString()).replaceAll(""); } - /** - * Extracts the base type of leaf schema node until it reach concrete type of TypeDefinition. - * - * @param node - * a node representing LeafSchemaNode - * @return concrete type definition of node value - */ - private static TypeDefinition typeDefinition(final LeafSchemaNode node) { - TypeDefinition baseType = node.getType(); - while (baseType.getBaseType() != null) { - baseType = baseType.getBaseType(); - } - return baseType; - } - - /** - * Extracts the base type of leaf schema node until it reach concrete type of TypeDefinition. - * - * @param node - * a node representing LeafListSchemaNode - * @return concrete type definition of node value - */ - private static TypeDefinition typeDefinition(final LeafListSchemaNode node) { - TypeDefinition baseType = node.getType(); - while (baseType.getBaseType() != null) { - baseType = baseType.getBaseType(); - } - return baseType; - } - /** * Gets the base type of DataSchemaNode value. * @@ -842,12 +933,15 @@ public final class SchemaContextUtil { * @return concrete type definition of node value */ private static TypeDefinition typeDefinition(final DataSchemaNode node) { - if (node instanceof LeafListSchemaNode) { - return typeDefinition((LeafListSchemaNode) node); - } else if (node instanceof LeafSchemaNode) { - return typeDefinition((LeafSchemaNode) node); - } else { - throw new IllegalArgumentException("Unhandled parameter type: " + node); + checkArgument(node instanceof TypedDataSchemaNode, "Unhandled parameter type %s", node); + + TypeDefinition current = ((TypedDataSchemaNode) node).getType(); + // TODO: don't we have a utility for this? + TypeDefinition base = current.getBaseType(); + while (base != null) { + current = base; + base = current.getBaseType(); } + return current; } }