From: Robert Varga Date: Thu, 7 Mar 2019 19:18:21 +0000 (+0100) Subject: Add YANG Schema Mount parser support X-Git-Tag: v3.0.0~103 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=18f08017dcdc114f5f7e22c171cac79b38ea0526;p=yangtools.git Add YANG Schema Mount parser support This adds the necessary bits and pieces to properly support mount-point extension in the parser. JIRA: YANGTOOLS-965 Change-Id: I7ca1b6c8c961e3033dc8023089d9169573dc3c4e Signed-off-by: Robert Varga --- diff --git a/artifacts/pom.xml b/artifacts/pom.xml index d7a73660cb..97017ef5b2 100644 --- a/artifacts/pom.xml +++ b/artifacts/pom.xml @@ -196,6 +196,17 @@ 3.0.0-SNAPSHOT + + org.opendaylight.yangtools + rfc8528-model-api + 3.0.0-SNAPSHOT + + + org.opendaylight.yangtools + rfc8528-parser-support + 3.0.0-SNAPSHOT + + org.opendaylight.yangtools yang-xpath-api diff --git a/docs/pom.xml b/docs/pom.xml index 8d4f412b22..d4b9ecdbac 100644 --- a/docs/pom.xml +++ b/docs/pom.xml @@ -145,6 +145,15 @@ rfc8040-parser-support + + org.opendaylight.yangtools + rfc8528-model-api + + + org.opendaylight.yangtools + rfc8528-parser-support + + org.opendaylight.yangtools yang-xpath-api diff --git a/features/odl-yangtools-parser-api/pom.xml b/features/odl-yangtools-parser-api/pom.xml index 1603a592a9..248b27fd4b 100644 --- a/features/odl-yangtools-parser-api/pom.xml +++ b/features/odl-yangtools-parser-api/pom.xml @@ -62,6 +62,10 @@ org.opendaylight.yangtools rfc8040-model-api + + org.opendaylight.yangtools + rfc8528-model-api + org.opendaylight.yangtools yang-model-api diff --git a/features/odl-yangtools-parser/pom.xml b/features/odl-yangtools-parser/pom.xml index fd4759cefd..4e566ced59 100644 --- a/features/odl-yangtools-parser/pom.xml +++ b/features/odl-yangtools-parser/pom.xml @@ -68,6 +68,10 @@ org.opendaylight.yangtools rfc8040-parser-support + + org.opendaylight.yangtools + rfc8528-parser-support + org.opendaylight.yangtools yang-parser-impl diff --git a/yang/pom.xml b/yang/pom.xml index aab8e175b2..8db619d452 100644 --- a/yang/pom.xml +++ b/yang/pom.xml @@ -82,6 +82,10 @@ rfc8040-model-api rfc8040-parser-support + + + rfc8528-model-api + rfc8528-parser-support diff --git a/yang/rfc8528-model-api/pom.xml b/yang/rfc8528-model-api/pom.xml new file mode 100644 index 0000000000..35a5d0e61e --- /dev/null +++ b/yang/rfc8528-model-api/pom.xml @@ -0,0 +1,58 @@ + + + + + 4.0.0 + + org.opendaylight.yangtools + bundle-parent + 3.0.0-SNAPSHOT + ../../bundle-parent + + + rfc8528-model-api + bundle + ${project.artifactId} + RFC8528 model API + + + + org.opendaylight.yangtools + concepts + + + org.opendaylight.yangtools + yang-common + + + org.opendaylight.yangtools + yang-model-api + + + + + + + org.apache.maven.plugins + maven-checkstyle-plugin + + checkstyle.violationSeverity=error + + + + com.github.spotbugs + spotbugs-maven-plugin + + true + + + + + + diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointEffectiveStatement.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointEffectiveStatement.java new file mode 100644 index 0000000000..e6308ac40c --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointEffectiveStatement.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +/** + * Effective statement representation of 'mount-point' extension defined in + * RFC8528. + */ +@Beta +public interface MountPointEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointSchemaNode.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointSchemaNode.java new file mode 100644 index 0000000000..c0ab93b646 --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointSchemaNode.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.model.api; + +import com.google.common.annotations.Beta; +import java.util.stream.Stream; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +/** + * Represents the effect of 'mount-point' extension, as defined in + * RFC8528, being attached to a SchemaNode. + */ +@Beta +public interface MountPointSchemaNode extends UnknownSchemaNode { + /** + * Find all mount points defined in a {@link ContainerSchemaNode}. + * + * @param schema ContainerSchemaNode to search + * @return {@link MountPointSchemaNode}s defined the ContainerSchemaNode. + * @throws NullPointerException if context is null + */ + static @NonNull Stream streamAll(final ContainerSchemaNode schema) { + return schema.getUnknownSchemaNodes().stream() + .filter(MountPointSchemaNode.class::isInstance) + .map(MountPointSchemaNode.class::cast); + } + + /** + * Find all mount points defined in a {@link ListSchemaNode}. + * + * @param schema ListSchemaNode to search + * @return {@link MountPointSchemaNode}s defined the ListSchemaNode. + * @throws NullPointerException if context is null + */ + static @NonNull Stream streamAll(final ListSchemaNode schema) { + return schema.getUnknownSchemaNodes().stream() + .filter(MountPointSchemaNode.class::isInstance) + .map(MountPointSchemaNode.class::cast); + } +} diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointStatement.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointStatement.java new file mode 100644 index 0000000000..a81087a446 --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/MountPointStatement.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatementAwareDeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DocumentedDeclaredStatement.WithStatus; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +/** + * Declared statement representation of 'mount-point' extension defined in + * RFC8528. + */ +@Beta +public interface MountPointStatement extends UnknownStatement, WithStatus, + ConfigStatementAwareDeclaredStatement { + +} diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountConstants.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountConstants.java new file mode 100644 index 0000000000..187311666d --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountConstants.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.model.api; + +import com.google.common.collect.ImmutableList; +import java.net.URI; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.Revision; +import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; +import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; + +/** + * Constants associated with RFC8528. + * + * @author Robert Varga + */ +@NonNullByDefault +public final class SchemaMountConstants { + private static final String MODULE_NAME = "ietf-yang-schema-mount"; + private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-schema-mount"); + private static final Revision RFC8528_REVISION = Revision.of("2019-01-14"); + + /** + * Runtime RFC8528 identity. + */ + public static final QNameModule RFC8528_MODULE = QNameModule.create(MODULE_NAMESPACE, RFC8528_REVISION).intern(); + + /** + * RFC8528 model source name. + */ + public static final SourceIdentifier RFC8528_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME, + RFC8528_REVISION); + + /** + * Normative prefix to use when importing {@link #RFC8528_SOURCE}. + */ + public static final String MODULE_PREFIX = "yangmnt"; + + private SchemaMountConstants() { + throw new UnsupportedOperationException(); + } + + /** + * Return identifiers of all sources known to define the metadata extension. + * + * @return Collection of identifiers. + */ + public static Collection knownModelSources() { + return ImmutableList.of(RFC8528_SOURCE); + } +} diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountStatements.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountStatements.java new file mode 100644 index 0000000000..1ba110ed30 --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/SchemaMountStatements.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.model.api; + +import static java.util.Objects.requireNonNull; + +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; + +/** + * {@link StatementDefinition}s for statements defined by RFC7952. + * + * @author Robert Varga + */ +@NonNullByDefault +public enum SchemaMountStatements implements StatementDefinition { + MOUNT_POINT(QName.create(SchemaMountConstants.RFC8528_MODULE, "mount-point"), "label", MountPointStatement.class, + MountPointEffectiveStatement.class); + + private final Class> effectiveRepresentation; + private final Class> declaredRepresentation; + private final QName statementName; + private final QName argumentName; + + SchemaMountStatements(final QName statementName, final String argumentName, + final Class> declaredRepresentation, + final Class> effectiveRepresentation) { + this.statementName = statementName.intern(); + this.argumentName = QName.create(statementName, argumentName); + this.declaredRepresentation = requireNonNull(declaredRepresentation); + this.effectiveRepresentation = requireNonNull(effectiveRepresentation); + } + + @Override + public @NonNull QName getArgumentName() { + return argumentName; + } + + @Override + public boolean isArgumentYinElement() { + return false; + } + + @Override + public QName getStatementName() { + return statementName; + } + + @Override + public Class> getEffectiveRepresentationClass() { + return effectiveRepresentation; + } + + @Override + public Class> getDeclaredRepresentationClass() { + return declaredRepresentation; + } +} diff --git a/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/package-info.java b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/package-info.java new file mode 100644 index 0000000000..1b6a0ea08c --- /dev/null +++ b/yang/rfc8528-model-api/src/main/java/org/opendaylight/yangtools/rfc8528/model/api/package-info.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +/** + * YANG metamodel extensions to support mount-poing, as defined in + * RFC8528. For SchemaNode world entry space is defined via + * {@link org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode}'s static methods. + * + * @author Robert Varga + */ +package org.opendaylight.yangtools.rfc8528.model.api; diff --git a/yang/rfc8528-parser-support/pom.xml b/yang/rfc8528-parser-support/pom.xml new file mode 100644 index 0000000000..915a45b340 --- /dev/null +++ b/yang/rfc8528-parser-support/pom.xml @@ -0,0 +1,64 @@ + + + + + 4.0.0 + + org.opendaylight.yangtools + bundle-parent + 3.0.0-SNAPSHOT + ../../bundle-parent + + + rfc8528-parser-support + bundle + ${project.artifactId} + RFC8528 parser support + + + + org.opendaylight.yangtools + concepts + + + org.opendaylight.yangtools + yang-common + + + + org.opendaylight.yangtools + rfc8528-model-api + + + + org.opendaylight.yangtools + yang-parser-rfc7950 + + + + + + + org.apache.maven.plugins + maven-checkstyle-plugin + + checkstyle.violationSeverity=error + + + + com.github.spotbugs + spotbugs-maven-plugin + + true + + + + + + diff --git a/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java new file mode 100644 index 0000000000..157cac6eae --- /dev/null +++ b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.parser; + +import org.opendaylight.yangtools.rfc8528.model.api.MountPointEffectiveStatement; +import org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode; +import org.opendaylight.yangtools.rfc8528.model.api.MountPointStatement; +import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountStatements; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; +import org.opendaylight.yangtools.yang.parser.spi.meta.QNameCacheNamespace; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; +import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; +import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; + +public final class MountPointStatementSupport + extends AbstractStatementSupport { + + private static final class Declared extends AbstractDeclaredStatement implements MountPointStatement { + Declared(final StmtContext context) { + super(context); + } + + @Override + public QName getArgument() { + return argument(); + } + } + + private static final class Effective extends UnknownEffectiveStatementBase + implements MountPointEffectiveStatement, MountPointSchemaNode { + + private final SchemaPath path; + + Effective(final StmtContext ctx) { + super(ctx); + path = ctx.coerceParentContext().getSchemaPath().get().createChild(argument()); + } + + @Override + public QName getQName() { + return path.getLastComponent(); + } + + @Override + public SchemaPath getPath() { + return path; + } + } + + private static final MountPointStatementSupport INSTANCE = new MountPointStatementSupport( + SchemaMountStatements.MOUNT_POINT); + + private final SubstatementValidator validator; + + MountPointStatementSupport(final StatementDefinition definition) { + super(definition); + this.validator = SubstatementValidator.builder(definition) + .addOptional(YangStmtMapping.CONFIG) + .addOptional(YangStmtMapping.DESCRIPTION) + .addOptional(YangStmtMapping.REFERENCE) + .addOptional(YangStmtMapping.STATUS) + .build(); + } + + public static MountPointStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public MountPointStatement createDeclared(final StmtContext ctx) { + return new Declared(ctx); + } + + @Override + public MountPointEffectiveStatement createEffective( + final StmtContext ctx) { + return new Effective(ctx); + } + + @Override + public QName parseArgumentValue(final StmtContext ctx, final String value) { + return StmtContextUtils.parseIdentifier(ctx, value); + } + + @Override + public QName adaptArgumentValue(final StmtContext ctx, + final QNameModule targetModule) { + return ctx.getFromNamespace(QNameCacheNamespace.class, ctx.getStatementArgument().withModule(targetModule)); + } + + @Override + public void onStatementAdded(final Mutable stmt) { + final StatementDefinition parentDef = stmt.coerceParentContext().getPublicDefinition(); + SourceException.throwIf(YangStmtMapping.CONTAINER != parentDef && YangStmtMapping.LIST != parentDef, + stmt.getStatementSourceReference(), "Mount points may only be defined at either a container or a list"); + } + + @Override + protected SubstatementValidator getSubstatementValidator() { + return validator; + } +} diff --git a/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/package-info.java b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/package-info.java new file mode 100644 index 0000000000..6bc4c97eb6 --- /dev/null +++ b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/package-info.java @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2017 Pantheon Technologies s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +/** + * YANG parser support for metamodel extensions defined in RFC8528. + * Add {@link org.opendaylight.yangtools.rfc8528.parser.MountPointStatementSupport} to your reactor to add support + * for this extension. + * + * @author Robert Varga + */ +package org.opendaylight.yangtools.rfc8528.parser; diff --git a/yang/rfc8528-parser-support/src/test/java/org/opendaylight/yangtools/rfc8528/parser/MountPointTest.java b/yang/rfc8528-parser-support/src/test/java/org/opendaylight/yangtools/rfc8528/parser/MountPointTest.java new file mode 100644 index 0000000000..c57f0552af --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/java/org/opendaylight/yangtools/rfc8528/parser/MountPointTest.java @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2019 PANTHEON.tech s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.rfc8528.parser; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; + +import java.io.IOException; +import java.net.URI; +import java.util.List; +import java.util.stream.Collectors; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException; +import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; +import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors; +import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; +import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException; +import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor; + +public class MountPointTest { + private static final QNameModule EXAMPLE_USES = QNameModule.create(URI.create("http://example.org/example-uses")); + private static final QName EXAMPLE_CONT = QName.create(EXAMPLE_USES, "cont"); + private static final QName EXAMPLE_GRP = QName.create(EXAMPLE_USES, "grp"); + private static final QName EXAMPLE_GRP_CONT = QName.create(EXAMPLE_USES, "grp-cont"); + private static final QName EXAMPLE_LIST = QName.create(EXAMPLE_USES, "list"); + + private static CrossSourceStatementReactor reactor; + + @BeforeClass + public static void createReactor() { + reactor = RFC7950Reactors.vanillaReactorBuilder() + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MountPointStatementSupport.getInstance()) + .build(); + } + + @AfterClass + public static void freeReactor() { + reactor = null; + } + + @Test + public void testMountPointResolution() throws ReactorException, IOException, YangSyntaxErrorException { + final SchemaContext context = reactor.newBuild() + .addLibSources( + YangStatementStreamSource.create(YangTextSchemaSource.forResource( + "/ietf-inet-types@2013-07-15.yang")), + YangStatementStreamSource.create(YangTextSchemaSource.forResource( + "/ietf-yang-schema-mount@2019-01-14.yang")), + YangStatementStreamSource.create(YangTextSchemaSource.forResource( + "/ietf-yang-types@2013-07-15.yang"))) + .addSources( + YangStatementStreamSource.create(YangTextSchemaSource.forResource("/example-grp.yang")), + YangStatementStreamSource.create(YangTextSchemaSource.forResource("/example-uses.yang"))) + .buildEffective(); + + assertEquals(5, context.getModules().size()); + + DataSchemaNode child = context.findDataTreeChild(EXAMPLE_CONT).get(); + assertThat(child, instanceOf(ContainerSchemaNode.class)); + List mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child) + .collect(Collectors.toList()); + assertEquals(2, mps.size()); + assertEquals(EXAMPLE_CONT, mps.get(0).getQName()); + assertEquals(EXAMPLE_CONT, mps.get(1).getQName()); + + child = context.findDataTreeChild(EXAMPLE_GRP_CONT).get(); + assertThat(child, instanceOf(ContainerSchemaNode.class)); + mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child).collect(Collectors.toList()); + assertEquals(1, mps.size()); + assertEquals(EXAMPLE_GRP, mps.get(0).getQName()); + + child = context.findDataTreeChild(EXAMPLE_LIST).get(); + assertThat(child, instanceOf(ListSchemaNode.class)); + mps = MountPointSchemaNode.streamAll((ListSchemaNode) child).collect(Collectors.toList()); + assertEquals(1, mps.size()); + assertEquals(EXAMPLE_LIST, mps.get(0).getQName()); + } +} diff --git a/yang/rfc8528-parser-support/src/test/resources/example-grp.yang b/yang/rfc8528-parser-support/src/test/resources/example-grp.yang new file mode 100644 index 0000000000..ffe2630945 --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/resources/example-grp.yang @@ -0,0 +1,12 @@ +module example-grp { + namespace "http://example.org/example-grp"; + prefix "eg"; + import ietf-yang-schema-mount { + prefix "yangmnt"; + } + grouping grp { + container grp-cont { + yangmnt:mount-point grp; + } + } +} diff --git a/yang/rfc8528-parser-support/src/test/resources/example-uses.yang b/yang/rfc8528-parser-support/src/test/resources/example-uses.yang new file mode 100644 index 0000000000..422fd487f0 --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/resources/example-uses.yang @@ -0,0 +1,18 @@ +module example-uses { + namespace "http://example.org/example-uses"; + prefix "eu"; + import example-grp { + prefix "eg"; + } + import ietf-yang-schema-mount { + prefix "yangmnt"; + } + container cont { + yangmnt:mount-point cont; + yangmnt:mount-point cont; + } + list list { + yangmnt:mount-point list; + } + uses eg:grp; +} diff --git a/yang/rfc8528-parser-support/src/test/resources/ietf-inet-types@2013-07-15.yang b/yang/rfc8528-parser-support/src/test/resources/ietf-inet-types@2013-07-15.yang new file mode 100644 index 0000000000..eacefb6363 --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/resources/ietf-inet-types@2013-07-15.yang @@ -0,0 +1,458 @@ +module ietf-inet-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-inet-types"; + prefix "inet"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types for Internet addresses and related things. + + Copyright (c) 2013 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6991; see + the RFC itself for full legal notices."; + + revision 2013-07-15 { + description + "This revision adds the following new data types: + - ip-address-no-zone + - ipv4-address-no-zone + - ipv6-address-no-zone"; + reference + "RFC 6991: Common YANG Data Types"; + } + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of types related to protocol fields ***/ + + typedef ip-version { + type enumeration { + enum unknown { + value "0"; + description + "An unknown or unspecified version of the Internet + protocol."; + } + enum ipv4 { + value "1"; + description + "The IPv4 protocol as defined in RFC 791."; + } + enum ipv6 { + value "2"; + description + "The IPv6 protocol as defined in RFC 2460."; + } + } + description + "This value represents the version of the IP protocol. + + In the value set and its semantics, this type is equivalent + to the InetVersion textual convention of the SMIv2."; + reference + "RFC 791: Internet Protocol + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + typedef dscp { + type uint8 { + range "0..63"; + } + description + "The dscp type represents a Differentiated Services Code Point + that may be used for marking packets in a traffic stream. + In the value set and its semantics, this type is equivalent + to the Dscp textual convention of the SMIv2."; + reference + "RFC 3289: Management Information Base for the Differentiated + Services Architecture + RFC 2474: Definition of the Differentiated Services Field + (DS Field) in the IPv4 and IPv6 Headers + RFC 2780: IANA Allocation Guidelines For Values In + the Internet Protocol and Related Headers"; + } + + typedef ipv6-flow-label { + type uint32 { + range "0..1048575"; + } + description + "The ipv6-flow-label type represents the flow identifier or Flow + Label in an IPv6 packet header that may be used to + discriminate traffic flows. + + In the value set and its semantics, this type is equivalent + to the IPv6FlowLabel textual convention of the SMIv2."; + reference + "RFC 3595: Textual Conventions for IPv6 Flow Label + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"; + } + + typedef port-number { + type uint16 { + range "0..65535"; + } + description + "The port-number type represents a 16-bit port number of an + Internet transport-layer protocol such as UDP, TCP, DCCP, or + SCTP. Port numbers are assigned by IANA. A current list of + all assignments is available from . + + Note that the port number value zero is reserved by IANA. In + situations where the value zero does not make sense, it can + be excluded by subtyping the port-number type. + In the value set and its semantics, this type is equivalent + to the InetPortNumber textual convention of the SMIv2."; + reference + "RFC 768: User Datagram Protocol + RFC 793: Transmission Control Protocol + RFC 4960: Stream Control Transmission Protocol + RFC 4340: Datagram Congestion Control Protocol (DCCP) + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of types related to autonomous systems ***/ + + typedef as-number { + type uint32; + description + "The as-number type represents autonomous system numbers + which identify an Autonomous System (AS). An AS is a set + of routers under a single technical administration, using + an interior gateway protocol and common metrics to route + packets within the AS, and using an exterior gateway + protocol to route packets to other ASes. IANA maintains + the AS number space and has delegated large parts to the + regional registries. + + Autonomous system numbers were originally limited to 16 + bits. BGP extensions have enlarged the autonomous system + number space to 32 bits. This type therefore uses an uint32 + base type without a range restriction in order to support + a larger autonomous system number space. + + In the value set and its semantics, this type is equivalent + to the InetAutonomousSystemNumber textual convention of + the SMIv2."; + reference + "RFC 1930: Guidelines for creation, selection, and registration + of an Autonomous System (AS) + RFC 4271: A Border Gateway Protocol 4 (BGP-4) + RFC 4001: Textual Conventions for Internet Network Addresses + RFC 6793: BGP Support for Four-Octet Autonomous System (AS) + Number Space"; + } + + /*** collection of types related to IP addresses and hostnames ***/ + + typedef ip-address { + type union { + type inet:ipv4-address; + type inet:ipv6-address; + } + description + "The ip-address type represents an IP address and is IP + version neutral. The format of the textual representation + implies the IP version. This type supports scoped addresses + by allowing zone identifiers in the address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + } + + typedef ipv4-address { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])' + + '(%[\p{N}\p{L}]+)?'; + } + description + "The ipv4-address type represents an IPv4 address in + dotted-quad notation. The IPv4 address may include a zone + index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format for the zone index is the numerical + format"; + } + + typedef ipv6-address { + type string { + pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}' + + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|' + + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}' + + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))' + + '(%[\p{N}\p{L}]+)?'; + pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|' + + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)' + + '(%.+)?'; + } + description + "The ipv6-address type represents an IPv6 address in full, + mixed, shortened, and shortened-mixed notation. The IPv6 + address may include a zone index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format of IPv6 addresses uses the textual + representation defined in Section 4 of RFC 5952. The + canonical format for the zone index is the numerical + format as described in Section 11.2 of RFC 4007."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + typedef ip-address-no-zone { + type union { + type inet:ipv4-address-no-zone; + type inet:ipv6-address-no-zone; + } + description + "The ip-address-no-zone type represents an IP address and is + IP version neutral. The format of the textual representation + implies the IP version. This type does not support scoped + addresses since it does not allow zone identifiers in the + address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + } + + typedef ipv4-address-no-zone { + type inet:ipv4-address { + pattern '[0-9\.]*'; + } + description + "An IPv4 address without a zone index. This type, derived from + ipv4-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + } + + typedef ipv6-address-no-zone { + type inet:ipv6-address { + pattern '[0-9a-fA-F:\.]*'; + } + description + "An IPv6 address without a zone index. This type, derived from + ipv6-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + typedef ip-prefix { + type union { + type inet:ipv4-prefix; + type inet:ipv6-prefix; + } + description + "The ip-prefix type represents an IP prefix and is IP + version neutral. The format of the textual representations + implies the IP version."; + } + + typedef ipv4-prefix { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])' + + '/(([0-9])|([1-2][0-9])|(3[0-2]))'; + } + description + "The ipv4-prefix type represents an IPv4 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 32. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The canonical format of an IPv4 prefix has all bits of + the IPv4 address set to zero that are not part of the + IPv4 prefix."; + } + + typedef ipv6-prefix { + type string { + pattern '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}' + + '((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|' + + '(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}' + + '(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))' + + '(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))'; + pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|' + + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)' + + '(/.+)'; + } + + description + "The ipv6-prefix type represents an IPv6 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 128. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The IPv6 address should have all bits that do not belong + to the prefix set to zero. + + The canonical format of an IPv6 prefix has all bits of + the IPv6 address set to zero that are not part of the + IPv6 prefix. Furthermore, the IPv6 address is represented + as defined in Section 4 of RFC 5952."; + reference + "RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + /*** collection of domain name and URI types ***/ + + typedef domain-name { + type string { + pattern + '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*' + + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)' + + '|\.'; + length "1..253"; + } + description + "The domain-name type represents a DNS domain name. The + name SHOULD be fully qualified whenever possible. + + Internet domain names are only loosely specified. Section + 3.5 of RFC 1034 recommends a syntax (modified in Section + 2.1 of RFC 1123). The pattern above is intended to allow + for current practice in domain name use, and some possible + future expansion. It is designed to hold various types of + domain names, including names used for A or AAAA records + (host names) and other records, such as SRV records. Note + that Internet host names have a stricter syntax (described + in RFC 952) than the DNS recommendations in RFCs 1034 and + 1123, and that systems that want to store host names in + schema nodes using the domain-name type are recommended to + adhere to this stricter standard to ensure interoperability. + + The encoding of DNS names in the DNS protocol is limited + to 255 characters. Since the encoding consists of labels + prefixed by a length bytes and there is a trailing NULL + byte, only 253 characters can appear in the textual dotted + notation. + + The description clause of schema nodes using the domain-name + type MUST describe when and how these names are resolved to + IP addresses. Note that the resolution of a domain-name value + may require to query multiple DNS records (e.g., A for IPv4 + and AAAA for IPv6). The order of the resolution process and + which DNS record takes precedence can either be defined + explicitly or may depend on the configuration of the + resolver. + + Domain-name values use the US-ASCII encoding. Their canonical + format uses lowercase US-ASCII characters. Internationalized + domain names MUST be A-labels as per RFC 5890."; + reference + "RFC 952: DoD Internet Host Table Specification + RFC 1034: Domain Names - Concepts and Facilities + RFC 1123: Requirements for Internet Hosts -- Application + and Support + RFC 2782: A DNS RR for specifying the location of services + (DNS SRV) + RFC 5890: Internationalized Domain Names in Applications + (IDNA): Definitions and Document Framework"; + } + + typedef host { + type union { + type inet:ip-address; + type inet:domain-name; + } + description + "The host type represents either an IP address or a DNS + domain name."; + } + + typedef uri { + type string; + description + "The uri type represents a Uniform Resource Identifier + (URI) as defined by STD 66. + + Objects using the uri type MUST be in US-ASCII encoding, + and MUST be normalized as described by RFC 3986 Sections + 6.2.1, 6.2.2.1, and 6.2.2.2. All unnecessary + percent-encoding is removed, and all case-insensitive + characters are set to lowercase except for hexadecimal + digits, which are normalized to uppercase as described in + Section 6.2.2.1. + + The purpose of this normalization is to help provide + unique URIs. Note that this normalization is not + sufficient to provide uniqueness. Two URIs that are + textually distinct after this normalization may still be + equivalent. + + Objects using the uri type may restrict the schemes that + they permit. For example, 'data:' and 'urn:' schemes + might not be appropriate. + + A zero-length URI is not a valid URI. This can be used to + express 'URI absent' where required. + + In the value set and its semantics, this type is equivalent + to the Uri SMIv2 textual convention defined in RFC 5017."; + reference + "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax + RFC 3305: Report from the Joint W3C/IETF URI Planning Interest + Group: Uniform Resource Identifiers (URIs), URLs, + and Uniform Resource Names (URNs): Clarifications + and Recommendations + RFC 5017: MIB Textual Conventions for Uniform Resource + Identifiers (URIs)"; + } + +} diff --git a/yang/rfc8528-parser-support/src/test/resources/ietf-yang-schema-mount@2019-01-14.yang b/yang/rfc8528-parser-support/src/test/resources/ietf-yang-schema-mount@2019-01-14.yang new file mode 100644 index 0000000000..c49458a11c --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/resources/ietf-yang-schema-mount@2019-01-14.yang @@ -0,0 +1,224 @@ +module ietf-yang-schema-mount { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-schema-mount"; + prefix yangmnt; + + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + + import ietf-yang-types { + prefix yang; + reference + "RFC 6991: Common YANG Data Types"; + } + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + Editor: Martin Bjorklund + + + Editor: Ladislav Lhotka + "; + + description + "This module defines a YANG extension statement that can be used + to incorporate data models defined in other YANG modules in a + module. It also defines operational state data that specify the + overall structure of the data model. + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2019 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject to + the license terms contained in, the Simplified BSD License set + forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 8528; + see the RFC itself for full legal notices."; + + revision 2019-01-14 { + description + "Initial revision."; + reference + "RFC 8528: YANG Schema Mount"; + } + + /* + * Extensions + */ + + extension mount-point { + argument label; + description + "The argument 'label' is a YANG identifier, i.e., it is of the + type 'yang:yang-identifier'. + + The 'mount-point' statement MUST NOT be used in a YANG + version 1 module, neither explicitly nor via a 'uses' + statement. + The 'mount-point' statement MAY be present as a substatement + of 'container' and 'list' and MUST NOT be present elsewhere. + There MUST NOT be more than one 'mount-point' statement in a + given 'container' or 'list' statement. + + If a mount point is defined within a grouping, its label is + bound to the module where the grouping is used. + + A mount point defines a place in the node hierarchy where + other data models may be attached. A server that implements a + module with a mount point populates the + '/schema-mounts/mount-point' list with detailed information on + which data models are mounted at each mount point. + + Note that the 'mount-point' statement does not define a new + data node."; + } + + /* + * State data nodes + */ + + container schema-mounts { + config false; + description + "Contains information about the structure of the overall + mounted data model implemented in the server."; + list namespace { + key "prefix"; + description + "This list provides a mapping of namespace prefixes that are + used in XPath expressions of 'parent-reference' leafs to the + corresponding namespace URI references."; + leaf prefix { + type yang:yang-identifier; + description + "Namespace prefix."; + } + leaf uri { + type inet:uri; + description + "Namespace URI reference."; + } + } + list mount-point { + key "module label"; + + description + "Each entry of this list specifies a schema for a particular + mount point. + + Each mount point MUST be defined using the 'mount-point' + extension in one of the modules listed in the server's + YANG library instance with conformance type 'implement'."; + leaf module { + type yang:yang-identifier; + description + "Name of a module containing the mount point."; + } + leaf label { + type yang:yang-identifier; + description + "Label of the mount point defined using the 'mount-point' + extension."; + } + leaf config { + type boolean; + default "true"; + description + "If this leaf is set to 'false', then all data nodes in the + mounted schema are read-only ('config false'), regardless + of their 'config' property."; + } + choice schema-ref { + mandatory true; + description + "Alternatives for specifying the schema."; + container inline { + presence + "A complete self-contained schema is mounted at the + mount point."; + description + "This node indicates that the server has mounted at least + the module 'ietf-yang-library' at the mount point, and + its instantiation provides the information about the + mounted schema. + + Different instances of the mount point may have + different schemas mounted."; + } + container shared-schema { + presence + "The mounted schema together with the 'parent-reference' + make up the schema for this mount point."; + + description + "This node indicates that the server has mounted at least + the module 'ietf-yang-library' at the mount point, and + its instantiation provides the information about the + mounted schema. When XPath expressions in the mounted + schema are evaluated, the 'parent-reference' leaf-list + is taken into account. + + Different instances of the mount point MUST have the + same schema mounted."; + leaf-list parent-reference { + type yang:xpath1.0; + description + "Entries of this leaf-list are XPath 1.0 expressions + that are evaluated in the following context: + + - The context node is the node in the parent data tree + where the mount-point is defined. + + - The accessible tree is the parent data tree + *without* any nodes defined in modules that are + mounted inside the parent schema. + + - The context position and context size are both equal + to 1. + + - The set of variable bindings is empty. + + - The function library is the core function library + defined in the W3C XPath 1.0 document + (http://www.w3.org/TR/1999/REC-xpath-19991116) and + the functions defined in Section 10 of RFC 7950. + + - The set of namespace declarations is defined by the + 'namespace' list under 'schema-mounts'. + + Each XPath expression MUST evaluate to a node-set + (possibly empty). For the purposes of evaluating + XPath expressions whose context nodes are defined in + the mounted schema, the union of all these node-sets + together with ancestor nodes are added to the + accessible data tree. + + Note that in the case 'ietf-yang-schema-mount' is + itself mounted, a 'parent-reference' in the mounted + module may refer to nodes that were brought into the + accessible tree through a 'parent-reference' in the + parent schema."; + } + } + } + } + } +} diff --git a/yang/rfc8528-parser-support/src/test/resources/ietf-yang-types@2013-07-15.yang b/yang/rfc8528-parser-support/src/test/resources/ietf-yang-types@2013-07-15.yang new file mode 100644 index 0000000000..ee58fa3ab0 --- /dev/null +++ b/yang/rfc8528-parser-support/src/test/resources/ietf-yang-types@2013-07-15.yang @@ -0,0 +1,474 @@ +module ietf-yang-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types"; + prefix "yang"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types. + + Copyright (c) 2013 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6991; see + the RFC itself for full legal notices."; + + revision 2013-07-15 { + description + "This revision adds the following new data types: + - yang-identifier + - hex-string + - uuid + - dotted-quad"; + reference + "RFC 6991: Common YANG Data Types"; + } + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of counter and gauge types ***/ + + typedef counter32 { + type uint32; + description + "The counter32 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter32 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter32 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter32. + + In the value set and its semantics, this type is equivalent + to the Counter32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef zero-based-counter32 { + type yang:counter32; + default "0"; + description + "The zero-based-counter32 type represents a counter32 + that has the defined 'initial' value zero. + + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter32 textual convention of the SMIv2."; + reference + "RFC 4502: Remote Network Monitoring Management Information + Base Version 2"; + } + + typedef counter64 { + type uint64; + description + "The counter64 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter64 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter64 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter64. + + In the value set and its semantics, this type is equivalent + to the Counter64 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef zero-based-counter64 { + type yang:counter64; + default "0"; + description + "The zero-based-counter64 type represents a counter64 that + has the defined 'initial' value zero. + + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter64 textual convention of the SMIv2."; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + typedef gauge32 { + type uint32; + description + "The gauge32 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^32-1 (4294967295 decimal), and + the minimum value cannot be smaller than 0. The value of + a gauge32 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge32 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the Gauge32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef gauge64 { + type uint64; + description + "The gauge64 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^64-1 (18446744073709551615), and + the minimum value cannot be smaller than 0. The value of + a gauge64 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge64 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the CounterBasedGauge64 SMIv2 textual convention defined + in RFC 2856"; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + /*** collection of identifier-related types ***/ + + typedef object-identifier { + type string { + pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))' + + '(\.(0|([1-9]\d*)))*'; + } + description + "The object-identifier type represents administratively + assigned names in a registration-hierarchical-name tree. + + Values of this type are denoted as a sequence of numerical + non-negative sub-identifier values. Each sub-identifier + value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers + are separated by single dots and without any intermediate + whitespace. + + The ASN.1 standard restricts the value space of the first + sub-identifier to 0, 1, or 2. Furthermore, the value space + of the second sub-identifier is restricted to the range + 0 to 39 if the first sub-identifier is 0 or 1. Finally, + the ASN.1 standard requires that an object identifier + has always at least two sub-identifiers. The pattern + captures these restrictions. + + Although the number of sub-identifiers is not limited, + module designers should realize that there may be + implementations that stick with the SMIv2 limit of 128 + sub-identifiers. + + This type is a superset of the SMIv2 OBJECT IDENTIFIER type + since it is not restricted to 128 sub-identifiers. Hence, + this type SHOULD NOT be used to represent the SMIv2 OBJECT + IDENTIFIER type; the object-identifier-128 type SHOULD be + used instead."; + reference + "ISO9834-1: Information technology -- Open Systems + Interconnection -- Procedures for the operation of OSI + Registration Authorities: General procedures and top + arcs of the ASN.1 Object Identifier tree"; + } + + typedef object-identifier-128 { + type object-identifier { + pattern '\d*(\.\d*){1,127}'; + } + description + "This type represents object-identifiers restricted to 128 + sub-identifiers. + + In the value set and its semantics, this type is equivalent + to the OBJECT IDENTIFIER type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef yang-identifier { + type string { + length "1..max"; + pattern '[a-zA-Z_][a-zA-Z0-9\-_.]*'; + pattern '.|..|[^xX].*|.[^mM].*|..[^lL].*'; + } + description + "A YANG identifier string as defined by the 'identifier' + rule in Section 12 of RFC 6020. An identifier must + start with an alphabetic character or an underscore + followed by an arbitrary sequence of alphabetic or + numeric characters, underscores, hyphens, or dots. + + A YANG identifier MUST NOT start with any possible + combination of the lowercase or uppercase character + sequence 'xml'."; + reference + "RFC 6020: YANG - A Data Modeling Language for the Network + Configuration Protocol (NETCONF)"; + } + + /*** collection of types related to date and time***/ + + typedef date-and-time { + type string { + pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?' + + '(Z|[\+\-]\d{2}:\d{2})'; + } + description + "The date-and-time type is a profile of the ISO 8601 + standard for representation of dates and times using the + Gregorian calendar. The profile is defined by the + date-time production in Section 5.6 of RFC 3339. + + The date-and-time type is compatible with the dateTime XML + schema type with the following notable exceptions: + + (a) The date-and-time type does not allow negative years. + + (b) The date-and-time time-offset -00:00 indicates an unknown + time zone (see RFC 3339) while -00:00 and +00:00 and Z + all represent the same time zone in dateTime. + + (c) The canonical format (see below) of data-and-time values + differs from the canonical format used by the dateTime XML + schema type, which requires all times to be in UTC using + the time-offset 'Z'. + + This type is not equivalent to the DateAndTime textual + convention of the SMIv2 since RFC 3339 uses a different + separator between full-date and full-time and provides + higher resolution of time-secfrac. + + The canonical format for date-and-time values with a known time + zone uses a numeric time zone offset that is calculated using + the device's configured known offset to UTC time. A change of + the device's offset to UTC time will cause date-and-time values + to change accordingly. Such changes might happen periodically + in case a server follows automatically daylight saving time + (DST) time zone offset changes. The canonical format for + date-and-time values with an unknown time zone (usually + referring to the notion of local time) uses the time-offset + -00:00."; + reference + "RFC 3339: Date and Time on the Internet: Timestamps + RFC 2579: Textual Conventions for SMIv2 + XSD-TYPES: XML Schema Part 2: Datatypes Second Edition"; + } + + typedef timeticks { + type uint32; + description + "The timeticks type represents a non-negative integer that + represents the time, modulo 2^32 (4294967296 decimal), in + hundredths of a second between two epochs. When a schema + node is defined that uses this type, the description of + the schema node identifies both of the reference epochs. + + In the value set and its semantics, this type is equivalent + to the TimeTicks type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef timestamp { + type yang:timeticks; + description + "The timestamp type represents the value of an associated + timeticks schema node at which a specific occurrence + happened. The specific occurrence must be defined in the + description of any schema node defined using this type. When + the specific occurrence occurred prior to the last time the + associated timeticks attribute was zero, then the timestamp + value is zero. Note that this requires all timestamp values + to be reset to zero when the value of the associated timeticks + attribute reaches 497+ days and wraps around to zero. + + The associated timeticks schema node must be specified + in the description of any schema node using this type. + + In the value set and its semantics, this type is equivalent + to the TimeStamp textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of generic address types ***/ + + typedef phys-address { + type string { + pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'; + } + + description + "Represents media- or physical-level addresses represented + as a sequence octets, each octet represented by two hexadecimal + numbers. Octets are separated by colons. The canonical + representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the PhysAddress textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + typedef mac-address { + type string { + pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}'; + } + description + "The mac-address type represents an IEEE 802 MAC address. + The canonical representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the MacAddress textual convention of the SMIv2."; + reference + "IEEE 802: IEEE Standard for Local and Metropolitan Area + Networks: Overview and Architecture + RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of XML-specific types ***/ + + typedef xpath1.0 { + type string; + description + "This type represents an XPATH 1.0 expression. + + When a schema node is defined that uses this type, the + description of the schema node MUST specify the XPath + context in which the XPath expression is evaluated."; + reference + "XPATH: XML Path Language (XPath) Version 1.0"; + } + + /*** collection of string types ***/ + + typedef hex-string { + type string { + pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'; + } + description + "A hexadecimal string with octets represented as hex digits + separated by colons. The canonical representation uses + lowercase characters."; + } + + typedef uuid { + type string { + pattern '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-' + + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'; + } + description + "A Universally Unique IDentifier in the string representation + defined in RFC 4122. The canonical representation uses + lowercase characters. + + The following is an example of a UUID in string representation: + f81d4fae-7dec-11d0-a765-00a0c91e6bf6 + "; + reference + "RFC 4122: A Universally Unique IDentifier (UUID) URN + Namespace"; + } + + typedef dotted-quad { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'; + } + description + "An unsigned 32-bit number expressed in the dotted-quad + notation, i.e., four octets written as decimal numbers + and separated with the '.' (full stop) character."; + } +} diff --git a/yang/yang-parser-impl/pom.xml b/yang/yang-parser-impl/pom.xml index 9e32fdc6b3..e9bdc0295e 100644 --- a/yang/yang-parser-impl/pom.xml +++ b/yang/yang-parser-impl/pom.xml @@ -98,6 +98,14 @@ org.opendaylight.yangtools rfc8040-parser-support + + org.opendaylight.yangtools + rfc8528-model-api + + + org.opendaylight.yangtools + rfc8528-parser-support + com.google.guava diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java index 03fc317681..2e66f5e329 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java @@ -18,6 +18,7 @@ import org.opendaylight.yangtools.rfc6536.parser.DefaultDenyAllStatementSupport; import org.opendaylight.yangtools.rfc6536.parser.DefaultDenyWriteStatementSupport; import org.opendaylight.yangtools.rfc7952.parser.AnnotationStatementSupport; import org.opendaylight.yangtools.rfc8040.parser.YangDataStatementSupport; +import org.opendaylight.yangtools.rfc8528.parser.MountPointStatementSupport; import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.CustomCrossSourceStatementReactorBuilder; import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; @@ -81,6 +82,9 @@ public final class DefaultReactors { // RFC8040 yang-data support .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, YangDataStatementSupport.getInstance()) + // RFC8528 yang-data support + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MountPointStatementSupport.getInstance()) + // OpenConfig extensions support (except openconfig-version) .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, EncryptedValueStatementSupport.getInstance())