X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2Ftree%2FSchemaAwareApplyOperation.java;h=ae8440ce84db1ec3d3dfed30a43f38fbe16f9080;hb=37380a5c65e213bc5f34b521d8f8e7d315df7465;hp=88ea70f22df755e8c79e0cdb507babff78a7a62b;hpb=8f2876d895936b36aba1fc3ec65b18900e559184;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java index 88ea70f22d..ae8440ce84 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java @@ -7,13 +7,19 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema.tree; -import com.google.common.base.Preconditions; +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Verify.verifyNotNull; + import java.util.List; import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode; +import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode; +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException; @@ -21,50 +27,56 @@ import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version; -import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; +import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode; +import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { +abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class); - public static ModificationApplyOperation from(final DataSchemaNode schemaNode, - final DataTreeConfiguration treeConfig) { - if (treeConfig.getTreeType() == TreeType.CONFIGURATION) { - Preconditions.checkArgument(schemaNode.isConfiguration(), - "Supplied %s does not belongs to configuration tree.", schemaNode.getPath()); + static ModificationApplyOperation from(final DataSchemaNode schemaNode, + final DataTreeConfiguration treeConfig) throws ExcludedDataSchemaNodeException { + if (!belongsToTree(treeConfig.getTreeType(), schemaNode)) { + throw new ExcludedDataSchemaNodeException(schemaNode + " does not belong to configuration tree"); } if (schemaNode instanceof ContainerSchemaNode) { - final ContainerSchemaNode containerSchema = (ContainerSchemaNode) schemaNode; - if (containerSchema.isPresenceContainer()) { - return new PresenceContainerModificationStrategy(containerSchema, treeConfig); - } - - return new StructuralContainerModificationStrategy(containerSchema, treeConfig); + return ContainerModificationStrategy.of((ContainerSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof ListSchemaNode) { return fromListSchemaNode((ListSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof ChoiceSchemaNode) { return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeConfig); } else if (schemaNode instanceof LeafListSchemaNode) { - return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeConfig); + return MinMaxElementsValidation.from(new LeafSetModificationStrategy((LeafListSchemaNode) schemaNode, + treeConfig)); } else if (schemaNode instanceof LeafSchemaNode) { - return new LeafModificationStrategy((LeafSchemaNode) schemaNode); + return new ValueNodeModificationStrategy<>(LeafNode.class, (LeafSchemaNode) schemaNode); + } else if (schemaNode instanceof AnydataSchemaNode) { + return new ValueNodeModificationStrategy<>(AnydataNode.class, (AnydataSchemaNode) schemaNode); + } else if (schemaNode instanceof AnyxmlSchemaNode) { + return new ValueNodeModificationStrategy<>(AnyxmlNode.class, (AnyxmlSchemaNode) schemaNode); + } else if (schemaNode instanceof SchemaContext) { + return new StructuralContainerModificationStrategy((SchemaContext) schemaNode, treeConfig); + } else { + throw new IllegalStateException("Unsupported schema " + schemaNode); } - throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass()); } - public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree, + static AugmentationModificationStrategy from(final DataNodeContainer resolvedTree, final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, final DataTreeConfiguration treeConfig) { - for (final AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { + for (final AugmentationSchemaNode potential : augSchemas.getAvailableAugmentations()) { for (final DataSchemaNode child : potential.getChildNodes()) { if (identifier.getPossibleChildNames().contains(child.getQName())) { return new AugmentationModificationStrategy(potential, resolvedTree, treeConfig); @@ -75,39 +87,27 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { return null; } - public static void checkConflicting(final YangInstanceIdentifier path, final boolean condition, - final String message) throws ConflictingModificationAppliedException { + static void checkConflicting(final ModificationPath path, final boolean condition, final String message) + throws ConflictingModificationAppliedException { if (!condition) { - throw new ConflictingModificationAppliedException(path, message); + throw new ConflictingModificationAppliedException(path.toInstanceIdentifier(), message); } } - private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, + private static ModificationApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final DataTreeConfiguration treeConfig) { final List keyDefinition = schemaNode.getKeyDefinition(); - final SchemaAwareApplyOperation op; + final SchemaAwareApplyOperation op; if (keyDefinition == null || keyDefinition.isEmpty()) { - op = new UnkeyedListModificationStrategy(schemaNode, treeConfig); - } else if (schemaNode.isUserOrdered()) { - op = new OrderedMapModificationStrategy(schemaNode, treeConfig); + op = new ListModificationStrategy(schemaNode, treeConfig); } else { - op = new UnorderedMapModificationStrategy(schemaNode, treeConfig); + op = MapModificationStrategy.of(schemaNode, treeConfig); } - return MinMaxElementsValidation.from(op, schemaNode); - } - private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, - final DataTreeConfiguration treeConfig) { - final SchemaAwareApplyOperation op; - if (schemaNode.isUserOrdered()) { - op = new OrderedLeafSetModificationStrategy(schemaNode, treeConfig); - } else { - op = new UnorderedLeafSetModificationStrategy(schemaNode, treeConfig); - } - return MinMaxElementsValidation.from(op, schemaNode); + return MinMaxElementsValidation.from(op); } - protected static void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, + protected static void checkNotConflicting(final ModificationPath path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { checkConflicting(path, original.getVersion().equals(current.getVersion()), "Node was replaced by other transaction."); @@ -117,13 +117,13 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { protected final ModificationApplyOperation resolveChildOperation(final PathArgument child) { final Optional potential = getChild(child); - Preconditions.checkArgument(potential.isPresent(), "Operation for child %s is not defined.", child); + checkArgument(potential.isPresent(), "Operation for child %s is not defined.", child); return potential.get(); } @Override - final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, - final Optional current, final Version version) throws DataValidationFailedException { + final void checkApplicable(final ModificationPath path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { switch (modification.getOperation()) { case DELETE: checkDeleteApplicable(modification, current); @@ -145,9 +145,37 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } } - protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current, final Version version) throws DataValidationFailedException { - final Optional original = modification.getOriginal(); + @Override + final void quickVerifyStructure(final NormalizedNode writtenValue) { + verifyValue(writtenValue); + } + + @Override + final void fullVerifyStructure(final NormalizedNode writtenValue) { + verifyValue(writtenValue); + verifyValueChildren(writtenValue); + } + + /** + * Verify the a written value, without performing deeper tree validation. + * + * @param writtenValue Written value + */ + abstract void verifyValue(NormalizedNode writtenValue); + + /** + * Verify the children implied by a written value after the value itself has been verified by + * {@link #verifyValue(NormalizedNode)}. Default implementation does nothing. + * + * @param writtenValue Written value + */ + void verifyValueChildren(final NormalizedNode writtenValue) { + // Defaults to no-op + } + + protected void checkMergeApplicable(final ModificationPath path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { + final Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { /* * We need to do conflict detection only and only if the value of leaf changed @@ -155,8 +183,10 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * it should not cause transaction to fail, since result of this merge * leads to same data. */ - if (!original.get().getData().equals(current.get().getData())) { - checkNotConflicting(path, original.get(), current.get()); + final TreeNode orig = original.get(); + final TreeNode cur = current.get(); + if (!orig.getData().equals(cur.getData())) { + checkNotConflicting(path, orig, cur); } } } @@ -171,19 +201,19 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @param current current node in TreeNode for modification to apply * @throws DataValidationFailedException when a data dependency conflict is detected */ - protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current, final Version version) throws DataValidationFailedException { - final Optional original = modification.getOriginal(); + private static void checkWriteApplicable(final ModificationPath path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { + final Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { checkNotConflicting(path, original.get(), current.get()); - } else if (original.isPresent()) { - throw new ConflictingModificationAppliedException(path, "Node was deleted by other transaction."); - } else if (current.isPresent()) { - throw new ConflictingModificationAppliedException(path, "Node was created by other transaction."); + } else { + checkConflicting(path, !original.isPresent(), "Node was deleted by other transaction."); + checkConflicting(path, !current.isPresent(), "Node was created by other transaction."); } } - private static void checkDeleteApplicable(final NodeModification modification, final Optional current) { + private static void checkDeleteApplicable(final NodeModification modification, + final Optional current) { // Delete is always applicable, we do not expose it to subclasses if (!current.isPresent()) { LOG.trace("Delete operation turned to no-op on missing node {}", modification); @@ -191,12 +221,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } @Override - protected ChildTrackingPolicy getChildPolicy() { - return ChildTrackingPolicy.UNORDERED; - } - - @Override - final Optional apply(final ModifiedNode modification, final Optional currentMeta, + Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { switch (modification.getOperation()) { case DELETE: @@ -205,8 +230,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { : ModificationType.UNMODIFIED); return modification.setSnapshot(Optional.empty()); case TOUCH: - Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", - modification); + checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", modification); return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(), version))); case MERGE: @@ -217,8 +241,8 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { // structure is usually verified when the transaction is sealed. To preserve correctness, we have // to run that validation here. modification.resolveModificationType(ModificationType.WRITE); - result = applyWrite(modification, currentMeta, version); - verifyStructure(result.getData(), true); + result = applyWrite(modification, modification.getWrittenValue(), currentMeta, version); + fullVerifyStructure(result.getData()); } else { result = applyMerge(modification, currentMeta.get(), version); } @@ -226,7 +250,8 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { return modification.setSnapshot(Optional.of(result)); case WRITE: modification.resolveModificationType(ModificationType.WRITE); - return modification.setSnapshot(Optional.of(applyWrite(modification, currentMeta, version))); + return modification.setSnapshot(Optional.of(applyWrite(modification, + verifyNotNull(modification.getWrittenValue()), currentMeta, version))); case NONE: modification.resolveModificationType(ModificationType.UNMODIFIED); return currentMeta; @@ -247,7 +272,8 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { */ protected abstract TreeNode applyMerge(ModifiedNode modification, TreeNode currentMeta, Version version); - protected abstract TreeNode applyWrite(ModifiedNode modification, Optional currentMeta, Version version); + protected abstract TreeNode applyWrite(ModifiedNode modification, NormalizedNode newValue, + Optional currentMeta, Version version); /** * Apply a nested operation. Since there may not actually be a nested operation @@ -271,8 +297,14 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @throws org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException If subtree * modification is not applicable (e.g. leaf node). */ - protected abstract void checkTouchApplicable(YangInstanceIdentifier path, NodeModification modification, - Optional current, Version version) throws DataValidationFailedException; + protected abstract void checkTouchApplicable(ModificationPath path, NodeModification modification, + Optional current, Version version) throws DataValidationFailedException; + + /** + * Return the {@link WithStatus}-subclass schema associated with this operation. + * @return A model node + */ + abstract @NonNull T getSchema(); /** * Checks if supplied schema node belong to specified Data Tree type. All nodes belong to the operational tree, @@ -282,7 +314,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @param node Schema node * @return {@code true} if the node matches the tree type, {@code false} otherwise. */ - static boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) { + static final boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) { return treeType == TreeType.OPERATIONAL || node.isConfiguration(); } }